pure 0.1.0

data/CHANGES.rdoc

@@ -0,0 +1,7 @@
+
+= Pure ChangeLog
+
+== Version 0.1.0
+
+* Initial release.
+

data/MANIFEST

@@ -0,0 +1,30 @@
+CHANGES.rdoc
+MANIFEST
+README.rdoc
+Rakefile
+devel/jumpstart.rb
+devel/jumpstart/lazy_attribute.rb
+devel/jumpstart/ruby.rb
+devel/jumpstart/simple_installer.rb
+install.rb
+lib/pure.rb
+lib/pure/pure_private/creator.rb
+lib/pure/pure_private/driver.rb
+lib/pure/pure_private/error.rb
+lib/pure/pure_private/extractor.rb
+lib/pure/pure_private/extractor_ripper.rb
+lib/pure/pure_private/extractor_ruby_parser.rb
+lib/pure/pure_private/function_database.rb
+lib/pure/pure_private/singleton_features.rb
+lib/pure/pure_private/util.rb
+spec/basic_spec.rb
+spec/combine_spec.rb
+spec/common.rb
+spec/error_spec.rb
+spec/fun_spec.rb
+spec/lazy_spec.rb
+spec/parser_spec.rb
+spec/readme_spec.rb
+spec/splat_spec.rb
+spec/subseqent_spec.rb
+spec/timed_spec.rb

data/README.rdoc

@@ -0,0 +1,59 @@
+
+= Pure
+
+== Summary
+
+Language-level support for automatic parallelism and lazy evaluation.
+
+== Synopsis
+
+  require 'pure'
+  include Pure
+  
+  geometry = pure do
+    def area(width, height)
+      width*height
+    end
+  
+    def width(border)
+      7 + border
+    end
+  
+    def height(border)
+      5 + border
+    end
+  
+    def border
+      2
+    end
+  end
+  
+  # compute the area using 3 parallel threads
+  puts geometry.compute(:area, :threads => 3)
+  # => 63
+
+  # We've done this computation.
+  puts((7 + 2)*(5 + 2))
+  # => 63
+
+== Description
+
++Pure+ is an importation of the pure functional paradigm into Ruby.
+
+Method names and argument names have lexicographical meaning within a
++pure+ block.  Above, the +width+ argument to +area+ corresponds by
+its literal name to the +width+ method, for example.
+
++pure+ returns a module which may be included into other +pure+ blocks.
+
+Implementation details are placed inside Pure::PurePrivate, making
+<tt>include Pure</tt> a hygienic operation.
+
+Pure does not modify any of the standard classes.
+
+== Implementation
+
+The "ripper" parser is used if it exists, otherwise ruby_parser is
+used.
+
+Pure has been tested on MRI 1.8.6, 1.8.7, 1.9.1 and the latest jruby.

data/Rakefile

@@ -0,0 +1,10 @@
+$LOAD_PATH.unshift "devel"
+
+require "jumpstart"
+
+Jumpstart.new "pure" do |s|
+  s.developer("James M. Lawrence", "quixoticsycophant@gmail.com")
+  s.dependency("comp_tree", ">= 0.7.6")
+  s.rubyforge_user = "quix"
+  s.rubyforge_name = "purefunctional"
+end

data/devel/jumpstart.rb

@@ -0,0 +1,634 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+require 'rubygems'
+require 'ostruct'
+require 'rbconfig'
+
+require 'rake/gempackagetask'
+require 'rake/contrib/sshpublisher'
+require 'rake/clean'
+
+require 'rdoc/rdoc'
+
+require 'jumpstart/ruby'
+require 'jumpstart/lazy_attribute'
+require 'jumpstart/simple_installer'
+
+class Jumpstart
+  include LazyAttribute
+
+  def initialize(project_name)
+    attribute :name do
+      project_name
+    end
+
+    attribute :version do
+      const = "VERSION"
+      begin
+        require name
+        if mod = Object.const_get(to_camel_case(name))
+          candidates = mod.constants.grep(%r!#{const}!)
+          result = (
+            if candidates.size == 1
+              candidates.first
+            elsif candidates.include? const
+              const
+            else
+              raise
+            end
+          )
+          mod.const_get(result)
+        else
+          raise
+        end
+      rescue Exception
+        "0.0.0"
+      end
+    end
+
+    attribute :rubyforge_name do
+      name.gsub('_', '')
+    end
+
+    attribute :rubyforge_user do
+      email.first[%r!^.*(?=@)!]
+    end
+
+    attribute :readme_file do
+      "README.rdoc"
+    end
+
+    attribute :history_file do
+      "CHANGES.rdoc"
+    end
+
+    attribute :doc_dir do
+      "documentation"
+    end
+
+    attribute :spec_files do
+      Dir["spec/*_{spec,example}.rb"]
+    end
+
+    attribute :test_files do
+      Dir["test/test_*.rb"]
+    end
+
+    attribute :rcov_dir do
+      "coverage"
+    end
+
+    attribute :spec_output do
+      "spec.html"
+    end
+
+    %w[gem tgz].map { |ext|
+      attribute ext.to_sym do
+        "pkg/#{name}-#{version}.#{ext}"
+      end
+    }
+
+    attribute :rcov_options do
+      # workaround for the default rspec task
+      Dir["*"].select { |f| File.directory? f }.inject(Array.new) { |acc, dir|
+        if dir == "lib"
+          acc
+        else
+          acc + ["--exclude", dir + "/"]
+        end
+      } + ["--text-report"]
+    end
+
+    attribute :readme_file do
+      "README.rdoc"
+    end
+    
+    attribute :manifest_file do
+      "MANIFEST"
+    end
+
+    attribute :files do
+      if File.exist?(manifest_file)
+        File.read(manifest_file).split("\n")
+      else
+        [manifest_file] + `git ls-files`.split("\n")
+      end
+    end
+
+    attribute :rdoc_files do
+      Dir["lib/**/*.rb"]
+    end
+    
+    attribute :extra_rdoc_files do
+      if File.exist?(readme_file)
+        [readme_file]
+      else
+        []
+      end
+    end
+
+    attribute :rdoc_options do
+      if File.exist?(readme_file)
+        ["--main", readme_file]
+      else
+        []
+      end + [
+       "--title", "#{name}: #{summary}",
+      ] + (files - rdoc_files).inject(Array.new) { |acc, file|
+        acc + ["--exclude", file]
+      }
+    end
+
+    attribute :browser do
+      if Config::CONFIG["host"] =~ %r!darwin!
+        app = %w[Firefox Safari].map { |t|
+          "/Applications/#{t}.app"
+        }.select { |t|
+          File.exist? t
+        }.first
+        if app
+          ["open", app]
+        else
+          raise "need to set `browser'"
+        end
+      else
+        "firefox"
+      end
+    end
+
+    attribute :gemspec do
+      Gem::Specification.new { |g|
+        g.has_rdoc = true
+        %w[
+          name
+          authors
+          email
+          summary
+          version
+          description
+          files
+          extra_rdoc_files
+          rdoc_options
+        ].each { |param|
+          value = send(param) and (
+            g.send("#{param}=", value)
+          )
+        }
+
+        if rubyforge_name
+          g.rubyforge_project = rubyforge_name
+        end
+
+        if url
+          g.homepage = url
+        end
+
+        extra_deps.each { |dep|
+          g.add_dependency(*dep)
+        }
+
+        extra_dev_deps.each { |dep|
+          g.add_development_dependency(*dep)
+        }
+      }
+    end
+
+    attribute :readme_contents do
+      File.read(readme_file) rescue "FIXME: readme_file"
+    end
+    
+    attribute :sections do
+      begin
+        pairs = Hash[*readme_contents.split(%r!^== (\w+).*?$!)[1..-1]].map {
+          |section, contents|
+          [section.downcase, contents.strip]
+        }
+        Hash[*pairs.flatten]
+      rescue
+        nil
+      end
+    end
+
+    attribute :description_section do
+      "description"
+    end
+
+    attribute :summary_section do
+      "summary"
+    end
+
+    attribute :description_sentences do
+      1
+    end
+
+    attribute :summary_sentences do
+      1
+    end
+    
+    [:summary, :description].each { |section|
+      attribute section do
+        begin
+          sections[send("#{section}_section")].
+          gsub("\n", " ").
+          split(%r!\.\s*!m).
+          first(send("#{section}_sentences")).
+          join(".  ") << "."
+        rescue
+          "FIXME: #{section}"
+        end
+      end
+    }
+
+    attribute :url do
+      begin
+        readme_contents.match(%r!^\*.*?(http://\S+)!)[1]
+      rescue
+        "http://#{rubyforge_name}.rubyforge.org"
+      end
+    end
+
+    attribute :extra_deps do
+      []
+    end
+
+    attribute :extra_dev_deps do
+      []
+    end
+
+    yield self
+
+    self.class.instance_methods(false).select { |t|
+      t.to_s =~ %r!\Adefine_!
+    }.each { |method_name|
+      send(method_name)
+    }
+  end
+
+  def developer(name, email)
+    authors << name
+    self.email << email
+  end
+
+  def authors
+    @authors ||= Array.new
+  end
+
+  def email
+    @email ||= Array.new
+  end
+
+  def dependency(name, version)
+    extra_deps << [name, version]
+  end
+
+  def define_clean
+    task :clean do
+      Rake::Task[:clobber].invoke
+    end
+  end
+
+  def define_package
+    task manifest_file do
+      create_manifest
+    end
+    CLEAN.include manifest_file
+    task :package => :clean
+    Rake::GemPackageTask.new(gemspec) { |t|
+      t.need_tar = true
+    }
+  end
+
+  def define_spec
+    unless spec_files.empty?
+      require 'spec/rake/spectask'
+      
+      desc "run specs"
+      Spec::Rake::SpecTask.new('spec') do |t|
+        t.spec_files = spec_files
+      end
+    
+      desc "run specs with text output"
+      Spec::Rake::SpecTask.new('text_spec') do |t|
+        t.spec_files = spec_files
+        t.spec_opts = ['-fs']
+      end
+  
+      desc "run specs with html output"
+      Spec::Rake::SpecTask.new('full_spec') do |t|
+        t.spec_files = spec_files
+        t.rcov = true
+        t.rcov_opts = rcov_options
+        t.spec_opts = ["-fh:#{spec_output}"]
+      end
+      
+      desc "run full_spec then open browser"
+      task :show_spec => :full_spec do
+        open_browser(spec_output, rcov_dir + "/index.html")
+      end
+
+      desc "run specs individually"
+      task :spec_deps do
+        run_ruby_on_each(*spec_files)
+      end
+
+      task :prerelease => [:spec, :spec_deps]
+      task :default => :spec
+
+      CLEAN.include spec_output
+    end
+  end
+
+  def define_test
+    unless test_files.empty?
+      desc "run tests"
+      task :test do
+        test_files.each { |file|
+          require file
+        }
+      end
+      
+      desc "run tests with rcov"
+      task :full_test do
+        verbose(false) {
+          sh("rcov", "-o", rcov_dir, "--text-report",
+            *(test_files + rcov_options)
+          )
+        }
+      end
+      
+      desc "run full_test then open browser"
+      task :show_test => :full_test do
+        open_browser(rcov_dir + "/index.html")
+      end
+      
+      desc "run tests individually"
+      task :test_deps do
+        run_ruby_on_each(*test_files)
+      end
+      
+      task :prerelease => [:test, :test_deps]
+      task :default => :test
+      
+      CLEAN.include rcov_dir
+    end
+  end
+
+  def define_doc
+    desc "run rdoc"
+    task :doc => :clean_doc do
+      args = (
+        gemspec.rdoc_options +
+        gemspec.require_paths.clone +
+        gemspec.extra_rdoc_files +
+        ["-o", doc_dir]
+      ).flatten.map { |t| t.to_s }
+      RDoc::RDoc.new.document args
+    end
+    
+    task :clean_doc do
+      # normally rm_rf, but mimic rake/clean output
+      rm_r(doc_dir) rescue nil
+    end
+
+    desc "run rdoc then open browser"
+    task :show_doc => :doc do
+      open_browser(doc_dir + "/index.html")
+    end
+
+    task :rdoc => :doc
+    task :clean => :clean_doc
+  end
+
+  def define_publish
+    desc "upload docs"
+    task :publish => [:clean_doc, :doc] do
+      Rake::SshDirPublisher.new(
+        "#{rubyforge_user}@rubyforge.org",
+        "/var/www/gforge-projects/#{rubyforge_name}",
+        doc_dir
+      ).upload
+    end
+  end
+
+  def define_install
+    desc "direct install (no gem)"
+    task :install do
+      SimpleInstaller.new.run([])
+    end
+
+    desc "direct uninstall (no gem)"
+    task :uninstall do
+      SimpleInstaller.new.run(["--uninstall"])
+    end
+  end
+  
+  def define_debug
+    runner = Class.new do
+      def comment_src_dst(on)
+        on ? ["", "#"] : ["#", ""]
+      end
+      
+      def comment_regions(on, contents, start)
+        src, dst = comment_src_dst(on)
+        contents.gsub(%r!^(\s+)#{src}#{start}.*?^\1#{src}(\}|end)!m) { |chunk|
+          indent = $1
+          chunk.gsub(%r!^#{indent}#{src}!, "#{indent}#{dst}")
+        }
+      end
+      
+      def comment_lines(on, contents, start)
+        src, dst = comment_src_dst(on)
+        contents.gsub(%r!^(\s*)#{src}#{start}!) { 
+          $1 + dst + start
+        }
+      end
+
+      def debug_info(enable)
+        Find.find("lib", "test") { |path|
+          if path =~ %r!\.rb\Z!
+            Jumpstart.replace_file(path) { |contents|
+              result = comment_regions(!enable, contents, "debug")
+              comment_lines(!enable, result, "trace")
+            }
+          end
+        }
+      end
+    end
+    
+    desc "enable debug and trace calls"
+    task :debug_on do
+      runner.new.debug_info(true)
+    end
+    
+    desc "disable debug and trace calls"
+    task :debug_off do
+      runner.new.debug_info(false)
+    end
+  end
+
+  def define_columns
+    desc "check for columns > 80"
+    task :check_columns do
+      Dir["**/*.rb"].each { |file|
+        File.read(file).scan(%r!^.{81}!) { |match|
+          unless match =~ %r!http://!
+            raise "#{file} greater than 80 columns: #{match}"
+          end
+        }
+      }
+    end
+    task :prerelease => :check_columns
+  end
+
+  def define_comments
+    task :comments do
+      file = "comments.txt"
+      write_file(file) {
+        Array.new.tap { |result|
+          (["Rakefile"] + Dir["**/*.{rb,rake}"]).each { |file|
+            File.read(file).scan(%r!\#[^\{].*$!) { |match|
+              result << match
+            }
+          }
+        }.join("\n")
+      }
+      CLEAN.include file
+    end
+  end
+
+  def define_check_directory
+    task :check_directory do
+      unless `git status` =~ %r!nothing to commit \(working directory clean\)!
+        raise "Directory not clean"
+      end
+    end
+  end
+
+  def define_ping
+    task :ping do
+      %w[github.com rubyforge.org].each { |server|
+        cmd = "ping " + (
+          if Config::CONFIG["host"] =~ %r!darwin!
+            "-c2 #{server}"
+          else
+            "#{server} 2 2"
+          end
+        )
+        unless `#{cmd}` =~ %r!0% packet loss!
+          raise "No ping for #{server}"
+        end
+      }
+    end
+  end
+
+  def define_update_jumpstart
+    url = ENV["RUBY_JUMPSTART"] || "git://github.com/quix/jumpstart.git"
+    task :update_jumpstart do
+      git "clone", url
+      rm_rf "devel/jumpstart"
+      Dir["jumpstart/**/*.rb"].each { |source|
+        dest = source.sub(%r!\Ajumpstart/!, "devel/")
+        dest_dir = File.dirname(dest)
+        mkdir_p(dest_dir) unless File.directory?(dest_dir)
+        cp source, dest
+      }
+      rm_r "jumpstart"
+      git "commit", "devel", "-m", "update jumpstart"
+    end
+  end
+
+  def git(*args)
+    sh("git", *args)
+  end
+
+  def create_manifest
+    write_file(manifest_file) {
+      files.sort.join("\n")
+    }
+  end
+
+  def rubyforge(command, file)
+    sh(
+      "rubyforge",
+      command,
+      rubyforge_name,
+      rubyforge_name,
+      version.to_s,
+      file
+    )
+  end
+
+  def define_release
+    task :prerelease => [:clean, :check_directory, :ping]
+
+    task :finish_release do
+      gem_md5, tgz_md5 = [gem, tgz].map { |file|
+        "#{file}.md5".tap { |md5|
+          sh("md5sum #{file} > #{md5}")
+        }
+      }
+
+      rubyforge("add_release", gem)
+      [gem_md5, tgz, tgz_md5].each { |file|
+        rubyforge("add_file", file)
+      }
+
+      git("tag", "#{name}-" + version.to_s)
+      git(*%w(push --tags origin master))
+    end
+
+    task :release => [:prerelease, :package, :publish, :finish_release]
+  end
+
+  def define_debug_gem
+    task :debug_gem do
+      puts gemspec.to_ruby
+    end
+  end
+  
+  def open_browser(*files)
+    sh(*([browser].flatten + files))
+  end
+
+  def write_file(file)
+    yield.tap { |contents|
+      File.open(file, "wb") { |out|
+        out.print(contents)
+      }
+    }
+  end
+
+  def run_ruby_on_each(*files)
+    files.each { |file|
+      Ruby.run("-w", file)
+    }
+  end
+
+  def to_camel_case(str)
+    str.split('_').map { |t| t.capitalize }.join
+  end
+
+  class << self
+    def replace_file(file)
+      old_contents = File.read(file)
+      yield(old_contents).tap { |new_contents|
+        if old_contents != new_contents
+          File.open(file, "wb") { |output|
+            output.print(new_contents)
+          }
+        end
+      }
+    end
+  end
+end
+
+unless respond_to? :tap
+  class Object
+    def tap
+      yield self
+      self
+    end
+  end
+end
+