pure 0.1.0 → 0.2.0

data/spec/combine_spec.rb

@@ -1,62 +0,0 @@
-require File.dirname(__FILE__) + "/common"
-
-describe "combining pure modules" do
-  before :all do
-    mod_a = @mod_a = pure do
-      def area(width, height)
-        width*height
-      end
-      
-      def border
-        5
-      end
-    end
-
-    mod_b = @mod_b = pure do
-      def width(border)
-        20 + border
-      end
-      
-      def height(border)
-        30 + border
-      end
-    end
-    
-    combined = @combined = pure do
-      include mod_a
-      include mod_b
-    end
-
-    @combined_override = pure do
-      include combined
-      def border
-        99
-      end
-    end
-  end
-  
-  max_threads = 5
-
-  it "should work with modules included into empty module" do
-    (1..max_threads).each { |n|
-      @combined.compute(:area, n).should == (20 + 5)*(30 + 5)  
-    }
-  end
-
-  it "should work with modules included into overriding module" do
-    (1..max_threads).each { |n|
-      @combined_override.compute(:area, n).should == (20 + 99)*(30 + 99)  
-    }
-  end
-
-  it "should work with one module included into another" do
-    mod_b = @mod_b
-    @mod_a.module_eval {
-      include mod_b
-    }
-    (1..max_threads).each { |n|
-      @mod_a.compute(:area, n).should == (20 + 5)*(30 + 5)  
-    }
-  end
-end
-

data/spec/common.rb

@@ -1,44 +0,0 @@
-$LOAD_PATH.unshift File.dirname(__FILE__) + "/../lib"
-
-require 'rubygems'
-require 'pure'
-require 'pathname'
-require 'spec'
-
-include Pure
-
-AVAILABLE_PARSERS = ["ruby_parser"] + (
-  begin
-    require 'ripper'
-    ["ripper"]
-  rescue LoadError
-    []
-  end
-) + (
-  if Method.instance_methods.include? :parameters
-    [nil]
-  else
-    []
-  end
-)
-
-module Spec::Example::ExampleGroupMethods
-  alias_method :example__original, :example
-
-  def example(*args, &block)
-    AVAILABLE_PARSERS.each { |parser|
-      parser_desc = parser || "no parser"
-      describe "(#{parser_desc})" do
-        before :each do
-          Pure.parser = parser
-        end
-        example__original(*args, &block)
-      end
-    }
-  end
-
-  [:it, :specify].each { |method_name|
-    remove_method method_name
-    alias_method method_name, :example
-  }
-end

data/spec/error_spec.rb

@@ -1,146 +0,0 @@
-require File.dirname(__FILE__) + "/common"
-
-describe "two defs on the same line:" do
-  it "should raise error unless Method#parameters is used" do
-    code = lambda {
-      pure do
-        def x ; end ; def y ; end
-      end
-    }
-    if Pure.parser.nil?
-      code.should_not raise_error
-    else
-      code.should raise_error(Pure::PurePrivate::ParseError)
-    end
-  end
-end
-
-describe "function missing:" do
-  it "should raise error" do
-    lambda {
-      pure do
-        def area(width, height)
-          width*height
-        end
-        
-        def width
-          33
-        end
-      end.compute :area, :threads => 3
-    }.should raise_error(Pure::PurePrivate::NoFunctionError)
-  end
-end
-
-describe "bad arguments:" do
-  it "should raise error when given nil" do
-    lambda {
-      pure do
-        def f
-        end
-      end.compute nil, 33
-    }.should raise_error(Pure::PurePrivate::ArgumentError)
-  end
-
-  it "should raise error when given something random" do
-    lambda {
-      pure do
-        def f
-        end
-      end.compute 33, 33
-    }.should raise_error(Pure::PurePrivate::ArgumentError)
-  end
-
-  it "should raise error when given a string" do
-    lambda {
-      pure do
-        def f
-        end
-      end.compute "f", 33
-    }.should raise_error(Pure::PurePrivate::ArgumentError)
-  end
-end
-
-describe "`fun'" do
-  describe "given hash of size != 1" do
-    it "should raise error" do
-      lambda {
-        pure do
-          fun :x => 1, :y => 2 do
-          end
-        end
-      }.should raise_error(Pure::PurePrivate::ArgumentError)
-    end
-  end
-
-  describe "given more than 1 argument" do
-    it "should raise error" do
-      lambda {
-        pure do
-          fun :x, :y do
-          end
-        end
-      }.should raise_error(Pure::PurePrivate::ArgumentError)
-    end
-  end
-
-  describe "with &block" do
-    it "should raise error unless Method#parameters is used" do
-      code = lambda {
-        pure do
-          fun :f, &lambda { 33 }
-        end.compute(:f, :threads => 4).should == 33
-      }
-      if Pure.parser.nil?
-        code.should_not raise_error
-      else
-        code.should raise_error(Pure::PurePrivate::ParseError)
-      end
-
-      code = lambda {
-        pure do
-          t = lambda { 33 }
-          fun :f, &t
-        end.compute(:f, :threads => 4).should == 33
-      }
-      if Pure.parser.nil?
-        code.should_not raise_error
-      else
-        code.should raise_error(Pure::PurePrivate::ParseError)
-      end
-    end
-  end
-end
-
-describe "calling define_method" do
-  it "should raise error" 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::PurePrivate::NotImplementedError)
-  end
-end
-
-describe "parse engine" do
-  it "should raise error when not installed" do
-    lambda {
-      Pure.parser = "z"*99
-    }.should raise_error(LoadError)
-  end
-
-  it "should raise error when unsupported" do
-    lambda {
-      Pure.parser = "fileutils"
-    }.should raise_error(Pure::PurePrivate::NotImplementedError)
-  end
-end

data/spec/fun_spec.rb

@@ -1,122 +0,0 @@
-require File.dirname(__FILE__) + "/common"
-
-describe "`fun' definitions" do
-  it "should work with symbols only" 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(:area, :threads => 4).should == (20 + 5)*(30 + 5)
-  end
-
-  it "should work with symbols and parens only" 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(:area, :threads => 4).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(:area, :threads => 4).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(:area, 3).should == 33*44
-  end
-
-  it "should be lower precedence than `def' definitions" do
-    pure do
-      fun :f do
-        44
-      end
-    end.compute(:f, 10).should == 44
-
-    pure do
-      fun :f do
-        44
-      end
-
-      def f
-        33
-      end
-    end.compute(:f, 10).should == 33
-  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(:area, 3).should == 12
-  end
-
-  it "should support splat with single-element array" do
-    pure do
-      name = [:f]
-      fun(*name) do
-        name
-      end
-    end.compute(:f, 3).should == [:f]
-  end
-end

data/spec/lazy_spec.rb

@@ -1,22 +0,0 @@
-require File.dirname(__FILE__) + "/common"
-
-LAZY_SPEC_COUNTER = Struct.new(:value).new
-
-describe "laziness" do
-  it "should be lazy" do
-    LAZY_SPEC_COUNTER.value = 0
-
-    mod = pure do
-      def square(n)
-        n*n
-      end
-      
-      def n
-        LAZY_SPEC_COUNTER.value += 1
-        3
-      end
-    end.compute :square, :threads => 4
-
-    LAZY_SPEC_COUNTER.value.should == 1
-  end
-end

data/spec/subseqent_spec.rb

@@ -1,42 +0,0 @@
-require File.dirname(__FILE__) + "/common"
-
-describe "subsequent `def' definitions" do
-  it "should be accepted" do
-    mod = pure do
-      def f
-        33
-      end
-    end
-
-    mod.compute(:f, 4).should == 33
-
-    mod.module_eval do
-      def g
-        44
-      end
-    end
-
-    mod.compute(:g, 4).should == 44
-  end
-end
-
-describe "subsequent `fun' definitions" do
-  it "should be accepted" do
-    mod = pure do
-      fun :f do
-        33
-      end
-    end
-
-    mod.compute(:f, 4).should == 33
-
-    mod.module_eval do
-      fun :g do
-        44
-      end
-    end
-
-    mod.compute(:g, 4).should == 44
-  end
-end
-

data/spec/timed_spec.rb

@@ -1,30 +0,0 @@
-require File.dirname(__FILE__) + "/common"
-require 'benchmark'
-
-describe "timed example" do
-  before :all do
-    @mod = pure do
-      def root(a, b)
-      end
-        
-      def a
-        sleep(0.25)
-      end
-
-      def b
-        sleep(0.25)
-      end
-    end
-    @compute = lambda { |n|
-      @mod.compute :root, n
-    }
-  end
-
-  it "should run with 1 thread" do
-    Benchmark.measure { @compute.call(1) }.real.should be_close(0.5, 0.1)
-  end
-
-  it "should be 2x faster with 2 threads" do
-    Benchmark.measure { @compute.call(2) }.real.should be_close(0.25, 0.05)
-  end
-end