pure 0.1.0 → 0.2.0

data/lib/pure/parser/impl/base_parser.rb

@@ -0,0 +1,21 @@
+
+module Pure
+  module Parser
+    module BaseParser
+      @cache = Hash.new { |hash, key| hash[key] = Hash.new }
+      
+      class << self
+        def extract(mod, method_name, file, line, processor)
+          defs = @cache[processor][file] || (
+            @cache[processor][file] = processor.new(file).run
+          )
+          spec = defs[line]
+          unless spec and spec[:name] and spec[:name] == method_name
+            raise ParseMethodError.new(file, line, method_name)
+          end
+          spec.merge(:file => file, :line => line)
+        end
+      end
+    end
+  end
+end

data/lib/pure/parser/impl/internal.rb

@@ -0,0 +1,31 @@
+
+module Pure
+  module Parser
+    module Internal
+      module_function
+
+      def extract(mod, method_name, file, line)
+        if method_name == :__fun
+          Hash.new
+        else
+          parameters = mod.instance_method(method_name).parameters.reject {
+            |type, name|
+            type == :block
+          }
+          args = parameters.map { |type, name|
+            name
+          }
+          types = parameters.inject(Hash.new) { |acc, (type, name)|
+            acc.merge!(type => true)
+          }
+          {
+            :name => method_name,
+            :args => args,
+            :splat => types[:rest],
+            :default => types[:opt],
+          }
+        end.merge(:file => file, :line => line)
+      end
+    end
+  end
+end

data/lib/pure/parser/impl/ripper.rb

@@ -0,0 +1,96 @@
+
+require 'ripper'
+require 'pure/parser/impl/base_parser'
+
+module Pure
+  module Parser
+    module Ripper
+      class << self
+        def extract(mod, method_name, file, line)
+          BaseParser.extract(mod, method_name, file, line, Processor)
+        end
+      end
+
+      class Processor
+        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 ParseError.new(@file, line, "unforeseen `def' syntax"
+              end
+            )
+            args = (
+              if params[1].nil?
+                []
+              else
+                params[1].map { |t| t[1].to_sym }
+              end
+            )
+            splat = params.any? { |t| t.is_a?(Array) and t[0] == :rest_param }
+            default = !!params[2]
+            @defs[line] = {
+              :name => name,
+              :args => args,
+              :code => sexp,
+              :splat => splat,
+              :default => default,
+            }
+          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,
+                :code => sexp[2],
+              }
+            end
+          end
+        end
+
+        def process(sexp)
+          if sexp.is_a? Array
+            process_def(sexp)
+            process_fun(sexp)
+            sexp.each { |sub_sexp|
+              process(sub_sexp)
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pure/parser/impl/ruby_parser.rb

@@ -0,0 +1,77 @@
+
+require 'ruby_parser'
+require 'sexp_processor'
+require 'pure/parser/impl/base_parser'
+    
+module Pure
+  module Parser
+    module RubyParser
+      class << self
+        def extract(mod, method_name, file, line)
+          BaseParser.extract(mod, method_name, file, line, Processor)
+        end
+
+        def compiler
+          %w[pure/compiler/ruby_parser Pure::Compiler::RubyParser]
+        end
+      end
+
+      module DupSexp
+        module_function
+        def dup_sexp(sexp)
+          if sexp.is_a? Sexp or sexp.is_a? Array
+            array = sexp.map { |sub_sexp|
+              dup_sexp(sub_sexp)
+            }
+            Sexp.new.replace(array)
+          else
+            sexp
+          end
+        end
+      end
+
+      class Processor < SexpProcessor
+        include DupSexp
+
+        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 = dup_sexp(sexp[2][1..-1]).to_a
+            args.reject! { |a| a.to_s =~ %r!\A&! }
+            default = (
+              args.last and args.last.is_a?(Array) and args.last[0] == :block
+            )
+            splat = args.any? { |arg| arg.to_s =~ %r!\A\*! }
+            @defs[sexp.line] = {
+              :name => name,
+              :args => args,
+              :code => dup_sexp(sexp),
+              :splat => splat,
+              :default => default,
+            }
+          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,
+              :code => dup_sexp(sexp)
+            }
+          end
+          super
+        end
+      end
+    end
+  end
+end

data/lib/pure/parser/internal.rb

@@ -0,0 +1,4 @@
+# rcov hack
+has_parameters = Method.instance_methods.include?(:parameters)
+require('pure/parser/impl/internal') if has_parameters
+raise LoadError unless has_parameters

data/lib/pure/parser/ripper.rb

@@ -0,0 +1,2 @@
+# rcov hack
+require('ripper') ; require('pure/parser/impl/ripper')

data/lib/pure/parser/ruby_parser.rb

@@ -0,0 +1,2 @@
+# rcov hack
+require('ruby_parser') ; require('pure/parser/impl/ruby_parser')

data/lib/pure/pure.rb

@@ -0,0 +1,32 @@
+
+module Pure
+  class << self
+    #
+    # Create a <em>pure module</em>.  The given block is evaluated in
+    # the context of the created module.
+    #
+    # A pure module is a Module instance whose methods have been
+    # specially registered for lexical analysis.
+    # 
+    # The methods of a pure module are referred to as <em>pure
+    # functions</em>.
+    #
+    # See Pure::PureModule.
+    #
+    def define(parser = Pure.parser, &block)
+      PureModule.new(parser, &block)
+    end
+
+    attr_accessor :parser, :worker
+
+    remove_method :parser
+    def parser  #:nodoc:
+      @parser ||= BundledParsers.find_default
+    end
+
+    remove_method :worker
+    def worker  #:nodoc:
+      @worker ||= NativeWorker
+    end
+  end
+end

data/lib/pure/pure_module.rb

@@ -0,0 +1,141 @@
+
+module Pure
+  class PureModule < Module
+    def initialize(parser, &block)  #:nodoc:
+      @parsing_active = true
+      @parser = parser
+      super(&block)
+    end
+
+    #
+    # call-seq: compute(overrides = {})
+    #           compute(num_parallel, overrides = {})
+    #           compute(worker, overrides = {})
+    #
+    # Initialize a computation.
+    #
+    # All three forms take an optional hash for overriding pure
+    # functions.
+    #
+    # In the first form, Pure.worker is the worker for the computation
+    # and Pure.worker decides the number of parallel computations.
+    #
+    # In the second form, Pure.worker is the worker for the
+    # computation and _num_parallel_ is passed as a hint to
+    # Pure.worker, which may accept or ignore the hint.
+    #
+    # In the third form, _worker_ is the worker for the computation
+    # and _worker_ decides the number of parallel computations.
+    #
+    def compute(*args)
+      overrides = args.last.is_a?(Hash) ? args.pop : Hash.new
+      worker, num_parallel = (
+        case args.size
+        when 0
+          [Pure.worker, nil]
+        when 1
+          if args[0].is_a? Integer
+            [Pure.worker, args[0]]
+          else
+            [args[0], nil]
+          end
+        else
+          raise ArgumentError, "wrong number of arguments"
+        end
+      )
+      driver = Driver.new(worker, self, num_parallel, overrides)
+      delegate = Delegate.new(driver)
+      if block_given?
+        yield delegate
+      else
+        delegate
+      end
+    end
+
+    #
+    # call-seq: fun name => [name_a, name_b,...] do |arg_a, arg_b,...|
+    #             ...
+    #           end
+    #
+    # Define a pure function whose name and/or argument names are
+    # not known at compile time.
+    #
+    # The name of the pure function is the value of _name_.  The
+    # names of the function arguments are _name_a_, _name_b_,...
+    # The respective values of the function arguments are
+    # _arg_a_,_arg_b_,...
+    #
+    # See README.rdoc for examples.
+    #
+    def fun(*args, &block)
+      function_str, arg_data = (
+        if args.size == 1
+          arg = args.first
+          if arg.is_a? Hash
+            unless arg.size == 1
+              raise ArgumentError, "`fun' given hash of size != 1"
+            end
+            arg.to_a.first
+          else
+            [arg, []]
+          end
+        else
+          raise ArgumentError, "wrong number of arguments (#{args.size} for 1)"
+        end
+      )
+      arg_names = (
+        if arg_data.is_a? Enumerable
+          arg_data.map { |t| t.to_sym }
+        else
+          [arg_data.to_sym]
+        end
+      )
+      function_name = function_str.to_sym
+      deactivate_parsing {
+        define_method(function_name, &block)
+      }
+      Extractor.record_function(self, :fun, function_name, arg_names, caller)
+      nil
+    end
+
+    def method_added(function_name)  #:nodoc:
+      super
+      if @parsing_active
+        Extractor.record_function(self, :def, function_name, nil, caller)
+      end
+    end
+
+    def define_method(*args, &block)  #:nodoc:
+      if @parsing_active
+        raise DefineMethodError.new(*Util.file_line(caller.first))
+      else
+        super
+      end
+    end
+
+    attr_reader :parser  #:nodoc:
+
+    def deactivate_parsing  #:nodoc:
+      @parsing_active = false
+      begin
+        yield
+      ensure
+        @parsing_active = true
+      end
+    end
+
+    def each_function  #:nodoc:
+      ancestors.each { |ancestor|
+        if defs = ExtractedFunctions[parser][ancestor]
+          defs.each_pair { |name, spec|
+            yield name, spec
+          }
+        end
+      }
+    end
+
+    # want 'fun' both documented and private; rdoc --all is bad
+    rdoc_fun = :fun
+    private rdoc_fun
+  end
+end

data/lib/pure/util.rb

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

data/lib/pure/version.rb

@@ -0,0 +1,4 @@
+
+module Pure
+  VERSION = "0.2.0"
+end

data/spec/compiler_ruby_parser_spec.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/pure_spec_base'
+
+require 'pure/parser/ruby_parser'
+require 'pure/compiler/ruby_parser'
+
+describe Pure::Compiler::RubyParser do
+  before :all do
+    @compiler = Pure::Compiler::RubyParser.new
+  end
+
+  it "should transform `fun' definitions to `define_method' definitions" do
+    def_f = pure(Pure::Parser::RubyParser) do
+      def f(x, y)
+        x + y
+      end
+    end
+    
+    fun_f = pure(Pure::Parser::RubyParser) do
+      fun :f => [:x, :y] do |a, b|
+        a + b
+      end
+    end
+
+    def_g = pure(Pure::Parser::RubyParser) do
+      def g
+      end
+    end
+
+    fun_g = pure(Pure::Parser::RubyParser) do
+      fun :g do
+      end
+    end
+
+    def_h = pure(Pure::Parser::RubyParser) do
+      def h(x)
+        x**2
+      end
+    end
+
+    fun_h = pure(Pure::Parser::RubyParser) do
+      fun :h => :x do |a|
+        a**2
+      end
+    end
+
+    fun_i = pure(Pure::Parser::RubyParser) do
+      fun :i => [:p, :q] do |*s|
+        s.size
+      end
+    end
+
+    fun_j = pure(Pure::Parser::RubyParser) 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, "define_method(:f) { |a, b| (a + b) }"],
+      [:def, def_g, :g, "def g # do nothing end"],
+      [:fun, fun_g, :g, "define_method(:g) { }"],
+      [:def, def_h, :h, "def h(x) (x ** 2) end"],
+      [:fun, fun_h, :h, "define_method(:h) { |a| (a ** 2) }"],
+      [:fun, fun_i, :i, "define_method(:i) { |*s| s.size }"],
+      [:fun, fun_j, :j, "define_method(:j) { |r, *s| (r + s) }"],
+    ].each { |type, mod, name, expected|
+      entry = Pure::ExtractedFunctions[Pure::Parser::RubyParser][mod][name]
+      entry[:code].should be_a(Sexp)
+      sexp = Pure::Parser::RubyParser::DupSexp.dup_sexp(entry[:code])
+      if entry[:origin] == :fun
+        sexp = @compiler.fun_to_define_method(entry[:name], sexp)
+      end
+      recovered = Ruby2Ruby.new.process(sexp).strip.gsub(%r!\s+!, " ")
+      recovered.should == expected
+    }
+  end
+end
+