facets 3.0.0 → 3.2.0

data/test/core/kernel/test_respond.rb

@@ -1,38 +0,0 @@
-covers 'facets/kernel/respond'
-
-test_case Kernel do
-
-  method :respond do
-
-    test do
-      c = Class.new do
-        def f; "f"; end
-      end
-    
-      x = c.new
-      x.respond(:f).assert == "f"
-      x.respond(:g).assert == nil
-
-      x.respond.f.assert == "f"
-      x.respond.g.assert == nil
-    end
-
-  end
-
-  #
-  #method :respond_with_value do
-  #  test do
-  #    c = Class.new do
-  #      def f; "f"; end
-  #    end
-  #
-  #    x = c.new
-  #    x.respond_with_value(:f).assert == "f"
-  #    x.respond_with_value(:g).assert == nil
-  #
-  #    x.respond_with_value.f.assert == "f"
-  #    x.respond_with_value.g.assert == nil
-  #  end
-  #end
-
-end

data/test/core/kernel/test_returning.rb

@@ -1,17 +0,0 @@
-covers 'facets/kernel/returning'
-
-test_case Kernel do
-
-  method :returning do
-
-    test do
-      foo = returning( values = [] ) do
-        values << 'bar'
-        values << 'baz'
-      end
-      foo.assert == ['bar', 'baz']
-    end
-
-  end
-
-end

data/test/core/kernel/test_silence.rb

@@ -1,24 +0,0 @@
-covers 'facets/kernel/silence'
-
-test_case Kernel do
-
-  # TODO: figure out how to test silence methods
-
-  concern "Not straight foward to test since they effect output."
-
-  method :silence do
-  end
-
-  method :silence_stream do
-  end
-
-  method :silence_stderr do
-  end
-
-  method :silence_stdout do
-  end
-
-  method :silently do
-  end
-
-end

data/test/core/kernel/test_singleton_class.rb

@@ -1,15 +0,0 @@
-covers 'facets/kernel/singleton_class'
-
-test_case Kernel do
-
-  method :singleton_class do
-
-    test do
-      x = Class.new
-      m = (class << x; self; end)
-      x.singleton_class.assert == m
-    end
-
-  end
-
-end

data/test/core/kernel/test_super_method.rb

@@ -1,23 +0,0 @@
-covers 'facets/kernel/super_method'
-
-test_case Kernel do
-
-  method :super_method do
-
-    setup "class heirarchy" do
-      @x = Class.new{ def x ; 1 ; end }
-      @y = Class.new(@x){ def x ; 2 ; end }
-      @z = Class.new(@y){ def x ; 3 ; end }
-    end
-
-    test do
-      x = @x.new
-      z = @z.new
-      s0 = x.method(:x)
-      s1 = z.super_method(@x, :x)
-      s1.call.assert == s0.call
-    end
-
-  end
-
-end

data/test/core/kernel/test_tap.rb

@@ -1,38 +0,0 @@
-covers 'facets/kernel/tap'
-
-test_case Kernel do
-
-  method :tap do
-
-    test do
-      e = "foo"
-      r = "foobar".tap{ |x| x.gsub!(/bar/, '') }
-      r.assert == e
-    end
-
-    test "check internal value" do
-      x = [1,2,3]
-      x.tap{ |a|
-        a.assert == x
-      }
-    end
-
-    test "assign via tap block" do
-      bob = Struct.new(:name, :address, :zip).new
-
-      x = lambda do |s|
-        s.name    = "Bob Sawyer"
-        s.address = "123 Maple, Anytown NC"
-        s.zip     = "12345" 
-      end
-
-      bob.tap(&x)
-
-      bob.name.assert == "Bob Sawyer"
-      bob.address.assert == "123 Maple, Anytown NC"
-      bob.zip.assert == "12345"
-    end
-
-  end
-
-end

data/test/core/kernel/test_temporarily.rb

@@ -1,25 +0,0 @@
-covers 'facets/kernel/temporarily'
-
-test_case Kernel do
-
-  method :temporarily do
-
-    test "global variable" do
-      $temporary_variable = true
-      temporarily('$temporary_variable'=>false) do
-        $temporary_variable.assert == false
-      end
-      $temporary_variable.assert == true
-    end
-
-    test "instance variable" do
-      @x = 1
-      temporarily('@x'=>2) do
-        @x.assert == 2
-      end
-      @x.assert == 1
-    end
-
-  end
-
-end

data/test/core/kernel/test_true.rb

@@ -1,31 +0,0 @@
-covers 'facets/kernel/true'
-
-test_case Kernel do
-
-  method :true? do
-
-    test "nothing is true? but true itself" do
-      true.assert.true?
-
-      nil.refute.true?
-      false.refute.true?
-      1.refute.true?
-      :a.refute.true?
-    end
-
-  end
-
-  method :false? do
-
-    test "nothing is false? but false itself" do
-      false.assert.false?
-
-      nil.refute.false?
-      true.refute.false?
-      1.refute.false?
-      :a.refute.false?
-    end
-
-  end
-
-end

data/test/core/kernel/test_try.rb

@@ -1,35 +0,0 @@
-covers 'facets/kernel/try'
-
-test_case Kernel do
-
-  method :try do
-
-    test do
-      example = Struct.new(:name).new("bob")
-      example.try(:name).assert == "bob"
-    end
-
-    test "without argument" do
-      example = Struct.new(:name).new("bob")
-      example.try.name.assert == "bob"
-    end
-
-  end
-
-end
-
-test_case NilClass do
-
-  method :try do
-
-    test do
-      nil.try(:name).assert == nil
-    end
-
-    test "without argument" do
-      nil.try.name.assert == nil
-    end
-
-  end
-
-end

data/test/core/kernel/test_val.rb

@@ -1,30 +0,0 @@
-covers 'facets/kernel/val'
-
-test_case Kernel do
-
-  method :val? do
-
-    test "of nil" do
-      f = nil
-      t = 1
-      f.refute.val?
-      t.assert.val?
-    end
-
-    test "of empty array" do
-      f = []
-      t = [1]
-      f.refute.val?
-      t.assert.val?
-    end
-
-    test "of empty string" do
-      f = ''
-      t = '1'
-      f.refute.val?
-      t.assert.val? 
-    end
-
-  end
-
-end

data/test/core/kernel/test_with.rb

@@ -1,18 +0,0 @@
-covers 'facets/kernel/with'
-
-test_case Kernel do
-
-  method :with do
-
-    test do
-      with values = [] do
-        self << 'bar'
-        self << 'baz'
-      end
-      values.assert == ['bar', 'baz']
-    end
-
-  end
-
-end
-

data/test/core/kernel/test_writers.rb

@@ -1,53 +0,0 @@
-covers 'facets/kernel/writers'
-
-test_case Kernel do
-
-  method :writers do
-
-    test do
-      c = Class.new do
-        attr_accessor :a
-        def b=(b); @b=b; end
-      end
-      o = c.new
-      w = o.writers
-
-      w.assert.include?(:a=)
-      w.assert.include?(:b=)
-    end
-
-    test do
-      c = Class.new do
-        attr_accessor :a
-        def b=(b); @b=b; end
-        private
-        def q=(q); @q=q; end
-      end
-      o = c.new
-      w = o.writers(:access=>:private)
-
-      w.refute.include?(:a=)
-      w.refute.include?(:b=)
-      w.assert.include?(:q=)
-    end
-
-    test do
-      c = Class.new do
-        attr_accessor :a
-        def b=(b); @b=b; end
-        private
-        def q=(q); @q=q; end
-      end
-      o = c.new
-      w = o.writers(:access=>:all)
-
-      w.assert.include?(:a=)
-      w.assert.include?(:b=)
-      w.assert.include?(:q=)
-    end
-
-    # TODO: Need to test more options for writers.
-
-  end
-
-end

data/test/core/matchdata/test_match.rb

@@ -1,14 +0,0 @@
-covers 'facets/matchdata/match'
-
-test_case MatchData do
-
-  method :match do
-
-    test do
-      md = /X(a)(b)(c)X/.match("YXabcXY")
-      md.match.assert == "XabcX"
-    end
-
-  end
-
-end

data/test/core/matchdata/test_matchset.rb

@@ -1,29 +0,0 @@
-covers 'facets/matchdata/matchset'
-
-test_case MatchData do
-
-  method :matchtree do
-
-    test do
-      md = /(bb)(cc(dd))(ee)/.match "XXaabbccddeeffXX"
-      md.matchtree.assert == [["bb"], ["cc", ["dd"]], ["ee"]]
-    end
-
-    test do
-      md = /(bb)c(c(dd))(ee)/.match "XXaabbccddeeffXX"
-      md.matchtree.assert == [["bb"], "c", ["c", ["dd"]], ["ee"]]
-    end
-
-  end
-
-  method :matchset do
-
-    test do
-      md = /(bb)(cc(dd))(ee)/.match "XXaabbccddeeffXX"
-      md.matchset.assert == ["XXaa", [["bb"], ["cc", ["dd"]], ["ee"]], "ffXX"]
-    end
-
-  end
-
-end
-

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
-