pure 0.1.0 → 0.2.0

data/install.rb

@@ -1,3 +1,2 @@
-$LOAD_PATH.unshift "devel"
-require 'jumpstart/simple_installer'
+load './devel/jumpstart.rb'
 Jumpstart::SimpleInstaller.new.run

data/lib/pure.rb

@@ -1,19 +1,41 @@
+# 
+# Copyright (c) 2008, 2009 James M. Lawrence.  All rights reserved.
+# 
+# Permission is hereby granted, free of charge, to any person
+# obtaining a copy of this software and associated documentation files
+# (the "Software"), to deal in the Software without restriction,
+# including without limitation the rights to use, copy, modify, merge,
+# publish, distribute, sublicense, and/or sell copies of the Software,
+# and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+# 
 
-require 'pure/pure_private/creator'
-require 'pure/pure_private/extractor'
+require 'comp_tree'
 
-module Pure
-  PURE_VERSION = "0.1.0"
+require 'pure/version'
+require 'pure/error'
+require 'pure/util'
+require 'pure/extractor'
+require 'pure/extracted_functions'
+require 'pure/bundled_plugin'
+require 'pure/bundled_parsers'
+require 'pure/driver'
+require 'pure/native_worker'
+require 'pure/delegate'
+require 'pure/dsl_definition'
+require 'pure/names'
+require 'pure/pure_module'
+require 'pure/pure'
 
-  module_function
-
-  def pure(&block)
-    PurePrivate::Creator.create_module(&block)
-  end
-
-  class << self
-    [:parser, :parser=].each { |name|
-      define_method name, &PurePrivate::Extractor.method(name)
-    }
-  end
-end

data/lib/pure/bundled_parsers.rb

@@ -0,0 +1,4 @@
+
+module Pure
+  BundledParsers = BundledPlugin.new("pure", "parser", NoParserError)
+end

data/lib/pure/bundled_plugin.rb

@@ -0,0 +1,49 @@
+
+module Pure
+  class BundledPlugin
+    def initialize(project_name, plugin_name, empty_error)
+      @project_name = project_name
+      @plugin_name = plugin_name
+      @empty_error = empty_error
+    end
+
+    def files
+      result = Dir[File.dirname(__FILE__) + "/#{@plugin_name}/*.rb"].map {
+        |file|
+        file[%r!(#{@project_name}/#{@plugin_name}/.*)\.rb\Z!, 1]
+      }
+      result.sort  # rcov workaround
+    end
+
+    def fetch(file)
+      begin
+        require file
+        [@project_name, @plugin_name, File.basename(file)].inject(Object) {
+          |acc, name|
+          acc.const_get(Util.to_camel_case(name))
+        }
+      rescue LoadError
+        nil
+      end
+    end
+
+    def available
+      files.map { |file|
+        [file, fetch(file)]
+      }.reject { |file, object|
+        object.nil?
+      }.inject(Hash.new) { |acc, (file, object)|
+        acc.merge!(file => object)
+      }
+    end
+    
+    def find_default
+      files.each { |file|
+        if found = fetch(file)
+          return found
+        end
+      }
+      raise @empty_error
+    end
+  end
+end

data/lib/pure/compiler/ruby_parser.rb

@@ -0,0 +1,63 @@
+#
+# This file is self-contained, intended for use by an external server.
+#
+# It is not included by the top-level pure.rb.
+#
+
+require 'pure/version'
+require 'pure/names'
+require 'ruby2ruby'
+
+module Pure
+  module Compiler  #:nodoc:
+    class RubyParser  #:nodoc:
+      def initialize
+        @ruby2ruby = Ruby2Ruby.new
+      end
+
+      #
+      # Compiles and evaluates a function spec with arg values.
+      #
+      def evaluate_function(spec, *args)
+        compile_function(spec).send(spec[:name], *args)
+      end
+
+      #
+      # Compiles a function spec extracted by
+      # Pure::Parser::RubyParser.
+      #
+      # Returns an object which responds to spec[:name].
+      #
+      def compile_function(spec)
+        sexp = (
+          if spec[:origin] == :fun
+            fun_to_define_method(spec[:name], spec[:code])
+          else
+            spec[:code]
+          end
+        )
+
+        instance = Names.new(spec[:name], spec[:args])
+        Thread.current[:pure_compiler_input] = @ruby2ruby.process(sexp)
+
+        # use singleton to hide locals
+        class << instance
+          eval(Thread.current[:pure_compiler_input])
+        end
+
+        instance
+      end
+
+      #
+      # Code-transform `fun' definitions into `define_method' definitions.
+      #
+      def fun_to_define_method(name, sexp)
+        s(:iter,
+          s(:call, nil, :define_method, s(:arglist, s(:lit, name.to_sym))),
+          sexp[2],
+          sexp[3]
+        )
+      end
+    end
+  end
+end

data/lib/pure/delegate.rb

@@ -0,0 +1,16 @@
+
+module Pure
+  class Delegate
+    def initialize(driver)
+      (class << self ; self ; end).class_eval do
+        driver.each_function_name { |name|
+          define_method name do ||
+            driver.compute(name)
+          end
+        }
+      end
+    end
+    
+    alias_method :[], :send
+  end
+end

data/lib/pure/driver.rb

@@ -0,0 +1,33 @@
+
+module Pure
+  class Driver
+    def initialize(worker_class, mod, num_parallel, overrides)
+      @worker = worker_class.new
+      @worker.define_function_begin(mod, num_parallel)
+      @driver = CompTree.build do |driver|
+        overrides.each_pair { |name, value|
+          driver.define(name.to_sym) { value }
+        }
+        mod.each_function { |name, spec|
+          node = driver.nodes[name]
+          unless node and node.function
+            function = @worker.define_function(spec)
+            driver.define(name, *spec[:args], &function)
+          end
+        }
+        driver
+      end
+      @worker.define_function_end
+    end
+
+    def compute(root)
+      @driver.compute(root, @worker.num_parallel)
+    rescue CompTree::NoFunctionError => exception
+      raise Pure::NoFunctionError.new(exception.node_name)
+    end
+
+    def each_function_name(&block)
+      @driver.nodes.each_key(&block)
+    end
+  end
+end

data/lib/pure/dsl.rb

@@ -0,0 +1,2 @@
+require 'pure'
+include Pure::DSL

data/lib/pure/dsl_definition.rb

@@ -0,0 +1,11 @@
+
+module Pure
+  module DSL
+    #
+    # Alias of Pure.define
+    #
+    def pure(*args, &block)
+      Pure.define(*args, &block)
+    end
+  end
+end

data/lib/pure/error.rb

@@ -0,0 +1,89 @@
+
+module Pure
+  # Base class for Pure errors.
+  class Error < StandardError
+  end
+
+  # No parser found.
+  class NoParserError < Error
+    def initialize  #:nodoc:
+      super("no parser found")
+    end
+  end
+
+  # A missing function was encountered during a computation.
+  class NoFunctionError < Error
+    attr_reader :function_name  #:nodoc:
+
+    def initialize(function_name)  #:nodoc:
+      @function_name = function_name
+      super(custom_message)
+    end
+
+    def custom_message  #:nodoc:
+      "no function named `#{function_name}'"
+    end
+  end
+  
+  # Base class for errors found during extraction.
+  class ExtractionTimeError < Error
+    attr_reader :file, :line  #:nodoc:
+
+    def initialize(file, line)  #:nodoc:
+      @file, @line = file, line
+      super(custom_message + " at #{@file}:#{@line}")
+    end
+  end
+
+  class ParseError < ExtractionTimeError
+  end
+  
+  class ParseEntityError < ParseError
+    attr_reader :entity
+    
+    def initialize(file, line, entity)
+      @entity = entity
+      super(file, line)
+    end
+
+    def custom_message
+      "failed to parse `#{entity}'"
+    end      
+  end
+
+  # The parser could not extract a method definition.
+  class ParseMethodError < ParseEntityError
+  end
+
+  # Base class for breaches of pure function restrictions.
+  class RestrictionError < ExtractionTimeError
+  end
+
+  # A *splat argument was present in a pure function defined with `def'.
+  class SplatError < RestrictionError
+    def custom_message  #:nodoc:
+      "cannot use splat argument (*) in pure function defined with `def'"
+    end
+  end
+
+  # A pure function had a default argument.
+  class DefaultArgumentError < RestrictionError
+    def custom_message  #:nodoc:
+      "cannot use default argument in pure function"
+    end
+  end
+
+  # +define_method+ called inside a pure module.
+  class DefineMethodError < RestrictionError
+    def custom_message  #:nodoc:
+      "cannot use define_method in a pure module (use `fun' instead)"
+    end
+  end
+
+  # Attempt to create a pure module inside +eval+.
+  class EvalError < RestrictionError
+    def custom_message  #:nodoc:
+      "cannot define a pure module inside eval (write it to a file instead)"
+    end
+  end
+end

data/lib/pure/extracted_functions.rb

@@ -0,0 +1,11 @@
+
+module Pure
+  #
+  # ExtractedFunctions[parser][pure_module][function_name] = function_data
+  #
+  ExtractedFunctions = Hash.new { |hash, key|
+    hash[key] = Hash.new { |h, k|
+      h[k] = Hash.new
+    }
+  }
+end

data/lib/pure/extractor.rb

@@ -0,0 +1,59 @@
+
+module Pure
+  module Extractor
+    module_function
+
+    def extract(mod, method_name, backtrace)
+      file, line = Util.file_line(backtrace.first)
+      if file == "(eval)"
+        eval_error(backtrace)
+      end
+      mod.parser.extract(mod, method_name, file, line)
+    end
+
+    def eval_error(backtrace)
+      backtrace.each_with_index { |desc, index|
+        if desc =~ %r!:in \`eval\'\Z!
+          file, line = Util.file_line(backtrace[index + 1])
+          raise EvalError.new(file, line)
+        end
+      }
+    end
+
+    def record_function(mod, origin, name, args, backtrace)  #:nodoc:
+      spec = ExtractedFunctions[mod.parser][mod][name] = (
+        case origin
+        when :def
+          #
+          # For `def' definitions, function and argument names are
+          # determined at parse-time.
+          #
+          extract(mod, name, backtrace)
+        when :fun
+          #
+          # For `fun' definitions, function and argument names are
+          # determined at run-time.
+          #
+          # Use the __fun flag to verify the parser's discovery of a
+          # `fun' call.
+          #
+          extract(mod, :__fun, backtrace).
+          merge(:name => name, :args => args)
+        end
+      ).merge(
+        :origin => origin,
+        :parser => mod.parser.name
+      )
+
+      if origin == :def and spec[:splat]
+        raise SplatError.new(spec[:file], spec[:line])
+      end
+
+      if spec[:default]
+        raise DefaultArgumentError.new(spec[:file], spec[:line])
+      end
+
+      spec
+    end
+  end
+end

data/lib/pure/names.rb

@@ -0,0 +1,9 @@
+
+module Pure
+  class Names
+    attr_reader :fun_name, :arg_names
+    def initialize(fun_name, arg_names)
+      @fun_name, @arg_names = fun_name, arg_names
+    end
+  end
+end

data/lib/pure/native_worker.rb

@@ -0,0 +1,27 @@
+
+module Pure
+  class NativeWorker  #:nodoc:
+    attr_reader :num_parallel
+
+    def define_function_begin(pure_module, num_parallel)
+      @num_parallel = num_parallel || self.class.num_parallel
+      @class = Class.new Names do
+        include pure_module
+      end
+    end
+
+    def define_function(spec)
+      lambda { |*args|
+        @class.new(spec[:name], spec[:args]).send(spec[:name], *args)
+      }
+    end
+
+    def define_function_end
+    end
+
+    class << self
+      attr_accessor :num_parallel
+    end
+    @num_parallel = 1
+  end
+end