pure 0.1.0 → 0.2.0

data/spec/parser_spec.rb

@@ -1,36 +1,23 @@
-require File.dirname(__FILE__) + "/common"
+require File.dirname(__FILE__) + '/pure_spec_base'
 
-describe "parse engine" do
-  it "should be queryable" do
-    pure do
-      def f
+describe "parser" do
+  describe "provided by user" do
+    it "should be accepted by pure" do
+      memo = nil
+      parser = Class.new do
+        define_method :extract do |*args|
+          memo = args
+          Hash.new
+        end
+        def name
+          "SampleParser"
+        end
+      end.new
+      mod = pure(parser) do
+        def f(x, y)
+        end
       end
-    end
-    lambda {
-      Pure.parser
-    }.should_not raise_error
-  end
-
-  it "should be swappable" do
-    previous = Pure.parser
-    begin
-      Pure.parser = "ruby_parser"
-      Pure.parser.should == "ruby_parser"
-    ensure
-      Pure.parser = previous
-    end
-  end
-
-  it "should have a default unless Method#parameters available" do
-    Pure.parser = nil
-    pure do
-      def f
-      end
-    end.compute(:f, 3)
-    if Method.instance_methods.include?(:parameters)
-      Pure.parser.should == nil
-    else
-      Pure.parser.should_not == nil
+      memo.should == [mod, :f, __FILE__, 17]
     end
   end
 end

data/spec/pure_combine_spec.rb

@@ -0,0 +1,77 @@
+require File.dirname(__FILE__) + '/pure_spec_base'
+
+# factor out due to parsers changing
+module PureCombineSpec
+  module_function
+
+  def create_mod_a
+    pure do
+      def area(width, height)
+        width*height
+      end
+      
+      def border
+        5
+      end
+    end
+  end
+
+  def create_mod_b
+    pure do
+      def width(border)
+        20 + border
+      end
+      
+      def height(border)
+        30 + border
+      end
+    end
+  end
+  
+  def create_combined
+    mod_a = create_mod_a
+    mod_b = create_mod_b
+    pure do
+      include mod_a
+      include mod_b
+    end
+  end
+end
+  
+describe "pure" do
+  describe "modules combined with other pure modules" do
+    max_threads = 5
+
+    it "should work with modules included into empty module" do
+      combined = PureCombineSpec.create_combined
+      (1..max_threads).each { |n|
+        combined.compute(n).area.should == (20 + 5)*(30 + 5)  
+      }
+    end
+
+    it "should work with modules included into overriding module" do
+      combined = PureCombineSpec.create_combined
+      combined_override = pure do
+        include combined
+        def border
+          99
+        end
+      end
+      (1..max_threads).each { |n|
+        combined_override.compute(n).area.should == (20 + 99)*(30 + 99)  
+      }
+    end
+
+    it "should work with one module included into another" do
+      mod_a = PureCombineSpec.create_mod_a
+      mod_b = PureCombineSpec.create_mod_b
+      mod_a.module_eval do
+        include mod_b
+      end
+      (1..max_threads).each { |n|
+        mod_a.compute(n).area.should == (20 + 5)*(30 + 5)  
+      }
+    end
+  end
+end
+

data/spec/pure_def_spec.rb

@@ -0,0 +1,186 @@
+require File.dirname(__FILE__) + '/pure_spec_base'
+
+describe "pure" do
+  describe "`def' definitions" do
+    it "should be parsed with 1 arg default" do
+      lambda {
+        pure do
+          def f(x = 99)
+            x
+          end
+        end
+      }.should raise_error(
+        Pure::DefaultArgumentError,
+        "cannot use default argument in pure function at #{__FILE__}:8"
+      )
+    end
+
+    it "should be parsed with non-paren 1 arg" do
+      pure do
+        def f x
+          x + 33
+        end
+      end.compute(3, :x => 44).f.should == 77
+    end
+
+    it "should be parsed with non-paren 1 arg splat" do
+      lambda {
+        pure do
+          def f *x
+            x + 33
+          end
+        end
+      }.should raise_error(Pure::SplatError)
+    end
+
+    it "should be parsed with non-paren 2 arg splat" do
+      lambda {
+        pure do
+          def f x, *y
+            x + 33
+          end
+        end
+      }.should raise_error(Pure::SplatError)
+    end
+
+    it "should be parsed with non-paren 2 args" do
+      pure do
+        def f x, y
+          x + y
+        end
+      end.compute(3, :x => 33, :y => 44).f.should == 77
+    end
+
+    it "should be parsed with 2 arg default" do
+      lambda {
+        pure do
+          def f(x, y = 99)
+            x + y
+          end
+        end
+      }.should raise_error(Pure::DefaultArgumentError)
+    end
+
+    it "should be parsed with non-paren 1 arg default" do
+      lambda {
+        pure do
+          def f x = 99
+            x + 44
+          end
+        end
+      }.should raise_error(Pure::DefaultArgumentError)
+    end
+
+    it "should be parsed with non-paren 2 arg 1 default" do
+      lambda {
+        pure do
+          def f x, y = 99
+            x + y
+          end
+        end
+      }.should raise_error(Pure::DefaultArgumentError)
+    end
+
+    it "should be parsed with non-paren 2 arg 2 default" do
+      lambda {
+        pure do
+          def f x = 77, y = 99
+            x + y
+          end
+        end
+      }.should raise_error(Pure::DefaultArgumentError)
+    end
+
+    it "should ignore &block" do
+      pure do
+        def f(&block)
+          33
+        end
+      end.compute(4).f.should == 33
+    end
+
+    it "should ignore &block with 1 arg" do
+      pure do
+        def f(x, &block)
+          x + 44
+        end
+      end.compute(4, :x => 33).f.should == 77
+    end
+
+    it "should ignore &block with 2 arg" do
+      pure do
+        def f(x, y, &block)
+          x + 44
+        end
+      end.compute(4, :x => 33, :y => nil).f.should == 77
+    end
+
+    it "should ignore &block with 1 arg default" do
+      lambda {
+        pure do
+          def f(x = 11, &block)
+            x + 44
+          end
+        end
+      }.should raise_error(Pure::DefaultArgumentError)
+    end
+
+    it "should ignore no-paren &block" do
+      pure do
+        def f &block
+          33
+        end
+      end.compute(4).f.should == 33
+    end
+
+    it "should ignore no-paren &block with 1 arg" do
+      pure do
+        def f x, &block
+          x + 44
+        end
+      end.compute(4, :x => 33).f.should == 77
+    end
+
+    it "should ignore no-paren &block with 2 arg" do
+      pure do
+        def f x, y, &block
+          x + 44
+        end
+      end.compute(4, :x => 33, :y => nil).f.should == 77
+    end
+
+    it "should ignore no-paren &block with 1 arg default" do
+      lambda {
+        pure do
+          def f x = 11, &block
+            x + 44
+          end
+        end
+      }.should raise_error(Pure::DefaultArgumentError)
+    end
+    
+    it "should have fun_name and arg_names" do
+      pure do
+        def f(x, y)
+          [fun_name, arg_names, x + y]
+        end
+      end.compute(:x => 11, :y => 22).f.should == [:f, [:x, :y], 33]
+    end
+
+    it "should have fun_name and arg_names, given 1 arg" do
+      pure do
+        def f(x)
+          [fun_name, arg_names, x]
+        end
+      end.compute(:x => 11).f.should == [:f, [:x], 11]
+    end
+
+    it "should have fun_name and arg_names, given no args" do
+      pure do
+        def f
+          [fun_name, arg_names]
+        end
+      end.compute.f.should == [:f, []]
+    end
+  end
+end

data/spec/pure_define_method_spec.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/pure_spec_base'
+
+describe "pure" do
+  it "should raise error when define_method called" do
+    lambda {
+      pure do
+        define_method :area do |width, height|
+          width*height
+        end
+        
+        def width
+          5
+        end
+        
+        def height
+          7
+        end
+      end.compute :area, 3
+    }.should raise_error(
+      Pure::DefineMethodError,
+      %r!cannot use define_method.* at #{__FILE__}:7!
+    )
+  end
+end

data/spec/pure_eval_spec.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/pure_spec_base'
+
+describe "pure" do
+  describe "defined inside eval" do
+    it "should raise an error" do
+      lambda {
+        code = %{
+          pure do
+            def f
+              33
+            end
+          end
+        }
+        eval(code)
+      }.should raise_error(Pure::EvalError, %r!#{__FILE__}:14!)
+    end
+  end
+end

data/spec/pure_fun_spec.rb

@@ -0,0 +1,243 @@
+require File.dirname(__FILE__) + '/pure_spec_base'
+
+require 'jumpstart'
+
+describe "pure" do
+  describe "`fun' definitions" do
+    it "should work with symbols" do
+      pure do
+        fun :area => [:width, :height] do |w, h|
+          w*h
+        end
+        
+        fun :width => [:border] do |b|
+          20 + b
+        end
+        
+        fun :height => :border do |b|
+          30 + b
+        end
+        
+        fun :border do
+          5
+        end
+      end.compute(4).area.should == (20 + 5)*(30 + 5)
+    end
+
+    it "should work with symbols and parens" do
+      pure do
+        fun(:area => [:width, :height]) do |w, h|
+          w*h
+        end
+        
+        fun(:width => [:border]) do |b|
+          20 + b
+        end
+        
+        fun(:height => :border) do |b|
+          30 + b
+        end
+        
+        fun(:border) do
+          5
+        end
+      end.compute(4).area.should == (20 + 5)*(30 + 5)
+    end
+
+    it "should work with mixed symbols and strings" do
+      pure do
+        fun :area => [:width, "height"] do |w, h|
+          w*h
+        end
+        
+        fun "width" => [:border] do |b|
+          20 + b
+        end
+        
+        fun :height => "border" do |b|
+          30 + b
+        end
+        
+        fun :border do
+          5
+        end
+      end.compute(4).area.should == (20 + 5)*(30 + 5)
+    end
+
+    it "should work with `def' definitions" do
+      pure do
+        fun :width do
+          33
+        end
+        
+        def height
+          44
+        end
+
+        fun :area => [:width, :height] do |w, h|
+          w*h
+        end
+      end.compute(3).area.should == 33*44
+    end
+
+    it "should be overwritten by later `def' definitions" do
+      Jumpstart::Ruby.no_warnings {
+        pure do
+          fun :f do
+            44
+          end
+          
+          def f
+            33
+          end
+        end.compute(10).f.should == 33
+      }
+    end
+
+    it "should overwrite earlier `def' definitions" do
+      Jumpstart::Ruby.no_warnings {
+        pure do
+          def f
+            33
+          end
+
+          fun :f do
+            44
+          end
+        end.compute(10).f.should == 44
+      }
+    end
+
+    it "should support splat in block args" do
+      pure do
+        fun :area => [:width, :height] do |*a|
+          a[0]*a[1]
+        end
+        
+        def width
+          3
+        end
+        
+        def height
+          4
+        end
+      end.compute(3).area.should == 12
+    end
+
+    it "should support splat with single-element array" do
+      pure do
+        name = [:f]
+        fun(*name) do
+          33
+        end
+      end.compute(3).f.should == 33
+    end
+
+    it "should not preclude `def' definitions called `fun'" do
+      pure do
+        def misery(fun)
+          fun**2
+        end
+
+        def fun(a, b)
+          a + b
+        end
+
+        def a
+          3
+        end
+
+        def b
+          5
+        end
+      end.compute(3).misery.should == 64
+    end
+
+    it "should raise error when given hash of size != 1" do
+      lambda {
+        pure do
+          fun :x => 1, :y => 2 do
+          end
+        end
+      }.should raise_error(ArgumentError)
+    end
+
+    it "should raise error given more than 1 argument" do
+      lambda {
+        pure do
+          fun :x, :y do
+          end
+        end
+      }.should raise_error(ArgumentError)
+    end
+
+    it "should raise error with &block unless Pure::Parser::Internal is used" do
+      code = lambda {
+        pure do
+          fun :f, &lambda { 33 }
+        end.compute(4).f.should == 33
+      }
+      if Pure.parser.name == "Pure::Parser::Internal"
+        code.should_not raise_error
+      else
+          code.should raise_error(Pure::ParseError)
+      end
+      
+      code = lambda {
+        pure do
+          t = lambda { 33 }
+          fun :f, &t
+        end.compute(4).f.should == 33
+      }
+      if Pure.parser.name == "Pure::Parser::Internal"
+        code.should_not raise_error
+      else
+        code.should raise_error(Pure::ParseError)
+      end
+    end
+
+    it "should allow function names containing any characters" do
+      %w[- / ? : ; . ! [ ] ( )].each { |char|
+        pure do
+          fun "f#{char}f" do
+            33
+          end
+        end.compute[:"f#{char}f"].should == 33
+      }
+    end
+
+    it "should have fun_name and arg_names, given multiple args" do
+      pure do
+        fun :f => [:x, :y] do |x, y|
+          [fun_name, arg_names, x + y]
+        end
+      end.compute(:x => 11, :y => 22).f.should == [:f, [:x, :y], 33]
+    end
+
+    it "should have fun_name and fun_args, given 1 arg" do
+      pure do
+        fun :f => :x do |x|
+          [fun_name, arg_names, x]
+        end
+      end.compute(:x => 11).f.should == [:f, [:x], 11]
+    end
+
+    it "should have fun_name and fun_args, given no args" do
+      pure do
+        fun :f do
+          [fun_name, arg_names]
+        end
+      end.compute.f.should == [:f, []]
+    end
+
+    it "should not see internals of the compiler" do
+      lambda {
+        pure do
+          fun :f do
+            spec
+          end
+        end.compute.f
+      }.should raise_error(NameError)
+    end
+  end
+end