rewrite 0.0.1 → 0.0.2

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2008-06-15
+
+* 1 tiny enhancement:
+  * Initial pre-release of a preview of an alpha of an undocumented proof-of-concept

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Reginald Braithwaite
+
+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.

data/Manifest.txt

@@ -0,0 +1,37 @@
+History.txt
+License.txt
+Manifest.txt
+PostInstall.txt
+README.txt
+Rakefile
+config/hoe.rb
+config/requirements.rb
+lib/rewrite.rb
+lib/rewrite/def_var.rb
+lib/rewrite/evaluation_strategies.rb
+lib/rewrite/prelude.rb
+lib/rewrite/prelude/andand.rb
+lib/rewrite/prelude/called_by_name.rb
+lib/rewrite/variables.rb
+lib/rewrite/version.rb
+lib/rewrite/with.rb
+script/console
+script/destroy
+script/generate
+script/txt2html
+setup.rb
+tasks/deployment.rake
+tasks/environment.rake
+tasks/website.rake
+test/test_andand.rb
+test/test_call_by_name.rb
+test/test_call_by_thunk.rb
+test/test_helper.rb
+test/test_rewriter_helpers.rb
+test/test_syntax_let.rb
+test/test_with.rb
+website/index.html
+website/index.txt
+website/javascripts/rounded_corners_lite.inc.js
+website/stylesheets/screen.css
+website/template.html.erb

data/PostInstall.txt

@@ -0,0 +1,7 @@
+
+For more information on rewrite, see http://rewrite.rubyforge.org
+
+NOTE: Change this information in PostInstall.txt 
+You can also delete it if you don't want it.
+
+

data/README.txt

@@ -0,0 +1,46 @@
+= rewrite
+
+* http://rewrite.rubyforge.org
+
+== DESCRIPTION:
+
+* Adds certain features to Ruby programs using sexp rewriting rather than open classes.
+
+== FEATURES:
+
+* Andand
+* Call by name
+
+== REQUIREMENTS:
+
+* Parse_Tree
+* Ruby2Ruby
+
+== INSTALL:
+
+* sudo gem install rewrite
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Reg Braithwaite
+
+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.

data/Rakefile

@@ -0,0 +1,4 @@
+require 'config/requirements'
+require 'config/hoe' # setup Hoe + all gem configuration
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/config/hoe.rb

@@ -0,0 +1,74 @@
+require 'rewrite/version'
+
+AUTHOR = 'Reg Braithwaite'  # can also be an array of Authors
+EMAIL = "raganwald+rewrite@gmail.com"
+DESCRIPTION = "Syntactic metaprogramming for Ruby"
+GEM_NAME = 'rewrite' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'rewrite' # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+EXTRA_DEPENDENCIES = [
+  ['ruby2ruby', '>= 1.1.9'],
+  ['parse_tree', '>= 2.2.0']
+]    # An array of rubygem dependencies [name, version]
+
+@config_file = "~/.rubyforge/user-config.yml"
+@config = nil
+RUBYFORGE_USERNAME = "raganwald"
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load(File.read(File.expand_path(@config_file)))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}
+Run 'rubyforge setup' to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  RUBYFORGE_USERNAME.replace @config["username"]
+end
+
+
+REV = nil
+# UNCOMMENT IF REQUIRED:
+# REV = YAML.load(`svn info`)['Revision']
+VERS = Rewrite::VERSION::STRING + (REV ? ".#{REV}" : "")
+RDOC_OPTS = ['--quiet', '--title', 'rewrite documentation',
+    "--opname", "index.html",
+    "--line-numbers",
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps
+    @extra_deps.reject! { |x| Array(x).first == 'hoe' }
+    @extra_deps
+  end
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.developer(AUTHOR, EMAIL)
+  p.description = DESCRIPTION
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
+
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  #p.extra_deps = EXTRA_DEPENDENCIES
+
+    #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+  end
+
+CHANGES = $hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n")
+PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+$hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
+$hoe.rsync_args = '-av --delete --ignore-errors'
+$hoe.spec.post_install_message = File.open(File.dirname(__FILE__) + "/../PostInstall.txt").read rescue ""

data/config/requirements.rb

@@ -0,0 +1,15 @@
+require 'fileutils'
+include FileUtils
+
+require 'rubygems'
+%w[rake hoe newgem rubigen].each do |req_gem|
+  begin
+    require req_gem
+  rescue LoadError
+    puts "This Rakefile requires the '#{req_gem}' RubyGem."
+    puts "Installation: gem install #{req_gem} -y"
+    exit
+  end
+end
+
+$:.unshift(File.join(File.dirname(__FILE__), %w[.. lib]))

data/lib/rewrite/def_var.rb

@@ -0,0 +1,63 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'rubygems'
+require 'parse_tree'
+require 'sexp_processor'
+
+module Rewrite
+    
+  class DefVar
+    
+    def initialize(sym, sexp)
+      @sym, @sexp = sym, sexp
+    end
+    
+    def process(sexp)
+      if sexp.length >= 3 && sexp[0] == :call && sexp[2] == :call &&
+          (callee = sexp[1]) && callee.length >= 4 && callee[0] == :iter && callee[1].to_a == [:fcall, :lambda]
+        parameters = callee[2]
+        if parameters.nil?
+          callee[2] = s(:dasgn_curr, @sym)
+          s(:call,
+            callee,
+            :call,
+            s(:array, @sexp)
+          )
+        elsif parameters[0] == :dasgn || parameters[0] == :dasgn_curr
+          callee[2] = s(:masgn,
+            s(:array,
+              s(:dasgn_curr, parameters[1]),
+              s(:dasgn_curr, @sym)
+            )
+          )
+          s(:call,
+            callee,
+            :call,
+            sexp[3] + [ @sexp ]
+          )
+        elsif parameters[0] == :masgn
+          callee[2][1] << s(:dasgn_curr, @sym)
+          s(:call,
+            callee,
+            :call,
+            sexp[3] + [ @sexp ]
+          )
+        else
+          raise "Confused by #{Ruby2Ruby.new.process(parameters)}"
+        end
+      else
+        s(:call,
+          s(:iter,
+            s(:fcall, :lambda),
+            s(:dasgn_curr, @sym),
+            sexp
+          ),
+          :call,
+          s(:array, @sexp)
+        )
+      end
+    end
+    
+  end
+  
+end

data/lib/rewrite/evaluation_strategies.rb

@@ -0,0 +1,86 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'rubygems'
+require 'parse_tree'
+require 'sexp_processor'
+
+module Rewrite
+  
+  class RewriteParametersAsThunkCalls
+  
+    def sexp(exp)
+      if exp.kind_of? Array
+        s(*exp.map { |e| sexp(e) })
+      else
+        exp
+      end
+    end
+  
+    def process(sexp)
+      raise "Expected a proc" unless sexp[0] == :proc
+      raise "Expected a proc with arity >= 1" if sexp[1] == nil
+      arguments = sexp[1]
+      variable_symbols = if arguments[0] == :dasgn || arguments[0] == :dasgn_curr
+        [arguments[1]]
+      elsif arguments[0] == :masgn
+        arguments[1][1..-1].map { |pair| pair[1] }
+      else
+        raise "don't know how to extract paramater names from #{arguments}"
+      end
+      
+      s(:iter,
+        s(:fcall, :lambda),
+        sexp(arguments),
+        variable_symbols.inject(sexp[2]) { |result, variable|
+          VariableRewriter.new(variable, s(:call, s(:dvar, variable), :call)).process(eval(result.inspect))
+        }
+      )
+      
+    end
+  
+  end
+    
+  # Initialize with a list of names, e.g.
+  # CallByThunk.new(:foo, :bar)
+  #
+  # It then converts expressions of the form foo(expr1, expr2, ..., exprn) into
+  # foo.call( lambda { expr1 }, lambda { expr2 }, ..., lambda { exprn })
+  #
+  # This is handy when combined with RewriteVariablesAsThunkCalls in the following
+  # manner: if you rewrite function invocations with CallByThunk and also rewrite the
+  # function's body to convert variable references into thunk calls, you now have a
+  # function with call-by-name semantics
+  #
+  class CallByThunk < SexpProcessor
+    
+    def initialize(*functions_to_thunkify)
+      @functions_to_thunkify = functions_to_thunkify
+      super()
+    end
+    
+    def process_fcall(exp)
+      qua = exp.dup
+      exp.shift
+      name = exp.shift
+      if @functions_to_thunkify.include? name
+        thunked = s(:call, s(:dvar, name), :call)
+        unless exp.empty?
+          arguments = exp.shift
+          raise "Do not understand arguments #{arguments}" unless arguments[0] == :array
+          arguments.shift
+          thunked_arguments = s(:array)
+          until arguments.empty?
+            thunked_arguments <<  s(:iter, s(:fcall, :lambda), nil, process(arguments.shift))
+          end
+          thunked << thunked_arguments
+        end
+      else
+        thunked = s(:fcall, name) # :fcall, name_of_the_function
+        thunked << process(exp.shift) unless exp.empty?
+      end
+      thunked
+    end
+    
+  end
+  
+end

data/lib/rewrite/prelude/andand.rb

@@ -0,0 +1,191 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'rubygems'
+require 'parse_tree'
+require 'sexp_processor'
+require 'sexp'
+
+module Rewrite
+
+  module Prelude
+  
+    # Adds a guarded method invocation to Ruby:
+    #
+    #   with(andand) do
+    #     ...
+    #     @phone = Location.find(:first, ...elided... ).andand.phone
+    #     ...
+    #   end
+    #
+    # It also works with parameters, blocks, and procs passed as blocks.
+    #
+    # Works by rewriting expressions like:
+    #
+    #   numbers.andand.inject(&:+)
+    #
+    # Into:
+    #
+    #  lambda { |__1234567890__|
+    #    if __1234567890__.nil?
+    #      nil
+    #    else
+    #      __1234567890__.inject(&:+)
+    #    end
+    #  }.call(numbers)
+    #
+    class Andand < SexpProcessor
+      
+      def process_iter(exp)
+        exp.shift
+        receiver_sexp = exp.first #[:call, [:call, [:lit, 1..10], :andand], :inject]
+        if receiver_sexp[0] == :call && matches_andand_invocation(receiver_sexp[1])
+          exp.shift
+          mono_parameter = Rewrite.gensym()
+          s(:call, 
+            s(:iter, 
+              s(:fcall, :lambda), 
+              s(:dasgn_curr, mono_parameter), 
+              s(:if, 
+                s(:call, s(:dvar, mono_parameter), :nil?), 
+                s(:nil), 
+                begin
+                  s(:iter, 
+                    s(:call, 
+                      s(:dvar, mono_parameter), 
+                      *(receiver_sexp[2..-1].map { |inner| process_inner_expr inner })
+                    ), 
+                    *(exp.map { |inner| process_inner_expr inner })
+                  )
+                ensure
+                  exp.clear
+                end
+              )
+            ), 
+            :call, 
+            s(:array, 
+              process_inner_expr(receiver_sexp[1][1]) # s(:lit, 1..10)
+            )
+          )
+        else
+          begin
+            s(:iter,
+              *(exp.map { |inner| process_inner_expr inner })
+            )
+          ensure
+            exp.clear
+          end
+        end
+      end
+    
+      def process_call(exp)
+        # s(:call, s(:call, s(:lit, :foo), :andand), :bar)
+        exp.shift
+        # s(s(:call, s(:lit, :foo), :andand), :bar)
+        receiver_sexp = exp.first
+        if matches_andand_invocation(receiver_sexp) # s(:call, s(:lit, :foo), :andand)
+          exp.shift
+          # s( :bar )
+          mono_parameter = Rewrite.gensym()
+          s(:call, 
+            s(:iter, 
+              s(:fcall, :lambda), 
+              s(:dasgn_curr, mono_parameter), 
+              s(:if, 
+                s(:call, s(:dvar, mono_parameter), :nil?), 
+                s(:nil), 
+                begin
+                  s(:call, 
+                    s(:dvar, mono_parameter), 
+                    *(exp.map { |inner| process_inner_expr inner })
+                  )
+                ensure
+                  exp.clear
+                end
+              )
+            ), 
+            :call, 
+            s(:array, 
+              process_inner_expr(receiver_sexp[1]) # s(:lit, :foo)
+            )
+          )
+        else
+          # pass through
+          begin
+            s(:call,
+              *(exp.map { |inner| process_inner_expr inner })
+            )
+          ensure
+            exp.clear
+          end
+        end
+      end
+    
+      def process_block_pass(exp)
+        orig = lambda { |exp_dup|
+          lambda { Ruby2Ruby.new.process(exp_dup) }
+        }.call(exp)
+        # [:block_pass, [:lit, :+], [:call, [:call, [:vcall, :foo], :andand], :bar]]
+        # [:block_pass, [:lit, :blitz], [:call, [:call, [:vcall, :foo], :andand], :bar, [:array, [:lit, :bash]]]]
+        exp.shift
+        # [[:lit, :+], [:call, [:call, [:vcall, :foo], :andand], :bar]]
+        # [[:lit, :blitz], [:call, [:call, [:vcall, :foo], :andand], :bar, [:array, [:lit, :bash]]]]
+        block_exp = process_inner_expr(exp.shift)
+        call_exp = exp.shift
+        raise "expected block_pass to have a receiver and a call form near #{orig.call}" unless exp.empty?
+        # [:call, [:call, [:vcall, :foo], :andand], :bar]
+        # [:call, [:call, [:vcall, :foo], :andand], :bar, [:array, [:lit, :bash]]]
+        raise 'confused' unless call_exp.shift == :call
+        # [[:call, [:vcall, :foo], :andand], :bar]
+        # [[:call, [:vcall, :foo], :andand], :bar, [:array, [:lit, :bash]]]
+        receiver_sexp = call_exp.first
+        if matches_andand_invocation(receiver_sexp) # [:call, [:vcall, :foo], :andand]
+          call_exp.shift
+          # [:bar]
+          # [:bar, [:array, [:lit, :bash]]]
+          mono_parameter = Rewrite.gensym()
+          s(:call, 
+            s(:iter, 
+              s(:fcall, :lambda), 
+              s(:dasgn_curr, mono_parameter), 
+              s(:if, 
+                s(:call, s(:dvar, mono_parameter), :nil?), 
+                s(:nil), 
+                s(:block_pass,
+                  block_exp,
+                  s(:call, 
+                    s(:dvar, mono_parameter), 
+                    *(call_exp.map { |inner| process_inner_expr inner })
+                  )
+                )
+              )
+            ), 
+            :call, 
+            s(:array, 
+              process_inner_expr(receiver_sexp[1]) # s(:lit, :foo)
+            )
+          )
+        else
+          s(:block_pass,
+            block_exp,
+            s(:call,
+              *(call_exp.map { |inner| process_inner_expr inner })
+            )
+          )
+        end
+      end
+      
+      private 
+      
+      def process_inner_expr(inner)
+          inner.kind_of?(Array) ? process(inner) : inner
+      end
+      
+      def matches_andand_invocation(sexp)
+        sexp[0] == :call && sexp[2] == :andand
+      end
+      
+    end
+  
+  end
+
+end

data/lib/rewrite/prelude/called_by_name.rb

@@ -0,0 +1,94 @@
+module Rewrite
+  
+  module Prelude
+  
+    # Warning: Extreme Funk ahead:
+    #
+    # CalledByName allows you to define your own function-like-things that are called by name rather than
+    # by value. Here is a trivial example:
+    #
+    #    with(
+    #      called_by_name(:my_or) { |arg1,  arg2|
+    #        if  arg1
+    #          true
+    #        else
+    #          !!arg2
+    #        end
+    #      }
+    #    ) do
+    #      ...
+    #      my_or(
+    #        true, nil.raise_missing_method_exception
+    #      )
+    #      ...
+    #    end
+    #
+    # First, and most obviously, you get something that looks like a real function. Procs in Ruby are just objects
+    # that capture the bindings where theire initializing block was created, and you have to invoke them using #call
+    # or #[].
+    #
+    # Second, and this is the funky bit, parameters inside of your function-like-thing are called by name. Meaning,
+    # when you call your function-like-thing, instead of evaluating each parameter's expression and passing its
+    # value, Ruby passes the expression itself. The expression is not evaluated until the parpameter is actually used,
+    # and if you use it more than once the expression is evaluated more than once. This matters when there are side
+    # effects.
+    #
+    # The example above shows how call-by-name can be used to implement short-circuit evaluation, something that is
+    # not possible in Ruby without a lot of boilerplate introducing lambdas. When you call my_or, it evaluates arg1
+    # as part of the if statement, that evaluates to true, and it never evaluates arg2. Therefore, it never tries
+    # to send a method to nil and thus never raises an exception.
+    #
+    # Works by rewriting:
+    #
+    #    with(
+    #      called_by_name(:my_or) { |arg1,  arg2|
+    #        if  arg1
+    #          true
+    #        else
+    #          !!arg2
+    #        end
+    #      }
+    #    ) do
+    #      ...
+    #      my_or(
+    #        true, nil.raise_missing_method_exception
+    #      )
+    #      ...
+    #    end
+    #
+    # Into:
+    #
+    #    lambda { |my_or|
+    #      ...
+    #      my_or.call(
+    #        lambda { true }, lambda { nil.raise_missing_method_exception }
+    #      )
+    #      ...
+    #    }.call(
+    #      lambda { |arg1,  arg2|
+    #        if arg1.call
+    #          true
+    #        else
+    #          !!arg2.call
+    #        end
+    #      }
+    #    )
+    #
+    class CalledByName
+  
+      def initialize(name, &proc)
+        @let = Rewrite::DefVar.new(name, Rewrite::RewriteParametersAsThunkCalls.new.process(eval(proc.to_sexp.inspect)))
+        @call_by_thunk = Rewrite::CallByThunk.new(name) 
+      end
+  
+      def process(exp)
+        @let.process(
+          @call_by_thunk.process(exp)
+        )
+      end
+  
+    end
+
+  end
+
+end

data/lib/rewrite/prelude.rb

@@ -0,0 +1,43 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+Dir["#{File.dirname(__FILE__)}/prelude/*.rb"].each do |element|
+   require element
+end
+
+    
+module Rewrite
+  
+  # Module containing standard rewriting features. For more information about each feature, go directly to the class,
+  # such as Andand or CalledByName. If you <tt>include Rewrite::Prelude</tt>, you get some methods as sugar. For a
+  # list of those methods, go to InstanceMethods.
+  #--
+  # TODO: Including the prelude should mean that all of these classes are processed by default, I shouldn't
+  #       have to write them all out as instance methods
+  module Prelude
+    
+    module ClassMethods #:nodoc: all
+      
+    end
+    
+    module InstanceMethods
+      
+      # Create a new CalledByName rewriter
+      def called_by_name(name, &proc)
+        CalledByName.new(name, &proc)
+      end
+      
+      # Instantiate Andand rewriting
+      def andand()
+        Andand.new
+      end
+      
+    end
+    def self.included(receiver) #:nodoc: all
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+    
+  end
+  
+end