facets 3.1.0 → 3.2.0

data/test/core/method/test_composition.rb

@@ -1,42 +0,0 @@
-covers 'facets/method/composition'
-
-test_case Method do
-
-  c = Class.new do
-    def f(x); x * 3; end
-    def g(x); x + 1; end
-  end
-
-  method :* do
-
-    test do
-      x = c.new
-      f = x.method(:f) * x.method(:g)
-      f.call(1).assert == 6
-    end
-
-    test do
-      x = c.new
-      f = x.method(:g) * x.method(:f)
-      f.call(1).assert == 4
-    end
-
-  end
-
-  method :^ do
-
-    test do
-      x = c.new
-      f = x.method(:f) ^ 3
-      f.call(1).assert == 27
-    end
-
-    test do
-      x = c.new
-      f = x.method(:g) ^ 3
-      f.call(1).assert == 4
-    end
-
-  end
-
-end

data/test/core/module/test_abstract.rb

@@ -1,24 +0,0 @@
-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
-

data/test/core/module/test_alias_accessor.rb

@@ -1,27 +0,0 @@
-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
-

data/test/core/module/test_alias_method_chain.rb

@@ -1,34 +0,0 @@
-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
-

data/test/core/module/test_alias_module_function.rb

@@ -1,24 +0,0 @@
-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

data/test/core/module/test_all_instance_methods.rb

@@ -1,27 +0,0 @@
-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

data/test/core/module/test_ancestor.rb

@@ -1,16 +0,0 @@
-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
-

data/test/core/module/test_anonymous.rb

@@ -1,18 +0,0 @@
-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

data/test/core/module/test_attr_setter.rb

@@ -1,28 +0,0 @@
-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

data/test/core/module/test_basename.rb

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

data/test/core/module/test_can.rb

@@ -1,22 +0,0 @@
-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
-

data/test/core/module/test_class.rb

@@ -1,22 +0,0 @@
-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
-

data/test/core/module/test_class_def.rb

@@ -1,22 +0,0 @@
-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

data/test/core/module/test_class_extend.rb

@@ -1,73 +0,0 @@
-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

data/test/core/module/test_class_inheritor.rb

@@ -1,135 +0,0 @@
-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

data/test/core/module/test_copy_inheritor.rb

@@ -1,35 +0,0 @@
-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
-

data/test/core/module/test_enclosure.rb

@@ -1,24 +0,0 @@
-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
-

data/test/core/module/test_instance_function.rb

@@ -1,30 +0,0 @@
-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

data/test/core/module/test_instance_method.rb

@@ -1,20 +0,0 @@
-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

data/test/core/module/test_instance_method_defined.rb

@@ -1,38 +0,0 @@
-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