pure 0.1.0 → 0.2.0

data/lib/pure/pure_private/creator.rb

@@ -1,27 +0,0 @@
-
-require 'pure/pure_private/util'
-require 'pure/pure_private/singleton_features'
-
-module Pure
-  module PurePrivate
-    module Creator
-      class << self
-        include Util
-
-        def create_module(&block)
-          mod = Module.new
-          fun_mod = Module.new
-          singleton_class_of(mod).module_eval {
-            include SingletonFeatures
-            @fun_mod = fun_mod
-          }
-          mod.module_eval(&block)
-          mod.module_eval {
-            include fun_mod
-          }
-          mod
-        end
-      end
-    end
-  end
-end

data/lib/pure/pure_private/driver.rb

@@ -1,48 +0,0 @@
-
-require 'pure/pure_private/function_database'
-require 'pure/pure_private/error'
-require 'comp_tree'
-
-module Pure
-  module PurePrivate
-    module Driver
-      include FunctionDatabase
-
-      module_function
-
-      def build_and_compute(mod, root, num_threads, &block)
-        begin
-          CompTree.build do |driver|
-            mod.ancestors.each { |ancestor|
-              if defs = FUNCTION_DATABASE[ancestor]
-                defs.each_pair { |function_name, spec|
-                  existing_node = driver.nodes[function_name]
-                  if existing_node.nil? or existing_node.function.nil?
-                    final_spec = spec.merge(:module => ancestor)
-                    node = driver.define(function_name, *spec[:args])
-                    node.function = yield function_name, final_spec
-                  end
-                }
-              end
-            }
-            driver.compute(root, num_threads)
-          end
-        rescue CompTree::NoFunctionError => exception
-          raise PurePrivate::NoFunctionError, exception.message
-        rescue CompTree::ArgumentError => exception
-          raise PurePrivate::ArgumentError, exception.message
-        end
-      end
-
-      def create_instance_and_compute(mod, root, opts)
-        num_threads = (opts.is_a?(Hash) ? opts[:threads] : opts).to_i
-        instance = Object.new.extend(mod)
-        build_and_compute(mod, root, num_threads) { |function_name, spec|
-          lambda { |*args|
-            instance.send(function_name, *args)
-          }
-        }
-      end
-    end
-  end
-end

data/lib/pure/pure_private/error.rb

@@ -1,32 +0,0 @@
-
-module Pure
-  module PurePrivate
-    class Error < StandardError
-    end
-    
-    class NoFunctionError < Error
-    end
-
-    class ParseError < Error
-    end
-
-    class ArgumentError < Error
-    end
-
-    class SplatError < ParseError
-      def initialize(file, line)
-        super()
-        @file = file
-        @line = line
-      end
-
-      def message
-        "cannot use splat (*) argument in a pure function defined with `def' " +
-        "at #{@file}:#{@line}"
-      end
-    end
-
-    class NotImplementedError < Error
-    end
-  end
-end

data/lib/pure/pure_private/extractor.rb

@@ -1,79 +0,0 @@
-
-require 'pure/pure_private/error'
-require 'pure/pure_private/util'
-
-module Pure
-  module PurePrivate
-    module Extractor
-      HAS_METHOD_PARAMETERS = Method.instance_methods.include?(:parameters)
-
-      DEFAULT_PARSER = (
-        if HAS_METHOD_PARAMETERS
-          nil
-        elsif RUBY_VERSION >= "1.9"
-          "ripper"
-        else
-          "ruby_parser"
-        end
-      )
-
-      @parser = nil
-      @engine = nil
-      @cache = Hash.new { |hash, key| hash[key] = Hash.new }
-
-      class << self
-        include Util
-
-        def extract(mod, method_name, backtrace)
-          file, line = file_line(backtrace.first)
-          if @parser.nil? and HAS_METHOD_PARAMETERS
-            if method_name == :fun
-              Hash.new
-            else
-              {
-                :name => method_name,
-                :args => mod.instance_method(method_name).parameters.map {
-                  |type, name|
-                  raise SplatError.new(file, line) if type == :rest
-                  name
-                },
-              }
-            end
-          else
-            if @parser.nil?
-              self.parser = DEFAULT_PARSER
-            end
-            defs = @cache[@parser][file] || (
-              @cache[@parser][file] = @engine.new(file).run
-            )
-            spec = defs[line]
-            unless spec and spec[:name] and spec[:name] == method_name
-              raise PurePrivate::ParseError,
-              "failure parsing `#{method_name}' at #{file}:#{line}" 
-            end
-            spec.merge(:file => file, :line => line)
-          end
-        end
-
-        def parser=(parser_name)
-          if parser_name.nil?
-            @engine = nil
-          else
-            require parser_name
-            begin
-              engine_name = "extractor_#{parser_name}"
-              require "pure/pure_private/#{engine_name}"
-              @engine = PurePrivate.const_get(to_camel_case(engine_name))
-            rescue LoadError
-              raise PurePrivate::NotImplementedError,
-              "parser not supported: #{parser_name}"
-            end
-          end
-          @parser = parser_name
-        end
-
-        attr_reader :parser
-      end
-    end
-  end
-end

data/lib/pure/pure_private/extractor_ripper.rb

@@ -1,95 +0,0 @@
-
-require 'ripper'
-
-module Pure
-  module PurePrivate
-    class ExtractorRipper
-      def initialize(file)
-        @file = file
-        @defs = Hash.new
-      end
-
-      def run
-        process(Ripper.sexp(File.read(@file)))
-        @defs
-      end
-
-      def process_def(sexp)
-        if sexp[0] == :def
-          name = sexp[1][1].to_sym
-          line = sexp[1][2][0]
-          params = (
-            case sexp[2].first
-            when :params
-              sexp[2]
-            when :paren
-              sexp[2][1]
-            else
-              raise PurePrivate::ParseError,
-              "unforeseen `def' syntax at #{@file}:#{line}"
-            end
-          )
-          if params.any? { |t| t and t[0] == :rest_param }
-            raise SplatError.new(@file, line)
-          end
-          args = (
-            if params[1].nil?
-              []
-            else
-              params[1].map { |t| t[1].to_sym }
-            end
-          )
-          @defs[line] = {
-            :name => name,
-            :args => args,
-            :sexp => sexp,
-          }
-          true
-        else
-          false
-        end
-      end
-
-      def process_fun(sexp)
-        if sexp[0] == :method_add_block and sexp[1].is_a?(Array)
-          line = (
-            if sexp[1][0] == :command and
-                sexp[1][1].is_a?(Array) and
-                sexp[1][1][1] == "fun"
-              sexp[1][1][2][0]
-            elsif sexp[1][0] == :method_add_arg and
-                sexp[1][1].is_a?(Array) and
-                sexp[1][1][0] == :fcall and
-                sexp[1][1][1].is_a?(Array) and
-                sexp[1][1][1][1] == "fun"
-              sexp[1][1][1][2][0]
-            else
-              nil
-            end
-          )
-          if line
-            @defs[line] = {
-              :name => :fun,
-              :sexp => sexp[2],
-            }
-            true
-          else
-            false
-          end
-        else
-          false
-        end
-      end
-
-      def process(sexp)
-        if sexp.is_a? Array
-          process_def(sexp) or process_fun(sexp) or (
-            sexp.each { |sub_sexp|
-              process(sub_sexp)
-            }
-          )
-        end
-      end
-    end
-  end
-end

data/lib/pure/pure_private/extractor_ruby_parser.rb

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

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

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

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

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