fuby 0.0.1

data/test/fuby/and.rb

@@ -0,0 +1,14 @@
+require 'fuby/and'
+
+using Fuby
+
+describe Hash do
+  describe "& that" do
+    it "creates a new hash by intersecting `self` and `that`" do
+
+      ({ a:1 } & { b:2 }).must_equal Hash.new
+      ({ a:1, b:2 } & { b:2, c:3 }).must_equal b:2
+
+    end
+  end
+end

data/test/fuby/any.rb

@@ -0,0 +1,15 @@
+require 'fuby/any'
+
+using Fuby
+
+describe Enumerable do
+  describe "any?" do
+    it "the behaviour of `any?` is modified in order to allow object (as well as Proc) arguments" do
+
+      [1, 2, 3].any?.must_be_instance_of Method
+      [1, 2, 3].any?.call(String).must_equal false
+      [1, 2, 3].any?(Integer).must_equal true
+
+    end
+  end
+end

data/test/fuby/bind.rb

@@ -0,0 +1,17 @@
+require 'fuby/bind'
+
+using Fuby
+
+describe Proc do
+  describe "bind receiver" do
+    it "binds self to the given receiver" do
+
+      foo = -> { self }
+      bar = {}
+      qux = foo.bind bar
+      qux.must_be_instance_of Method
+      qux.call.must_equal bar
+
+    end
+  end
+end

data/test/fuby/define_missing_method.rb

@@ -0,0 +1,33 @@
+require 'fuby/define_missing_method'
+
+using Fuby
+
+describe Module do
+  describe "define_missing_method pattern, &block" do
+    it "defines a missing_method handler for keys matching the given pattern" do
+
+      class A
+
+        define_missing_method /any/ do
+          5
+        end
+
+        define_missing_method /all/ do
+          5
+        end
+
+      end
+
+      A.new.many.must_equal 5
+      A.new.respond_to?(:zany).must_equal true
+      A.new.respond_to?(:mall).must_equal true
+
+    end
+    it "prepends any matched anonymous groups" do
+
+      class A
+      end
+
+    end
+  end
+end

data/test/fuby/drop.rb

@@ -0,0 +1,28 @@
+require 'fuby/drop'
+
+using Fuby
+
+describe Array do
+  describe "drop number = 1" do
+    it "returns a new array dropping the initial number elements" do
+
+      xs = [1, 2, 3, :four]
+
+      xs.drop.must_equal [2, 3, :four]
+      xs.drop(2).must_equal [3, :four]
+
+    end
+  end
+  describe "drop! predicate = Proc.new" do
+    it "dropping the initial elements that don't match the given predicate, returning self" do
+
+      xs = [1, 2, 3, :four]
+
+      xs.drop!.must_equal xs
+      xs.must_equal [2, 3, :four]
+      xs.drop! 2
+      xs.must_equal [:four]
+
+    end
+  end
+end

data/test/fuby/drop_until.rb

@@ -0,0 +1,26 @@
+# require 'fuby/drop_until'
+
+# using Fuby
+
+# describe Array do
+#   describe "drop_until predicate = Proc.new" do
+#     it "returns a new array dropping the initial elements that don't match the given predicate" do
+
+#       xs = [1, 2, 3, :four]
+
+#       xs.drop_until { false }.must_equal []
+#       xs.drop_until(Symbol).must_equal [:four]
+
+#     end
+#   end
+#   describe "drop_until! predicate = Proc.new" do
+#     it "dropping the initial elements that don't match the given predicate, returning self" do
+
+#       xs = [1, 2, 3, :four]
+
+#       xs.drop_until!(Symbol).must_equal xs
+#       xs.must_equal [:four]
+
+#     end
+#   end
+# end

data/test/fuby/drop_while.rb

@@ -0,0 +1,26 @@
+# require 'fuby/drop_while'
+
+# using Fuby
+
+# describe Array do
+#   describe "drop_while predicate = Proc.new" do
+#     it "returns a new array dropping the initial elements matching the given predicate" do
+
+#       xs = [1, 2, 3, :four]
+
+#       xs.drop_while { true }.must_equal []
+#       xs.drop_while(Integer).must_equal [:four]
+
+#     end
+#   end
+#   describe "drop_while! predicate = Proc.new" do
+#     it "dropping the initial elements matching the given predicate, returning self" do
+
+#       xs = [1, 2, 3, :four]
+
+#       xs.drop_while!(Integer).must_equal xs
+#       xs.must_equal [:four]
+
+#     end
+#   end
+# end

data/test/fuby/each_with_index_or_key.rb

@@ -0,0 +1,22 @@
+require 'fuby/each_with_index_or_key'
+
+using Fuby
+
+describe Array do
+  describe "each_with_index_or_key &block" do
+    it "is equivalent to each_with_index" do
+
+      [1, 2, 3].each_with_index_or_key.to_a.must_equal [[1, 0], [2, 1], [3, 2]]
+
+    end
+  end
+end
+describe Hash do
+  describe "each_with_index_or_key &block" do
+    it "enumerates self with a block taking the element and key as arguments" do
+
+      { a:1, b:2 }.each_with_index_or_key.to_a.must_equal [[1, :a], [2, :b]]
+
+    end
+  end
+end

data/test/fuby/extend.rb

@@ -0,0 +1,20 @@
+require 'fuby/extend'
+
+using Fuby
+
+describe Module do
+  describe "extend &block" do
+    it "creates and extends a module based on the given &block" do
+
+      o = Object.new
+      o.extend! do
+
+        def foo
+        end
+
+      end
+      o.must_respond_to :foo
+
+    end
+  end
+end

data/test/fuby/include.rb

@@ -0,0 +1,20 @@
+require 'fuby/include'
+
+using Fuby
+
+describe Module do
+  describe "include &block" do
+    it "creates and includes a module based on the given &block" do
+
+      c = Class.new
+      c.include! do
+
+        def foo
+        end
+
+      end
+      c.new.must_respond_to :foo
+
+    end
+  end
+end

data/test/fuby/intercept.rb

@@ -0,0 +1,16 @@
+require 'fuby/intercept'
+
+using Fuby
+
+describe Module do
+  describe "intercept &block" do
+    it "creates a proxy of self, with method_missing defined from the given &block" do
+
+      object = {}
+      object.intercept { |key, *sig, &blk| self }.foo.must_equal object
+      object.intercept { |key, *sig, &blk| key }.foo.must_equal :foo
+      object.intercept { |key, *sig, &blk| sig }.foo(1, 2, 3).must_equal [1, 2, 3]
+
+    end
+  end
+end

data/test/fuby/method_added_as_binary_operator.rb

@@ -0,0 +1,20 @@
+require 'fuby/method_added_as_binary_operator'
+
+using Fuby
+
+describe Module do
+  describe "method_added_as_binary_operator *names" do
+    it "redefines the referenced methods as binary operators, allowing currying of the second argument" do
+
+      class Array
+        method_added_as_binary_operator :push
+      end
+
+      xs = [1, 2, 3]
+      xs.push.must_be_instance_of Method
+      xs.push.call 4
+      xs.must_equal [1, 2, 3, 4]
+
+    end
+  end
+end

data/test/fuby/method_added_as_filter.rb

@@ -0,0 +1,28 @@
+require 'fuby/method_added_as_filter'
+
+using Fuby
+
+describe Module do
+  describe "method_added_as_filter *names" do
+    it "redefines the referenced methods as filter methods" do
+
+      m = Module.new do
+
+        def foo &pred
+          [1, 2, 3].select &pred
+        end
+
+        method_added_as_filter :foo
+
+      end
+
+      c = Class.new
+      c.send :include, m
+      c.new.must_respond_to :foo
+
+      c.new.foo { |i| i < 3 }.must_equal [1, 2]
+      c.new.foo(Integer).must_equal [1, 2, 3]
+
+    end
+  end
+end

data/test/fuby/new.rb

@@ -0,0 +1,3 @@
+require 'fuby/new'
+
+using Fuby

data/test/fuby/or.rb

@@ -0,0 +1,19 @@
+require 'fuby/or'
+
+using Fuby
+
+describe Hash do
+  describe "| that" do
+    it "creates a new hash by merging `self` into `that`" do
+
+      ({ a:1 } | { b:2 }).must_equal a:1, b:2
+
+    end
+    it "should preserve key order" do
+
+      ({ a:1 } | { b:2 }).keys.first.must_equal :a
+      ({ b:2 } | { a:1 }).keys.first.must_equal :b
+
+    end
+  end
+end

data/test/fuby/otherwise.rb

@@ -0,0 +1,30 @@
+require 'fuby/otherwise'
+
+using Fuby
+
+describe Object do
+  describe 'otherwise(that, &block)' do
+    it "returns self" do
+
+      5.otherwise(6).must_be_same_as 5
+
+    end
+  end
+
+end
+describe NilClass do
+  describe 'otherwise(that)' do
+    it "returns that" do
+
+      nil.otherwise(5).must_be_same_as 5
+
+    end
+  end
+  describe 'otherwise{that}' do
+    it "returns that" do
+
+      nil.otherwise{5}.must_be_same_as 5
+
+    end
+  end
+end

data/test/fuby/pop_if.rb

@@ -0,0 +1,31 @@
+require 'fuby/to_boolean'
+
+using Fuby
+
+describe Numeric do
+  describe "to_boolean" do
+    it "converts self to a boolean according to the common interpretation" do
+
+      0.to_boolean.must_equal false
+      1.to_boolean.must_equal true
+      +0.1.to_boolean.must_equal true
+      -0.1.to_boolean.must_equal false
+    end
+  end
+end
+
+describe String do
+  describe "to_boolean" do
+    it "converts self to a boolean according to the common interpretation" do
+
+      "1".to_boolean.must_equal true
+      "t".to_boolean.must_equal true
+      "true".to_boolean.must_equal true
+      "TRUE".to_boolean.must_equal true
+      "yes".to_boolean.must_equal true
+      "y".to_boolean.must_equal true
+      "goo".to_boolean.must_equal false
+
+    end
+  end
+end