pure 0.1.0

data/devel/jumpstart/lazy_attribute.rb

@@ -0,0 +1,38 @@
+
+class Jumpstart
+  #
+  # Mixin for lazily-evaluated attributes.
+  #
+  module LazyAttribute
+    #
+    # &block is evaluated when this attribute is requested.  The same
+    # result is returned for subsequent calls until the attribute is
+    # assigned a different value.
+    #
+    def attribute(reader, &block)
+      writer = "#{reader}="
+
+      singleton = (class << self ; self ; end)
+
+      define_evaluated_reader = lambda { |value|
+        singleton.class_eval {
+          remove_method(reader)
+          define_method(reader) { value }
+        }
+      }
+
+      singleton.class_eval {
+        define_method(reader) {
+          value = block.call
+          define_evaluated_reader.call(value)
+          value
+        }
+          
+        define_method(writer) { |value|
+          define_evaluated_reader.call(value)
+          value
+        }
+      }
+    end
+  end
+end

data/devel/jumpstart/ruby.rb

@@ -0,0 +1,44 @@
+
+require 'rbconfig'
+
+class Jumpstart
+  module Ruby
+    EXECUTABLE = lambda {
+      name = File.join(
+        Config::CONFIG["bindir"],
+        Config::CONFIG["RUBY_INSTALL_NAME"]
+      )
+
+      if Config::CONFIG["host"] =~ %r!(mswin|cygwin|mingw)! and
+          File.basename(name) !~ %r!\.(exe|com|bat|cmd)\Z!i
+        name + Config::CONFIG["EXEEXT"]
+      else
+        name
+      end
+    }.call
+
+    class << self
+      def run(*args)
+        cmd = [EXECUTABLE, *args]
+        unless system(*cmd)
+          cmd_str = cmd.map { |t| "'#{t}'" }.join(", ")
+          raise "system(#{cmd_str}) failed with status #{$?.exitstatus}"
+        end
+      end
+      
+      def with_warnings(value = true)
+        previous = $VERBOSE
+        $VERBOSE = value
+        begin
+          yield
+        ensure
+          $VERBOSE = previous
+        end
+      end
+      
+      def no_warnings(&block)
+        with_warnings(false, &block)
+      end
+    end
+  end
+end

data/devel/jumpstart/simple_installer.rb

@@ -0,0 +1,85 @@
+
+require 'rbconfig'
+require 'fileutils'
+require 'find'
+
+class Jumpstart
+  class SimpleInstaller
+    def initialize
+      dest_root = Config::CONFIG["sitelibdir"]
+      sources = []
+      Find.find("./lib") { |source|
+        if install_file?(source)
+          sources << source
+        end
+      }
+      @spec = sources.inject(Array.new) { |acc, source|
+        if source == "./lib"
+          acc
+        else
+          dest = File.join(dest_root, source.sub(%r!\A\./lib!, ""))
+  
+          install = lambda {
+            if File.directory?(source)
+              unless File.directory?(dest)
+                puts "mkdir #{dest}"
+                FileUtils.mkdir(dest)
+              end
+            else
+              puts "install #{source} --> #{dest}"
+              FileUtils.install(source, dest)
+            end
+          }
+            
+          uninstall = lambda {
+            if File.directory?(source)
+              if File.directory?(dest)
+                puts "rmdir #{dest}"
+                FileUtils.rmdir(dest)
+              end
+            else
+              if File.file?(dest)
+                puts "rm #{dest}"
+                FileUtils.rm(dest)
+              end
+            end
+          }
+  
+          acc << {
+            :source => source,
+            :dest => dest,
+            :install => install,
+            :uninstall => uninstall,
+          }
+        end
+      }
+    end
+  
+    def install_file?(source)
+      File.directory?(source) or
+      (File.file?(source) and File.extname(source) == ".rb")
+    end
+
+    def install
+      @spec.each { |entry|
+        entry[:install].call
+      }
+    end
+  
+    def uninstall
+      @spec.reverse.each { |entry|
+        entry[:uninstall].call
+      }
+    end
+
+    def run(args = ARGV)
+      if args.empty?
+        install
+      elsif args.size == 1 and args.first == "--uninstall"
+        uninstall
+      else
+        raise "unrecognized arguments: #{args.inspect}"
+      end
+    end
+  end
+end

data/install.rb

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

data/lib/pure.rb

@@ -0,0 +1,19 @@
+
+require 'pure/pure_private/creator'
+require 'pure/pure_private/extractor'
+
+module Pure
+  PURE_VERSION = "0.1.0"
+
+  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/pure_private/creator.rb

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

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

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

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

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