pure 0.1.0 → 0.2.0

data/spec/compute_overrides_spec.rb

@@ -0,0 +1,99 @@
+require File.dirname(__FILE__) + '/pure_spec_base'
+
+describe "compute" do
+  describe "overrides" do
+    it "should replace missing functions" do
+      pure do
+        def add(x, y)
+          x + y
+        end
+      end.compute(4, :x => 33, :y => 44).add.should == 77
+    end
+  
+    it "should fail if underspecified" do
+      (1..4).each { |n|
+        lambda {
+          pure do
+            def add(x, y)
+              x + y
+            end
+          end.compute(n, :y => 44).add
+        }.should raise_error(Pure::NoFunctionError, "no function named `x'")
+      }
+    end
+  
+    it "should override no-argument functions" do
+      (1..4).each { |n|
+        pure do
+          def add(x, y)
+            x + y
+          end
+          def x
+            33
+          end
+          def y
+            44
+          end
+        end.compute(n, :x => 55).add.should == 99
+      }
+    end
+  
+    it "should override multi-argument functions" do
+      (1..4).each { |n|
+        pure do
+          def add(x, y)
+            x + y
+          end
+          def x
+            33
+          end
+          def y
+            44
+          end
+        end.compute(n, :add => 11).add.should == 11
+      }
+    end
+
+    it "should override a root function" do
+      (1..4).each { |n|
+        greet = pure do
+          def hello(name)
+            "Hello, #{name}."
+          end
+          
+          def name
+            "Bob"
+          end
+        end
+        greet.compute(n).hello.should eql("Hello, Bob.")
+        greet.compute(n, :name => "Ralph").hello.should eql("Hello, Ralph.")
+        greet.compute(n, :hello => "Goodbye.").hello.should eql("Goodbye.")
+      }
+    end
+
+    it "should prevent the overridden function from being called" do
+      count = 0
+      pure do
+        def f x
+          x + 44
+        end
+
+        fun :x do
+          count += 1
+          33
+        end
+      end.compute(:x => 11).f.should eql(55)
+      count.should == 0
+    end
+
+    it "should convert non-symbol keys to symbols" do
+      (1..4).each { |n|
+        pure do
+          def add(x, y)
+            x + y
+          end
+        end.compute(n, "x" => 55, "y" => 44).add.should == 99
+      }
+    end
+  end
+end

data/spec/compute_spec.rb

@@ -0,0 +1,86 @@
+require File.dirname(__FILE__) + '/pure_spec_base'
+
+describe "compute" do
+  it "should accept no arguments" do
+    pure do
+      def f
+        33
+      end
+    end.compute.f.should == 33
+  end
+
+  it "should accept (overrides) argument" do
+    pure do
+      def f
+        33
+      end
+    end.compute(:f => 44).f.should == 44
+  end
+  it "should accept (num_parallel) argument" do
+    (1..8).each { |n|
+      pure do
+        def f
+          33
+        end
+      end.compute(n).f.should == 33
+    }
+  end
+  it "should accept (worker) argument" do
+    pure do
+      def f
+        33
+      end
+    end.compute(Pure::NativeWorker).f.should == 33
+  end
+  it "should accept (num_parallel, overrides) arguments" do
+    (1..8).each { |n|
+      pure do
+        def f
+          33
+        end
+      end.compute(n, :f => 99).f.should == 99
+    }
+  end
+  it "should accept (worker, overrides) arguments" do
+    pure do
+      def f
+        33
+      end
+    end.compute(Pure::NativeWorker, :f => 99).f.should == 99
+  end
+  it "should raise error for > 2 arguments" do
+    lambda {
+      pure do
+        def f
+          33
+        end
+      end.compute(:a, :b, :c).f.should == 99
+    }.should raise_error(ArgumentError)
+  end
+  it "should raise #{Pure::NoFunctionError} for undefined function" do
+    (1..8).each { |n|
+      lambda {
+        result = pure do
+          def f(x)
+            x + 33
+          end
+        end.compute(n).f
+      }.should raise_error(Pure::NoFunctionError, "no function named `x'")
+    }
+  end
+  it "should be independent of other compute calls" do
+    mod_f1 = pure do
+      def f
+        1
+      end
+    end
+    mod_f2 = pure do
+      def f
+        2
+      end
+    end
+    result_f1 = mod_f1.compute(3)
+    result_f2 = mod_f2.compute(4)
+    result_f1.f.should == 1
+  end
+end

data/spec/compute_thread_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/pure_spec_base'
+
+describe "compute" do
+  max_threads = 50
+  describe "with number of threads 1..#{max_threads}" do
+    it "should succeed" do
+      mod = pure do
+        def area(width, height)
+          width*height
+        end
+        
+        def width(border)
+          20 + border
+        end
+        
+        def height(border)
+          30 + border
+        end
+        
+        def border
+          5
+        end
+      end
+      (1..max_threads).each { |n|
+        mod.compute(n) { |s| s.area }.should == (20 + 5)*(30 + 5)  
+      }
+    end
+  end
+end

data/spec/compute_timed_spec.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/pure_spec_base'
+require 'benchmark'
+
+# factor out due to parsers changing
+def create_timed_benchmark
+  mod = pure do
+    def root(a, b)
+    end
+    
+    def a
+      sleep(0.25)
+    end
+    
+    def b
+      sleep(0.25)
+    end
+  end
+  lambda { |n|
+    mod.compute(n)[:root]
+  }
+end
+
+require 'rbconfig'
+
+# uneven results in windows
+unless Config::CONFIG["host"] =~ %r!(mswin|cygwin|mingw)!
+  describe "compute" do
+    describe "with timed example" do
+      it "should run with 1 thread" do
+        compute = create_timed_benchmark
+        Benchmark.measure { compute.call(1) }.real.should be_close(0.5, 0.1)
+      end
+      
+      it "should be 2x faster with 2 threads" do
+        compute = create_timed_benchmark
+        Benchmark.measure { compute.call(2) }.real.should be_close(0.25, 0.05)
+      end
+    end
+  end
+end

data/spec/delegate_spec.rb

@@ -0,0 +1,141 @@
+require File.dirname(__FILE__) + '/pure_spec_base'
+
+if RUBY_PLATFORM == "java"
+  # jruby needs this here; don't know why
+  require 'ruby2ruby'
+end
+
+def create_geometry_example
+  pure do
+    def area(width, height)
+      width*height
+    end
+    
+    def width(border)
+      7 + border
+    end
+    
+    def height(border)
+      5 + border
+    end
+  end.compute(4, :border => 2)
+end
+
+describe Pure::Delegate do
+  it "should hold results" do
+    geometry = create_geometry_example
+    geometry.area.should eql((7 + 2)*(5 + 2))
+    geometry.width.should eql(7 + 2)
+    geometry.height.should eql(5 + 2)
+    geometry.border.should eql(2)
+  end
+
+  it "should raise error for undefined attribute" do
+    lambda {
+      pure do
+        def f
+          33
+        end
+      end.compute.g
+    }.should raise_error(NoMethodError)
+  end
+
+  it "should raise error when attribute is passed args" do
+    lambda {
+      pure do
+        def f
+          33
+        end
+      end.compute.f(44)
+    }.should raise_error(ArgumentError)
+  end
+
+  it "should be lazy" do
+    mutex = Mutex.new
+    counter = 0
+    incrementer = pure do
+      fun :increment do
+        mutex.synchronize {
+          counter += 1
+        }
+      end
+    end.compute(Pure::NativeWorker)
+    counter.should eql(0)
+    3.times {
+      incrementer.increment.should eql(1)
+    }
+  end
+
+  describe "[] alternative to method call" do
+    it "should accept symbols" do
+      geometry = create_geometry_example
+      geometry[:area].should eql((7 + 2)*(5 + 2))
+      geometry[:width].should eql(7 + 2)
+      geometry[:height].should eql(5 + 2)
+      geometry[:border].should eql(2)
+    end
+
+    it "should accept strings" do
+      geometry = create_geometry_example
+      geometry["area"].should eql((7 + 2)*(5 + 2))
+      geometry["width"].should eql(7 + 2)
+      geometry["height"].should eql(5 + 2)
+      geometry["border"].should eql(2)
+    end
+
+    it "should raise error if given > 1 arg" do
+      geometry = create_geometry_example
+      lambda {
+        geometry[:area, 4]
+      }.should raise_error(ArgumentError)
+    end
+
+    it "should raise error when given other types" do
+      lambda {
+        pure do
+          def f
+          end
+        end.compute(33)[nil]
+      }.should raise_error(TypeError)
+
+      lambda {
+        pure do
+          def f
+          end
+        end.compute(33)[Object.new]
+      }.should raise_error(TypeError)
+    end
+
+    it "should propagate exceptions from root function" do
+      mod = pure do
+        def f
+          raise "zz"
+        end
+      end
+      result = mod.compute(4)
+      lambda {
+        result.f
+      }.should raise_error(RuntimeError, "zz")
+    end
+
+    it "should propagate exceptions from child functions" do
+      mod = pure do
+        def f(x)
+          33
+        end
+
+        def x(y)
+          44
+        end
+
+        def y
+          raise "foo"
+        end
+      end
+      result = mod.compute(4)
+      lambda {
+        result.f
+      }.should raise_error(RuntimeError, "foo")
+    end
+  end
+end

data/spec/fstat_example.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/pure_spec_base'
+
+describe "fstat example" do
+  it "should succeed" do
+    files = Dir["*"]
+      
+    stats = pure do
+      files.each { |file|
+        fun file do
+          File.stat(fun_name.to_s)
+        end
+      }
+      
+      fun :total_size => files do |*values|
+        values.inject(0) { |acc, stat| acc + stat.size }
+      end
+    end
+    
+    stats.compute { |result|
+      result["Rakefile"].size.should eql(File.stat("Rakefile").size)
+      total = files.inject(0) { |acc, file| acc + File.stat(file).size }
+      result.total_size.should == total
+    }
+  end
+end
+

data/spec/parser_sexp_spec.rb

@@ -0,0 +1,100 @@
+require File.dirname(__FILE__) + '/pure_spec_base'
+
+def check_sexp(type, mod, name, expected)
+  entry = Pure::ExtractedFunctions[Pure.parser][mod][name]
+  if Pure.parser == (Pure::Parser::RubyParser rescue nil)
+    check_ruby_parser_sexp(entry, type, mod, expected)
+  elsif Pure.parser == (Pure::Parser::Ripper rescue nil)
+    check_ripper_sexp(entry, type, mod, expected)
+  elsif Pure.parser == (Pure::Parser::Internal rescue nil)
+    check_internal_sexp(entry, type, mod, expected)
+  end
+end
+
+def check_ruby_parser_sexp(entry, type, mod, expected)
+  entry[:code].should be_a(Sexp)
+  sexp = Pure::Parser::RubyParser::DupSexp.dup_sexp(entry[:code])
+  require 'ruby2ruby'
+  recovered = Ruby2Ruby.new.process(sexp).strip.gsub(%r!\s+!, " ")
+  recovered.should == expected
+end
+
+def check_ripper_sexp(entry, type, mod, expected)
+  sexp = entry[:code]
+  sexp.should be_a(Array)
+  case entry[:origin]
+  when :def
+    sexp.first.should == :def
+  when :fun
+    sexp.first.should == :do_block
+  end
+end
+
+def check_internal_sexp(entry, type, mod, expected)
+  entry[:code].should == nil
+end
+
+describe "parser" do
+  describe "sexp" do
+    it "should match the source" do
+      def_f = pure do
+        def f(x, y)
+          x + y
+        end
+      end
+      
+      fun_f = pure do
+        fun :f => [:x, :y] do |a, b|
+          a + b
+        end
+      end
+  
+      def_g = pure do
+        def g
+        end
+      end
+  
+      fun_g = pure do
+        fun :g do
+        end
+      end
+  
+      def_h = pure do
+        def h(x)
+          x**2
+        end
+      end
+  
+      fun_h = pure do
+        fun :h => :x do |a|
+          a**2
+        end
+      end
+  
+      fun_i = pure do
+        fun :i => [:p, :q] do |*s|
+          s.size
+        end
+      end
+  
+      fun_j = pure do
+        fun :j => [:p, :q] do |r, *s|
+          r + s
+        end
+      end
+  
+      [
+        [:def, def_f, :f, "def f(x, y) (x + y) end"],
+        [:fun, fun_f, :f, "fun(:f => ([:x, :y])) { |a, b| (a + b) }"],
+        [:def, def_g, :g, "def g # do nothing end"],
+        [:fun, fun_g, :g, "fun(:g) { }"],
+        [:def, def_h, :h, "def h(x) (x ** 2) end"],
+        [:fun, fun_h, :h, "fun(:h => :x) { |a| (a ** 2) }"],
+        [:fun, fun_i, :i, "fun(:i => ([:p, :q])) { |*s| s.size }"],
+        [:fun, fun_j, :j, "fun(:j => ([:p, :q])) { |r, *s| (r + s) }"],
+      ].each { |type, mod, name, expected|
+        check_sexp(type, mod, name, expected)
+      }
+    end
+  end
+end