Add bin and edit workflow

bin/gems/facets-3.1.0/test/core/module/test_abstract.rb

@@ -0,0 +1,24 @@
+covers 'facets/module/abstract'
+
+test_case Module do
+
+  method :abstract do
+
+    test "in a module" do
+      m = Module.new{ abstract :q }
+      c = Class.new{ include m }
+      x = c.new
+      TypeError.assert.raised?{ x.q }
+    end
+
+    test "in a class" do
+      c = Class.new{ abstract :q }
+      #c.pry.abstract :q
+      x = c.new
+      TypeError.assert.raised?{ x.q }
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/module/test_alias_accessor.rb

@@ -0,0 +1,27 @@
+covers 'facets/module/alias_accessor'
+
+test_case Module do
+
+  method :alias_accessor do
+
+    test do
+      c = Class.new do
+        attr_accessor :x
+        alias_accessor :y, :x
+      end
+
+      x = c.new
+
+      x.x = 10
+      x.x.assert == 10
+      x.y.assert == 10
+
+      x.y = 20
+      x.x.assert == 20
+      x.y.assert == 20
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/module/test_alias_method_chain.rb

@@ -0,0 +1,34 @@
+covers 'facets/module/alias_method_chain'
+
+test_case Module do
+
+  method :alias_method_chain do
+
+    test do
+      x = Module.new do
+        def self.included(base)
+          base.module_eval {
+            alias_method_chain :foo, :feature
+          }
+        end
+        def foo_with_feature
+          foo_without_feature + '!'
+        end
+      end
+
+      y = Class.new do
+        def foo
+          "FOO"
+        end
+        include x
+      end
+
+      iy = y.new
+
+      iy.foo.assert == "FOO!"
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/module/test_alias_module_function.rb

@@ -0,0 +1,24 @@
+covers 'facets/module/alias_module_function'
+
+test_case Module do
+
+  method :alias_module_function do
+
+    test do
+      m = Module.new do
+        def x ; 33 ; end
+
+        module_function :x
+
+        alias_module_function :y, :x
+      end
+
+      m.y.assert == 33
+
+      # use send b/c private?
+      #@m.send(:y).assert == 33
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/module/test_all_instance_methods.rb

@@ -0,0 +1,27 @@
+covers 'facets/module/all_instance_methods'
+
+test_case Module do
+
+  method :all_instance_methods do
+
+    test do
+      c = Class.new do
+        def x; "x"; end
+        private
+        def y; "y"; end
+        protected
+        def z; "z"; end
+      end
+
+      list = c.all_instance_methods(false)
+
+      list.map!{ |m| m.to_sym } # b/c of diff in 1.8 vs 1.9
+
+      list.assert.include?(:x)
+      list.assert.include?(:y)
+      list.assert.include?(:z)
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/module/test_ancestor.rb

@@ -0,0 +1,16 @@
+covers 'facets/module/ancestor'
+
+test_case Module do
+
+  method :ancestor? do
+
+    test do
+      c1 = Class.new
+      c2 = Class.new(c1)
+      c2.assert.ancestor?(c1)
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/module/test_anonymous.rb

@@ -0,0 +1,18 @@
+covers 'facets/module/anonymous'
+
+test_case Module do
+
+  method :anonymous? do
+
+    test do
+      m = Module.new
+      m.assert.anonymous?
+    end
+
+    test do
+      Lemon.refute.anonymous?
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/module/test_attr_setter.rb

@@ -0,0 +1,28 @@
+covers 'facets/module/attr_setter'
+
+test_case Module do
+
+  method :attr_setter do
+
+    test do
+      c = Class.new do
+        attr_setter :a
+      end
+      x = c.new
+      x.a(1)
+      x.a.assert == 1
+    end
+
+    test do  
+      c = Class.new do
+        attr_setter :a
+        alias_setter :b, :a
+      end
+      x = c.new
+      x.b(1)
+      x.a.assert == 1
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/module/test_basename.rb

@@ -0,0 +1,14 @@
+covers 'facets/module/basename'
+
+test_case Module do
+
+  method :basename do
+
+    test do
+      Lemon::TestCase.basename.assert == "TestCase"
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/module/test_can.rb

@@ -0,0 +1,22 @@
+covers 'facets/module/can'
+
+test_case Module do
+
+  method :can do
+
+    test do
+      m = Module.new do
+        def x; "x"; end 
+      end
+
+      c = Class.new do
+        can m
+      end
+
+      c.x.assert == "x"
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/module/test_class.rb

@@ -0,0 +1,22 @@
+covers 'facets/module/class'
+
+test_case Module do
+
+  method :class? do
+
+    test do
+      x_class = Class.new
+      y_class = Class.new(x_class)
+
+      x = x_class.new
+      y = y_class.new
+
+      x_class.assert.class?(x)
+      y_class.assert.class?(y)
+      y_class.assert.class?(y)
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/module/test_class_def.rb

@@ -0,0 +1,22 @@
+covers 'facets/module/class_def'
+
+test_case Module do
+
+  method :class_def do
+
+    test do
+      m = Module.new
+      m.class_def(:x){"x"}
+      c = Class.new{ include m }
+      c.new.x.assert == "x"
+    end
+
+    test do
+      c = Class.new
+      c.class_def(:x){"x"}
+      c.new.x.assert == "x"
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/module/test_class_extend.rb

@@ -0,0 +1,73 @@
+covers 'facets/module/class_extend'
+
+test_case Module do
+
+  method :class_extend do
+
+    setup "module using class_extend" do
+      @mod = Module.new do
+              def i ; end
+              class_extend do
+                def n ; 42   ; end
+                def s ; self ; end
+              end
+            end
+    end
+
+    test "extends module" do
+      @mod.n.assert == 42
+      @mod.s.assert == @mod
+    end
+
+    test "has expected methods" do
+      @mod.instance_methods.map{ |m| m.to_s }.assert == ['i']
+    end
+
+    test "transfers class methods to including class" do
+      mod = @mod
+      mod = Module.new do
+        include mod
+      end
+      mod.n.assert == 42
+      mod.s.assert == mod
+    end
+
+    test "doesn't overwrite instance methods" do
+      mod = @mod
+      c = Class.new do
+        include mod
+        def n ; 11 ; end
+      end
+      c.new.n.assert == 11
+    end
+
+    test "is overridable via including module" do
+      mod = @mod
+      m = Module.new do
+        include mod
+        class_extend do
+          def n ; super + 1 ; end
+        end
+      end
+      m.n.assert == 43  # notice the difference!
+      m.s.assert == m
+    end
+
+    test "transfers class methods thru multiple levels of include" do
+      mod = @mod
+      a = Module.new do
+        include mod
+        class_extend do
+          def n ; super + 1 ; end
+        end
+      end
+      m = Module.new do
+        include a
+      end
+      m.n.assert == 43
+      m.s.assert == m
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/module/test_class_inheritor.rb

@@ -0,0 +1,135 @@
+covers 'facets/module/class_inheritor'
+
+test_case Class do
+
+  method :class_inheritor do
+
+    test "subclass with inheritor" do
+      c1 = Class.new do
+        class_inheritor :koko, [], :+
+        koko! << 1
+      end
+      c2 = Class.new(c1) do
+        class_inheritor :koko, [], :+
+        koko! << 2
+      end
+
+      c1.koko!.assert == [1]
+      c1.koko.assert  == [1]
+      c2.koko!.assert == [2]
+      c2.koko.assert  == [1,2]
+    end
+
+    test "subclass without inheritor" do
+      c1 = Class.new do
+        class_inheritor :koko, [], :+
+        koko! << 1
+      end
+      c2 = Class.new(c1)
+
+      c1.koko!.assert == [1]
+      c1.koko.assert  == [1]
+      c2.koko!.assert == []
+      c2.koko.assert  == [1]
+    end
+
+    test "include module with inheritor" do
+      c1 = Class.new do
+        class_inheritor :x, {}, :merge
+        x![:a] = 1
+      end
+      m1 = Module.new do
+        class_inheritor :x, {}, :merge
+        x![:b] = 2
+      end
+      c2 = Class.new(c1) do
+        include m1
+        class_inheritor :x, {}, :merge
+        x![:c] = 3
+      end
+
+      c1.x.assert == {:a=>1}
+
+      m1.x[:b].assert == 2
+
+      c2.x.assert == {:a=>1,:b=>2,:c=>3}
+
+      c1.x[:a].assert == 1
+      c1.x[:b].assert == nil
+      c1.x[:c].assert == nil
+
+      c2.x[:a].assert == 1
+      c2.x[:b].assert == 2
+      c2.x[:c].assert == 3
+
+      c2.x![:d] = 4
+      c2.x[:d].assert == 4
+    end
+
+    test "using #concat as the inheritor operator" do
+      c1 = Class.new do
+        class_inheritor :relations, [], :concat
+      end
+      c2 = Class.new(c1) do
+        #class_inheritor :relations, [], :concat
+      end
+      c1.relations! << 1
+      c1.relations! << 2
+      c2.relations! << 3
+
+      c1.relations.assert == [1,2]
+      c2.relations.assert == [1,2,3]
+    end
+
+  end
+
+end
+
+test_case Module do
+
+  method :class_inheritor do
+
+    test do
+      m1 = Module.new do
+        class_inheritor :koko, [], :+
+        koko! << 1
+      end
+      c1 = Class.new do
+        include m1
+        #inheritor :koko, [], :+
+        koko! << 2
+        koko! << 3
+      end
+      c2 = Class.new do
+        include m1
+        #inheritor :koko, [], :+
+        koko! << 4
+      end
+
+      m1.koko.assert  == [1]
+      c1.koko.assert == [1,2,3]
+      c2.koko.assert == [1,4]
+    end
+
+  end
+
+end
+
+=begin
+Test.class Inheritor do
+  setup do
+    a = [1]
+    @i = Inheritor.new(a, [2], :+)
+  end
+  method :== do
+    test do
+      @i.assert == [2]
+    end
+  end
+  method :inheritance do
+    test do
+      @i.inheritance == [1,2]
+    end
+  end
+end
+=end

bin/gems/facets-3.1.0/test/core/module/test_copy_inheritor.rb

@@ -0,0 +1,35 @@
+covers 'facets/module/copy_inheritor'
+
+test_case Module do
+
+  method :copy_inheritor do
+
+    setup do
+      m1 = Module.new do
+        copy_inheritor :koko, []
+        koko << 1
+      end
+      c1 = Class.new do
+        include m1
+        #inheritor :koko, [], :+
+        koko << 2
+        koko << 3
+      end
+      c2 = Class.new do
+        include m1
+        #inheritor :koko, [], :+
+        koko << 4
+      end
+      @m1, @c1, @c2 = m1, c1, c2
+    end
+
+    test do
+      @m1.koko.assert == [1]
+      @c1.koko.assert == [1,2,3]
+      @c2.koko.assert == [1,4]
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/module/test_enclosure.rb

@@ -0,0 +1,24 @@
+covers 'facets/module/enclosure'
+covers 'facets/module/enclosures'
+
+test_case Module do
+
+  method :enclosure do
+    test do
+      Lemon::TestCase.enclosure.assert == Lemon
+    end
+
+    test "anonymous module" do
+      m = Module.new
+      m.enclosure.assert == Object
+    end
+  end
+
+  method :enclosures do
+    test do
+      Lemon::TestCase.enclosures.assert == [Lemon, Object]
+    end
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/module/test_instance_function.rb

@@ -0,0 +1,30 @@
+covers 'facets/module/instance_function'
+
+test_case Module do
+
+  method :instance_function do
+
+    setup "using instance_function" do
+      @m = Module.new do
+        instance_function
+        def self.jumble(obj, arg)
+          obj + arg
+        end
+      end
+    end
+
+    test "class method" do
+      r = @m.jumble('Try', 'Me')
+      r.assert == 'TryMe'
+    end
+
+    test "instance method" do
+      s = 'Try'
+      s.extend @m
+      r = s.jumble('Me')
+      r.assert == 'TryMe'
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/module/test_instance_method.rb

@@ -0,0 +1,20 @@
+covers 'facets/module/instance_method'
+
+test_case Module do
+
+  method :instance_method! do
+
+    test do
+      c = Class.new do
+        def x; "x"; end
+      end
+
+      x1 = c.instance_method!(:x)
+      x2 = c.instance_method!(:x)
+
+      x1.object_id.assert == x2.object_id
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/module/test_instance_method_defined.rb

@@ -0,0 +1,38 @@
+covers 'facets/module/instance_method_defined'
+
+test_case Module do
+
+  method :instance_method_defined? do
+
+    test do
+      c = Class.new do
+        def x; "x"; end
+      end
+      c.assert.instance_method_defined?(:x)
+    end
+
+  end
+
+  method :singleton_method_defined? do
+
+    test do
+      c = Class.new do
+        def self.x; "x"; end
+      end
+      c.assert.singleton_method_defined?(:x)
+    end
+
+  end
+
+  method :module_method_defined? do
+
+    test "alias for #singleton_method_defined" do
+      c = Class.new do
+        def self.x; "x"; end
+      end
+      c.assert.module_method_defined?(:x)
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/module/test_integrate.rb

@@ -0,0 +1,28 @@
+covers 'facets/module/integrate'
+
+test_case Module do
+
+  method :integrate do
+
+    test do
+      m = Module.new do
+        def x ; 1 ; end
+      end
+
+      c = Class.new do
+        integrate m do
+          rename :y, :x
+        end
+      end
+
+      ic = c.new
+
+      NoMethodError.assert.raised?{ ic.x }
+
+      ic.y.assert == 1
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/module/test_is.rb

@@ -0,0 +1,50 @@
+covers 'facets/module/is'
+
+test_case Module do
+
+  method :is? do
+
+    test do
+      m = Module.new
+      x = Class.new
+      y = Class.new(x) do
+        is m
+      end
+
+      y.assert.is?(x)
+      y.assert.is?(m)
+    end
+
+  end
+
+  method :is do
+
+    test do
+      m = Module.new do
+        def q; "q"; end
+      end
+      x = Class.new do
+        is m
+      end
+      x.new.q.assert == "q"
+    end
+
+    # Note, we dynamically set the Self constant to avoid a named module
+    # showing up as an uncovered namespace in the Lemon coverage report.
+    test do
+      m = Module.new do
+        s = Module.new do
+          def q; "q"; end
+        end
+        const_set('Self', s)
+      end
+      x = Class.new do
+        is m
+      end
+      x.q.assert == "q"
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/module/test_memoize.rb

@@ -0,0 +1,33 @@
+covers 'facets/module/memoize'
+
+test_case Module do
+
+  method :memoize  do
+
+    test do
+      tc = Class.new do
+        def initialize(a)
+          @a = a
+        end
+        def a
+          "#{@a ^ 3 + 4}"
+        end
+        memoize :a
+      end
+
+      t1 = tc.new(1)
+      t2 = tc.new(2)
+      t3 = tc.new(3)
+
+      t1.a.assert == "6"
+      t2.a.assert == "5"
+      t3.a.assert == "4"
+
+      t1.a.__id__.assert == t1.a.__id__
+      t2.a.__id__.assert == t2.a.__id__
+      t3.a.__id__.assert == t3.a.__id__
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/module/test_method_clash.rb

@@ -0,0 +1,59 @@
+covers 'facets/module/method_clash'
+
+test_case Module do
+
+  setup do
+    @x = Class.new do
+      def q1; "q1"; end
+      def x1; "x1"; end
+      def r1; "r1"; end
+      private
+      def q2; "q2"; end
+      def x2; "x1"; end
+      protected
+      def q3; "q3"; end
+      def x3; "x3"; end
+    end
+
+    @y = Class.new do
+      def q1; "q1"; end
+      def y1; "y1"; end
+      private
+      def q2; "q2"; end
+      def y2; "y2"; end
+      def r1; "r1"; end
+      protected
+      def q3; "q3"; end
+      def y3; "y3"; end
+    end
+
+    @z = Class.new
+  end
+
+  method :method_clash? do
+
+    test do
+      @x.assert.method_clash?(@y)
+      @y.assert.method_clash?(@x)
+      @z.refute.method_clash?(@x)
+      @x.refute.method_clash?(@z)
+    end
+
+  end
+
+  method :method_clash do
+
+    test do
+      c = @x.method_clash(@y)
+      c.map!{ |m| m.to_s }
+      %w{r1 q1 q2 q3}.each do |x|
+        c.assert.include?(x)
+      end
+      %w{x1 x2 x3 y1 y2 y3}.each do |x|
+        c.refute.include?(x)
+      end
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/module/test_method_space.rb

@@ -0,0 +1,72 @@
+covers 'facets/module/method_space'
+
+test_case Class do
+
+  method :method_space do
+
+    test "via a block" do
+      c = Class.new do
+        def x; "x"; end
+        method_space :s do
+          def x; "sx"; end
+        end
+      end
+      o = c.new
+      o.x.assert == 'x'
+      o.s.x.assert == 'sx'
+    end
+
+    test "via module" do
+      M = Module.new do
+        def x; "mx"; end
+      end
+      c = Class.new do
+        def x; "x"; end
+        method_space M
+      end
+      o = c.new
+      o.x.assert == 'x'
+      o.m.x.assert == 'mx'
+    end
+
+    test "instance method is not defined" do
+      c = Class.new do
+        method_space :s do
+          def x; "sx"; end
+        end
+      end
+      o = c.new
+      expect(NoMethodError){ c.x }
+    end
+
+  end
+
+  method :include_as do
+
+    setup do
+      m = Module.new do
+        def x; "x"; end
+        def y; @y; end
+      end
+      @c = Class.new do
+        include_as :m => m
+        def initialize
+          @y = "y"
+        end
+      end
+    end
+
+    test "provides method space" do
+      o = @c.new
+      o.m.x.assert == "x"
+    end
+
+    test "has access to instance scope" do
+      o = @c.new
+      o.m.y.assert == "y"
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/module/test_methodize.rb

@@ -0,0 +1,26 @@
+covers 'facets/module/methodize'
+
+test_case Module do
+
+  method :methodize do
+
+    test do
+      Lemon.methodize.assert == 'lemon'
+    end
+
+  end
+
+end
+
+test_case Class do
+
+  method :methodize do
+
+    test do
+      Lemon::TestCase.methodize.assert == 'lemon__test_case'
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/module/test_modname.rb

@@ -0,0 +1,13 @@
+covers 'facets/module/modname'
+
+test_case Module do
+
+  method :modname do
+
+    test do
+      Lemon::TestCase.modname.assert == "Lemon"
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/module/test_module_def.rb

@@ -0,0 +1,22 @@
+covers 'facets/module/module_def'
+
+test_case Module do
+
+  method :module_def do
+
+    test do
+      m = Module.new
+      m.module_def(:x){"x"}
+      c = Class.new{ include m }
+      c.new.x.assert == "x"
+    end
+
+    test do
+      c = Class.new
+      c.module_def(:x){"x"}
+      c.new.x.assert == "x"
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/module/test_module_load.rb

@@ -0,0 +1,23 @@
+covers 'facets/module/module_load'
+
+test_case Module do
+
+  # TODO: write tests for module_load
+
+  skip "need to use a ruby fixture file to test module_load.rb" do
+
+    method :module_load do
+    end
+
+    method :module_require do
+    end
+
+    method :class_load do
+    end
+
+    method :class_require do
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/module/test_nodef.rb

@@ -0,0 +1,19 @@
+covers 'facets/module/nodef'
+
+test_case Module do
+
+  method :nodef do
+
+    test do
+      c = Class.new do
+        def the_undefined_method ; 'not here' ; end
+        nodef :the_undefined_method
+      end
+
+      c.new.refute.respond_to?(:the_undefined_method)
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/module/test_op.rb

@@ -0,0 +1,56 @@
+covers 'facets/module/op.rb'
+
+test_case Module do
+
+  setup do
+    @a = Module.new do
+      def x; "x"; end
+      def z; "zA"; end
+    end
+
+    @b = Module.new do
+      def y; "y"; end
+      def z; "zB"; end
+    end
+  end
+
+  method :+ do
+
+    test do
+      q = @a + @b
+      q.extend q
+
+      q.x.assert == "x"
+      q.y.assert == "y"
+      q.z.assert == "zB"
+    end
+
+  end
+
+  method :- do
+
+    test do
+      r = @a - @b
+      r.extend r
+
+      r.x.assert == "x"
+      NoMethodError.assert.raised?{ r.z }
+    end
+
+  end
+
+  method :* do
+
+    test do
+      z = @a * { :x => :y }
+      z.extend z
+
+      z.y.assert == "x"
+      z.z.assert == "zA"
+      NoMethodError.assert.raised?{ z.x }
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/module/test_pathize.rb

@@ -0,0 +1,25 @@
+covers 'facets/module/pathize'
+
+test_case Module do
+
+  method :pathize do
+
+    test do
+      Lemon.pathize.assert == 'lemon'
+    end
+
+  end
+
+end
+
+test_case Class do
+
+  method :pathize do
+
+    test do
+      Lemon::TestCase.pathize.assert == 'lemon/test_case'
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/module/test_preextend.rb

@@ -0,0 +1,26 @@
+covers 'facets/module/preextend'
+
+test_case Module do
+
+  method :preextend do
+
+    test "module method" do
+      m = Module.new do
+        def q; "qm"; end
+      end
+
+      n = Module.new do
+        preextend m
+        def q; "qn"; end
+      end
+
+      x = Class.new do
+        include n
+      end
+
+      n.q.assert == "qm"
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/module/test_redefine_method.rb

@@ -0,0 +1,30 @@
+covers 'facets/module/redefine_method'
+
+test_case Module do
+
+  method :redefine_method do
+
+    test do
+      c = Class.new do
+        def a; "a"; end
+        redefine_method(:a){ nil }
+      end
+      c.new.a.assert == nil
+    end
+
+  end
+
+  method :redef do
+
+    test do
+      c = Class.new do
+        def b; "b"; end
+        redef(:b){ "x" }
+      end
+      c.new.b.assert == "x"
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/module/test_redirect_method.rb

@@ -0,0 +1,32 @@
+covers 'facets/module/redirect_method'
+
+test_case Module do
+
+  method :redirect_method do
+
+    test do
+      c = Class.new do
+        def a1 ; 1 ; end
+        redirect_method :a2 => :a1
+      end
+
+      c.new.a2.assert == 1
+    end
+
+  end
+
+  method :redirect do
+
+    test do
+      c = Class.new do
+        def b1 ; 1 ; end
+        redirect :b2 => :b1
+      end
+
+      c.new.b2.assert == 1
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/module/test_remove.rb

@@ -0,0 +1,18 @@
+covers 'facets/module/remove'
+
+test_case Module do
+
+  method :remove do
+
+    test do
+      c = Class.new do
+        def the_removed_method ; 'not here' ; end
+        remove :the_removed_method
+      end
+
+      c.new.refute.respond_to?(:the_removed_method)
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/module/test_rename_method.rb

@@ -0,0 +1,34 @@
+covers 'facets/module/rename_method'
+
+test_case Module do
+
+  method :rename_method do
+
+    test do
+      c = Class.new do
+        def a; "A" ; end
+        rename_method :b, :a
+      end
+
+      c.new.refute.respond_to?(:a)
+      c.new.assert.respond_to?(:b)
+    end
+
+  end
+
+  method :rename do
+
+    test do
+      c = Class.new do
+        def c; "C" ; end
+        rename :d, :c
+      end
+
+      c.new.refute.respond_to?(:c)
+      c.new.assert.respond_to?(:d)
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/module/test_revise.rb

@@ -0,0 +1,61 @@
+covers 'facets/module/revise'
+
+test_case Module do
+
+  method :revisal do
+
+    test do
+      m = Module.new do
+        def x ; 1 ; end
+      end
+
+      c = Class.new do
+        include m.revisal {
+          rename :y, :x
+        }
+      end
+
+      ic = c.new
+
+      ic.y.assert == 1
+      NoMethodError.assert.raised?{ ic.x }
+    end
+
+  end
+
+  method :revise do
+
+    test do
+      m = Module.new do
+        def x ; 1 ; end
+      end
+
+      c = Class.new do
+        include m.revise {
+          rename :y, :x
+        }
+      end
+
+      ic = c.new
+
+      ic.y.assert == 1
+      NoMethodError.assert.raised?{ ic.x }
+    end
+
+  end
+
+  method :remove do
+
+    test do
+      c = Class.new do
+        def the_removed_method ; 'not here' ; end
+        remove :the_removed_method
+      end
+
+      c.new.refute.respond_to?(:the_removed_method)
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/module/test_set.rb

@@ -0,0 +1,30 @@
+covers 'facets/module/set'
+
+test_case Module do
+
+  method :set do
+
+    test do
+      c = Class.new do
+        set :x, 10
+      end
+
+      c.x.assert == 10
+    end
+
+    test do
+      h = 1
+      c = Class.new do
+        set :x do 
+          h += 1
+        end
+      end
+
+      c.x.assert == 2
+      c.x.assert == 3
+      c.x.assert == 4
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/module/test_spacename.rb

@@ -0,0 +1,15 @@
+covers 'facets/module/spacename'
+
+test_case Module do
+
+  method :spacename do
+
+    test do
+      Lemon::TestCase.spacename.assert == 'Lemon'
+      Lemon.spacename.assert == ''  # should this be nil ?
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/module/test_to_obj.rb

@@ -0,0 +1,20 @@
+covers 'facets/module/to_obj'
+
+test_case Module do
+
+  method :to_obj do
+
+    test do
+      m = Module.new do
+        def x; "x"; end
+        def y; "y"; end
+      end
+      o = m.to_obj
+      o.x.assert == "x"
+      o.y.assert == "y"
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/module/test_wrap_method.rb

@@ -0,0 +1,32 @@
+covers 'facets/module/wrap_method'
+
+test_case Module do
+
+  method :wrap_method do
+
+    test do
+      c = Class.new do
+        def a; "A"; end
+        wrap_method(:a) { |old| old.call + "B" }
+      end
+
+      c.new.a.assert == "AB"
+    end
+
+  end
+
+  method :wrap do
+
+    test do
+      c = Class.new do
+        def b; "B"; end
+        wrap(:b) { |old| old.call + "C" }
+      end
+
+      c.new.b.assert == "BC"
+    end
+
+  end
+
+end
+