pure 0.1.0 → 0.2.0

data/spec/pure_nested_spec.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/pure_spec_base'
+
+describe "pure" do
+  describe "with nested defs" do
+    it "should work with different names" do
+      Class.new do
+        def f(n)
+          pure do
+            def g(h)
+              h**2
+            end
+            fun :h do
+              n
+            end
+          end.compute(Pure::NativeWorker).g
+        end
+      end.new.f(5).should == 25
+    end
+
+    it "should work with the same name" do
+      Class.new do
+        def f(n)
+          pure do
+            def f(h)
+              h**2
+            end
+            fun :h do
+              n
+            end
+          end.compute(Pure::NativeWorker).f
+        end
+      end.new.f(5).should == 25
+    end
+  end
+end

data/spec/pure_parser_spec.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/pure_spec_base'
+
+describe "Pure.parser" do
+  it "should return the current parser" do
+    Pure.parser.should_not == nil
+  end
+
+  it "should have a default" do
+    Pure.parser = nil
+    pure do
+      def f
+      end
+    end.compute(Pure::NativeWorker).f
+    Pure.parser.should_not == nil
+  end
+
+  it "should be changed with Pure.parser=" do
+    lambda {
+      mod = pure do
+        def f
+        end
+      end
+    }.should_not raise_error
+    previous = Pure.parser
+    Pure.parser = "junk"
+    begin
+      lambda {
+        mod = pure do
+          def f
+          end
+        end
+      }.should raise_error
+    ensure
+      Pure.parser = previous
+    end
+  end
+
+  it "should raise error when no parser found" do
+    source = File.dirname(__FILE__) + "/../lib/pure/parser"
+    dest = source + "-tmp"
+    FileUtils.mv(source, dest)
+    begin
+      lambda {
+        Pure::BundledParsers.find_default
+      }.should raise_error(Pure::NoParserError, "no parser found")
+    ensure
+      FileUtils.mv(dest, source)
+    end
+  end
+end

data/spec/pure_spec.rb

@@ -0,0 +1,81 @@
+require File.dirname(__FILE__) + '/pure_spec_base'
+
+require 'jumpstart'
+
+describe "pure" do
+  it "should not be available without require 'pure/dsl'" do
+    code = %{
+      begin
+        pure do
+        end
+      rescue Exception => e
+        unless e.is_a?(NameError)
+          raise 'expected name error'
+        end
+        unless e.message =~ %r!undefined method \`pure\'!
+          raise 'unmatched message'
+        end
+      end
+    }
+    lambda {
+      Jumpstart::Ruby.run("-e", code)
+    }.should_not raise_error
+  end
+
+  it "should be an alias of Pure.define" do
+    Pure.define do
+      def f
+        33
+      end
+    end.compute(4).f.should == 33
+  end
+
+  it "should not allow `fun' outside of block" do
+    lambda {
+      pure do
+      end.fun :x do
+        33
+      end
+    }.should raise_error(NoMethodError)
+  end
+
+  describe "with subsequent `def' definitions" do
+    it "should be accepted" do
+      mod = pure do
+        def f
+          33
+        end
+      end
+
+      mod.compute(4).f.should eql(33)
+
+      mod.module_eval do
+        def g
+          44
+        end
+      end
+
+      mod.compute(4).g.should eql(44)
+    end
+  end
+
+  describe "with subsequent `fun' definitions" do
+    it "should be accepted" do
+      mod = pure do
+        fun :f do
+          33
+        end
+      end
+
+      mod.compute(4).f.should eql(33)
+
+      mod.module_eval do
+        fun :g do
+          44
+        end
+      end
+
+      mod.compute(4).g.should eql(44)
+    end
+  end
+end

data/spec/pure_spec_base.rb

@@ -0,0 +1,106 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../devel'
+
+require 'pure/dsl'
+require 'spec/autorun'
+
+TOPLEVEL_INSTANCE = self
+
+#
+# verify compilers
+#
+module CompilerWorker
+  class Base
+    attr_reader :num_parallel
+      
+    def define_function(spec)
+      lambda { |*args|
+        self.class.compiler.new.evaluate_function(spec, *args)
+      }
+    end
+    
+    def define_function_begin(pure_module, num_parallel)
+      @num_parallel = num_parallel || self.class.num_parallel
+    end
+      
+    def define_function_end
+    end
+      
+    class << self
+      attr_accessor :num_parallel
+      attr_reader :compiler
+    end
+  end
+
+  Pure::BundledParsers.available.values.map { |parser|
+    parser.compiler rescue nil
+  }.compact.each { |path, name|
+    names = name.split("::")
+    worker = Class.new Base do
+      require path
+      @compiler = names.inject(Object) { |mod, name|
+        mod.const_get(name)
+      }
+    end
+    const_set(names.last, worker)
+  }
+end
+
+module Spec::Example::ExampleGroupMethods
+  alias_method :describe__original, :describe
+
+  def describe(*args, &block)
+    if args[1] and args[1][:scope] == TOPLEVEL_INSTANCE
+      Pure::BundledParsers.available.each { |parser_path, parser|
+        workers = [Pure::NativeWorker]
+
+        name = parser.name.split("::").last
+        name = name.to_sym if RUBY_VERSION >= "1.9"
+        if CompilerWorker.constants.include?(name)
+          workers << CompilerWorker.const_get(name)
+        end
+
+        describe "[#{parser.name}]" do
+          before :each do
+            @previous_parser = Pure.parser
+            Pure.parser = parser
+          end
+          after :each do
+            Pure.parser = @previous_parser
+          end
+          workers.each { |worker|
+            describe "[#{worker}]" do
+              before :all do
+                @previous_worker = Pure.worker
+                worker.num_parallel = @previous_worker.num_parallel
+                Pure.worker = worker
+              end
+              after :all do
+                Pure.worker = @previous_worker
+              end
+              describe args.first, &block
+            end
+          }
+        end
+      }
+    else
+      describe__original(*args, &block)
+    end
+  end
+end
+
+#
+# Prevent Ruby2Ruby's destruction of the sexp.  In practice the
+# compiler resides on another ruby interpreter, making the destruction
+# harmless.
+#
+module Pure
+  module Compiler
+    class RubyParser
+      alias_method :compile_function__original, :compile_function
+      def compile_function(spec)
+        compile_function__original(Marshal.load(Marshal.dump(spec)))
+      end
+    end
+  end
+end

data/spec/pure_splat_spec.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/pure_spec_base'
+
+describe "pure" do
+  describe "function defined with splat (*) argument via `def'" do
+    it "should raise error" do
+      lambda {
+        pure do
+          def f(a, b, *stuff)
+            stuff
+          end
+        end
+      }.should raise_error(
+        Pure::SplatError, %r!cannot use splat.*#{__FILE__}:8!
+      )
+    end
+  end
+end
+

data/spec/pure_two_defs_spec.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/pure_spec_base'
+
+describe "pure" do
+  describe "with two defs on the same line" do
+    it "should raise error unless Pure::Parser::Internal is used" do
+      code = lambda {
+        pure do
+          def x ; end ; def y ; end
+        end
+      }
+      if Pure.parser.name == "Pure::Parser::Internal"
+        code.should_not raise_error
+      else
+        code.should raise_error(
+          Pure::ParseMethodError, "failed to parse `x' at #{__FILE__}:8"
+        )
+      end
+    end
+  end
+end

data/spec/pure_worker_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/pure_spec_base'
+
+describe "Pure.worker" do
+  it "should return the current worker" do
+    Pure.worker.should_not == nil
+  end
+
+  it "should be changed with Pure.worker=" do
+    lambda {
+      mod = pure do
+        def f
+        end
+      end
+    }.should_not raise_error
+    previous = Pure.worker
+    Pure.worker = "junk"
+    begin
+      lambda {
+        mod = pure do
+          def f
+          end
+        end.compute.f
+      }.should raise_error
+    ensure
+      Pure.worker = previous
+    end
+  end
+
+  it "should have a default" do
+    Pure.worker = nil
+    Pure.worker.should_not == nil
+  end
+end

data/spec/readme_spec.rb

@@ -1,35 +1,39 @@
-require 'pathname'
-require 'tempfile'
+require File.dirname(__FILE__) + '/pure_spec_base'
 
-here = Pathname(__FILE__).dirname
-require here + "common"
-root = here + ".."
-readme = root + "README.rdoc"
-lib = root + "lib"
+require "jumpstart"
 
-describe readme do
-  $LOAD_PATH.unshift root + "devel"
-  require "jumpstart/ruby"
-  ["Synopsis"].each { |section|
-    describe section do
-      it "should run as claimed" do
-        contents = readme.read
-  
-        code = %{
-          $LOAD_PATH.unshift "#{lib.expand_path}"
-          require 'rubygems'
-        } + contents.match(%r!== #{section}.*?\n(.*?)^\S!m)[1]
-  
-        expected = code.scan(%r!\# => (.*?)\n!).flatten.join("\n")
-  
-        Tempfile.open("pure-readme") { |file|
-          file.puts code
-          file.close
-          result = `"#{Jumpstart::Ruby::EXECUTABLE}" "#{file.path}"`
-          raise unless $?.exitstatus
-          result.chomp.should == expected
-        }
-      end
-    end
+readme = "README.rdoc"
+
+simple_sections = [
+ "Synopsis",
+ "Overrides",
+ "Delegates and Blocks",
+ "Combining Pure Modules",
+ "Restrictions",
+ "Default Number of Functions in Parallel",
+]
+
+Jumpstart.doc_to_spec(readme, *simple_sections)
+
+Jumpstart.doc_to_spec(readme, "Dynamic Names") { |expected, actual, index|
+  [expected, actual].each { |expr|
+    expr.should match(%r!\A[\d\s]+\Z!)
   }
-end
+}
+
+Jumpstart.doc_to_spec(readme, "Worker Plugins") { |expected, actual, index|
+  case index
+  when 0, 2
+    actual.should == expected
+  when 1
+    require 'ruby_parser'
+    trimmed_expected, trimmed_actual = [expected, actual].map { |expression|
+      result = eval(expression, TOPLEVEL_BINDING)
+      result[0].merge!(:file => nil, :line => nil)
+      result
+    }
+    trimmed_actual.should == trimmed_expected
+  else
+    raise
+  end
+}

data/spec/splat_spec.rb

@@ -1,15 +1,16 @@
-require File.dirname(__FILE__) + "/common"
+require File.dirname(__FILE__) + '/pure_spec_base'
 
-describe "splat (*) argument in pure function" do
-  describe "with `def'" do
-    it "should raise error" do
-      lambda {
-        pure do
-          def f(a, b, *stuff)
-            stuff
-          end
-        end
-      }.should raise_error(Pure::PurePrivate::SplatError)
+describe "splat" do
+  it "should be allowed outside of pure" do
+    Class.new do
+      def f(*args)
+      end
+    end
+
+    pure do
+      def g
+        44
+      end
     end
   end
 end