pure 0.1.0

data/lib/pure/pure_private/extractor_ruby_parser.rb

@@ -0,0 +1,47 @@
+
+require 'ruby_parser'
+require 'sexp_processor'
+    
+module Pure
+  module PurePrivate
+    class ExtractorRubyParser < SexpProcessor
+      def initialize(file)
+        super()
+        @file = file
+        @defs = Hash.new
+      end
+        
+      def run
+        process(RubyParser.new.parse(File.read(@file)))
+        @defs
+      end
+        
+      def process(sexp)
+        if sexp[0] == :defn
+          name = sexp[1]
+          args = sexp[2].to_a[1..-1]
+          if args.any? { |arg| arg.to_s =~ %r!\A\*! }
+            raise SplatError.new(@file, sexp.line)
+          end
+          @defs[sexp.line] = {
+            :name => name,
+            :args => args,
+            :sexp => sexp.dup,
+          }
+          sexp.clear
+        elsif sexp[0] == :iter and
+            sexp[1][0] == :call and
+            sexp[1][1] == nil and
+            sexp[1][2] == :fun
+          @defs[sexp[1].line] = {
+            :name => :fun,
+            :sexp => [sexp[2], sexp[3]],
+          }
+          sexp.clear
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/pure/pure_private/function_database.rb

@@ -0,0 +1,10 @@
+
+module Pure
+  module PurePrivate
+    module FunctionDatabase
+      FUNCTION_DATABASE = Hash.new { |hash, key|
+        hash[key] = Hash.new
+      }
+    end
+  end
+end

data/lib/pure/pure_private/singleton_features.rb

@@ -0,0 +1,67 @@
+
+require 'pure/pure_private/extractor'
+require 'pure/pure_private/function_database'
+require 'pure/pure_private/driver'
+require 'pure/pure_private/error'
+
+module Pure
+  module PurePrivate
+    module SingletonFeatures
+      include FunctionDatabase
+
+      def compute(root, opts)
+        Driver.create_instance_and_compute(self, root, opts)
+      end
+      
+      def fun(*args, &block)
+        fun_mod = class << self ; @fun_mod ; end
+        node_name, child_names = (
+          if args.size == 1
+            arg = args.first
+            if arg.is_a? Hash
+              unless arg.size == 1
+                raise PurePrivate::ArgumentError,
+                "`fun' given hash of size != 1"
+              end
+              arg.to_a.first
+            else
+              [arg, []]
+            end
+          else
+            raise PurePrivate::ArgumentError,
+            "wrong number of arguments (\#{args.size} for 1)"
+          end
+        )
+        child_syms = (
+          if child_names.is_a? Enumerable
+            child_names.map { |t| t.to_sym }
+          else
+            [child_names.to_sym]
+          end
+        )
+        node_sym = node_name.to_sym
+        fun_mod.module_eval {
+          define_method(node_sym, &block)
+        }
+        spec = Extractor.extract(fun_mod, :fun, caller)
+        FUNCTION_DATABASE[fun_mod][node_sym] = spec.merge(
+          :name => node_sym,
+          :args => child_syms,
+          :origin => :fun
+        )
+        nil
+      end
+
+      def method_added(function_name)
+        FUNCTION_DATABASE[self][function_name] = (
+          Extractor.extract(self, function_name, caller).merge(:origin => :def)
+        )
+      end
+
+      def define_method(*args, &block)
+        raise PurePrivate::NotImplementedError,
+        "define_method called (use the `fun' method instead)"
+      end
+    end
+  end
+end

data/lib/pure/pure_private/util.rb

@@ -0,0 +1,23 @@
+
+module Pure
+  module PurePrivate
+    module Util
+      module_function
+    
+      def file_line(backtrace)
+        file, line = backtrace.match(%r!\A(.*?):(\d+)!).captures
+        return file, line.to_i
+      end
+
+      def singleton_class_of(obj)
+        class << obj
+          self
+        end
+      end
+
+      def to_camel_case(str)
+        str.split('_').map { |t| t.capitalize }.join
+      end
+    end
+  end
+end

data/spec/basic_spec.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + "/common"
+
+describe "basic computation" do
+  before :all 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
+  end
+  
+  max_threads = 50
+
+  it "should run using compute(:x, :threads => n) syntax" do
+    (1..max_threads).each { |n|
+      @mod.compute(:area, :threads => n).should == (20 + 5)*(30 + 5)  
+    }
+  end
+
+  it "should run using compute(:x, n) syntax" do
+    (1..max_threads).each { |n|
+      @mod.compute(:area, n).should == (20 + 5)*(30 + 5)  
+    }
+  end
+end
+

data/spec/combine_spec.rb

@@ -0,0 +1,62 @@
+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

@@ -0,0 +1,44 @@
+$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

@@ -0,0 +1,146 @@
+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

@@ -0,0 +1,122 @@
+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