rewrite 0.1.0 → 0.2.0

data/README.txt

@@ -10,6 +10,7 @@
 
 * Andand
 * Call by name
+* Unhygienic macros
 
 == REQUIREMENTS:
 

data/lib/rewrite/prelude/andand.rb

@@ -88,7 +88,7 @@ module Rewrite
           exp.shift
           # s( :bar )
           mono_parameter = Rewrite.gensym()
-          s(:call, 
+          s(:call,
             s(:iter, 
               s(:fcall, :lambda), 
               s(:dasgn_curr, mono_parameter), 

data/lib/rewrite/version.rb

@@ -1,7 +1,7 @@
 module Rewrite #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 1
+    MINOR = 2
     TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')

data/lib/rewrite.rb

@@ -8,21 +8,76 @@ Dir["#{File.dirname(__FILE__)}/rewrite/*.rb"].each do |element|
    require element
 end
 
-#--
+# Rewrite is the namespace for everything provided by the rewrite gem (http://rewrite.rubyforge.org).
 #
-# TODO: Hygienic Inline Methods
+# Rewrite is a framework for rewriting Ruby code before it is interpreted. This is useful for creating
+# abstractions that require non-eager evaluation, optimizing certain kinds of code, and creating even
+# more expressive domain-specific languages.
 #
+# In its basic form, use Rewrite like this:
+#
+#   Rewrite.with(rewriter1, rewriter2, rewriter3) do
+#     class MyClass
+#       # ...
+#     end
+#   end
+#
+# Rewrite will take all the code between the do and end keywords and rewrite it using
+# the declared rewriters (rewriter1, rewriter2, and rewriter3).
+#
+# One of the benefits of this approach is that the effect of the rewriters is limited
+# to the blocks of code you choose to rewrite. For example, the andand gem
+# (http://andand.rubyforge.org) uses "Classical Metaprogramming:" it modifies the Object
+# and NilClass classes to do its thing, which means that if you require andand anywhere
+# in your project, you have andand everywhere in your project and (if you are writing a
+# gem or rails plug in) your downstream clients all have andand as well.
+#
+# Whereas Rewrite provides its own version of andand, Rewrite::Prelude::Andand. There are
+# some important difference that have to do with eager evaluation vs. call by name, but
+# especially interesting is that when you write:
+#
+#   class MyClass
+#     include Rewrite
+#     include Rewrite::Prelude
+#     with (andand) do
+#       # ...
+#       foo.andand.bar(42)
+#       # ...
+#     end
+#   end
+#
+# You are not modifying any core classes to make foo.andand.bar(42) work.
+#
+# See Rewrite::Prelude for a complete list of rewriters built into the Rewrite gem for your use.
 module Rewrite
   
   module ClassMethods
+      
+    # Provide a symbol that is extremely unlikely to be used elsewhere.
+    # 
+    # Rewriters use this when they need to name something. For example,
+    # Andand converts code like this:
+    #
+    #   numbers.andand.inject(&:+)
+    #
+    # Into:
+    #
+    #  lambda { |__1234567890__|
+    #    if __1234567890__.nil?
+    #      nil
+    #    else
+    #      __1234567890__.inject(&:+)
+    #    end
+    #  }.call(numbers)
+    #
+    # It uses Rewrite.gensym to generate __1234567890__.
+    #
+    def gensym
+      :"__#{Time.now.to_i}#{rand(100000)}__"
+    end
   
-    #--
-    # I really want to express this somehow as pattern {
-    #   lambda { _ }
-    # }
-    # and have it extract _ automatically, and somehow also 
-    # use the exact same pattern to compose a sexp, much as
-    # I used to have binary pattern expressions
+    # Convert an expression to a sexp by taking a block and stripping\
+    # the outer prc from it.
     def sexp_for &proc
       sexp = proc.to_sexp
       return if sexp.length != 3
@@ -31,34 +86,23 @@ module Rewrite
       sexp[2]
     end
     
+    # Convert an expression to a sexp and then the sexp to an array.
+    # Useful for tests where you want to compare results.
     def arr_for &proc
       sexp_for(&proc).to_a
     end
     
+    # Convert an object of some type to a sexp, very useful when you have a sexp
+    # expressed as a tree of arrays.
+    def recursive_s(node)
+      if node.is_a? Array
+        s(*(node.map { |subnode| recursive_s(subnode) }))
+      else
+        node
+      end
+    end
+    
   end
   extend ClassMethods
-      
-  # Provide a symbol that is extremely unlikely to be used elsewhere.
-  # 
-  # Rewriters use this when they need to name something. For example,
-  # Andand converts code like this:
-  #
-  #   numbers.andand.inject(&:+)
-  #
-  # Into:
-  #
-  #  lambda { |__1234567890__|
-  #    if __1234567890__.nil?
-  #      nil
-  #    else
-  #      __1234567890__.inject(&:+)
-  #    end
-  #  }.call(numbers)
-  #
-  # It uses Rewrite.gensym to generate __1234567890__.
-  #
-  def self.gensym
-    :"__#{Time.now.to_i}#{rand(100000)}__"
-  end
   
 end

data/test/test_by_example.rb

@@ -0,0 +1,293 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+require 'sexp'
+
+include Rewrite::With
+
+module Rewrite
+  
+  module ByExample
+
+    class TestByExample < Test::Unit::TestCase
+      
+      def sexp &proc
+        proc.to_sexp[2]
+      end
+  
+      def test_simple_entity_matcher
+        foo_andand_bar = SexpEntity.new( :call,
+          s(:call,
+            s(:vcall, :foo),
+            :andand
+          ),
+          :bar
+        )
+        assert_not_nil(foo_andand_bar.unfold(
+          s(:call, s(:call, s(:vcall, :foo), :andand), :bar)
+        ))
+        assert_nil(foo_andand_bar.unfold(
+          s(:call, s(:call, s(:vcall, :bar), :andand), :foo)
+        ))
+      end
+          
+      def test_simple_bind
+        foo_andand_bar = SexpEntity.new( :call,
+          s(:call,
+            BindEntity.new(:receiver),
+            :andand
+          ),
+          BindEntity.new(:message)
+        )
+        assert_equal(
+          {
+            :receiver => s(:vcall, :foo),
+            :message => :bar
+          },
+          foo_andand_bar.unfold(
+            s(:call, s(:call, s(:vcall, :foo), :andand), :bar)
+          )
+        )
+      end
+      
+      def test_any
+        any = SexpEntity.new(
+          Any.new(:foo, :bar)
+        )
+        assert_not_nil(any.unfold(
+          s(:foo)
+        ))
+        assert_not_nil(any.unfold(
+          s(:bar)
+        ))
+        assert_nil(any.unfold(
+          s(:bash)
+        ))
+      end
+      
+      def test_bind_expression_by_example
+        something_andand_bar = SexpEntity.new(:bind => [/__to_(.*)$/]) { __to_something.andand.bar }
+        assert_equal(
+          { :something => [:vcall, :foo] },
+          something_andand_bar.unfold( sexp { foo.andand.bar } )
+        )
+      end
+      
+      def test_bind_consistency_by_example
+        something_plus_something = SexpEntity.new(:bind => [:__to_something]) {__to_something + __to_something }
+        assert_nil(
+          something_plus_something.unfold(sexp { foo + bar })
+        )
+        assert_nil(
+          something_plus_something.unfold(sexp { 1 + 2 })
+        )
+        assert_not_nil(
+          something_plus_something.unfold(sexp { foo + foo })
+        )
+        assert_not_nil(
+          something_plus_something.unfold(sexp { 2 + 2 })
+        )
+      end
+      
+      def test_bind_method_name
+        foo_andand_something = SexpEntity.new(:bind => [/__to_(.*)$/]) { foo.andand.__to_something }
+        assert_equal(
+          { :something => :bar },
+          foo_andand_something.unfold( sexp { foo.andand.bar } )
+        )
+      end
+      
+      def test_bind_one_parameter
+        foo_andand_bar_something = SexpEntity.new(:bind => [/__to_(.*)$/]) { foo.andand.bar(__to_something) }
+        assert_equal(
+          { :something => [:lit, :bash] },
+          foo_andand_bar_something.unfold( sexp { foo.andand.bar(:bash) } )
+        )
+      end
+      
+      def test_bind_sequence
+        unfolder = SexpEntity.new(:array, BindSequence.new(:something))
+        assert_equal(
+          { :something => [[:lit, :bash], [:lit, :blitz]] },
+          unfolder.unfold(
+            s(:array, s(:lit, :bash), s(:lit, :blitz))
+          )
+        )
+      end
+      
+      def test_bind_parameter_list
+        foo_andand_bar_somethings = SexpEntity.new(:bind => [[/__splat_(.*)$/]]) { foo.andand.bar(__splat_something) }
+        assert_equal(
+          { :something => [[:lit, :bash], [:lit, :blitz]] },
+          foo_andand_bar_somethings.unfold( sexp { foo.andand.bar(:bash, :blitz) } )
+        )
+      end
+      
+      def test_refolding_entities
+        foo_andand_bar_something = SexpEntity.new(:bind => [/__to_(.*)$/]) { foo.andand.bar(__to_something) }
+        assert_equal(
+          sexp { foo.andand.bar(:bash) },
+          foo_andand_bar_something.fold( { :something => [:lit, :bash] } )
+        )
+      end
+      
+      def test_refolding_sequences
+        foo_andand_bar_somethings = SexpEntity.new(:bind => [[/__splat_(.*)$/]]) { foo.andand.bar(__splat_something) }
+        assert_equal(
+          sexp { foo.andand.bar(:bash, :blitz) },
+          foo_andand_bar_somethings.fold( { :something => [[:lit, :bash], [:lit, :blitz]] } )
+        )
+      end
+      
+      def test_simple_andand_refold
+        folder = SexpEntity.new(:bind => [/^__to_(.*)$/]) {
+          lambda { |__G12345__|
+            __G12345__ && __G12345__.__to_message
+          }.call(__to_receiver)
+        }
+        assert_equal(
+          sexp {
+            lambda { |__G12345__|
+              __G12345__ && __G12345__.age
+            }.call(Person.find_by_name('Otto'))
+          },
+          folder.fold( :receiver => sexp { Person.find_by_name('Otto') }, :message => :age )
+        )
+      end
+      
+      def test_simple_andand_hylomorphism
+        unfolder = SexpEntity.new(:bind => [/^__to_(.*)$/]) {
+          __to_receiver.andand.__to_message
+        }
+        folder = SexpEntity.new(:bind => [/^__to_(.*)$/]) {
+          lambda { |__G12345__|
+            __G12345__ && __G12345__.__to_message
+          }.call(__to_receiver)
+        }
+        assert_equal(
+          sexp {
+            lambda { |__G12345__|
+              __G12345__ && __G12345__.age
+            }.call(Person.find_by_name('Otto'))
+          },
+          folder.fold(
+            unfolder.unfold(
+              sexp { Person.find_by_name('Otto').andand.age }
+            )
+          )
+        )
+      end
+      
+      def test_andand_hylomorphism_with_a_parameter
+        unfolder = SexpEntity.new(:bind => [/^__to_(.*)$/]) {
+          __to_receiver.andand.__to_message(__to_parameter)
+        }
+        folder = SexpEntity.new(:bind => [/^__to_(.*)$/]) {
+          lambda { |__G12345__|
+            __G12345__ && __G12345__.__to_message(__to_parameter)
+          }.call(__to_receiver)
+        }
+        assert_equal(
+          sexp {
+            lambda { |__G12345__|
+              __G12345__ && __G12345__.age(true)
+            }.call(Person.find_by_name('Otto'))
+          },
+          folder.fold(
+            unfolder.unfold(
+              sexp { Person.find_by_name('Otto').andand.age(true) }
+            )
+          )
+        )
+      end
+      
+      def test_alternate_folder
+        folder = SexpEntity.new(:bind => [/^__to_(.*)$/]) {
+          lambda { |__G12345__|
+            __G12345__.__to_message unless __G12345__.nil?
+          }.call(__to_receiver)
+        }
+        assert_not_nil(
+          folder.fold(
+            :receiver => s(:vcall, :foo),
+            :message => :bar
+          )
+        )
+      end
+      
+      def test_andand_hylomorphism_with_a_parameter_list
+        unfolder = SexpEntity.new(:bind => [/^__to_(.*)$/, [/^__splat_(.*)$/]]) {
+          __to_receiver.andand.__to_message(__splat_parameters)
+        }
+        folder = SexpEntity.new(:bind => [/^__to_(.*)$/, [/^__splat_(.*)$/]]) {
+          lambda { |__G12345__|
+            __G12345__ && __G12345__.__to_message(__splat_parameters)
+          }.call(__to_receiver)
+        }
+        assert_equal(
+          sexp {
+            lambda { |__G12345__|
+              __G12345__ && __G12345__.find(1,2,3)
+            }.call(Person)
+          },
+          folder.fold(
+            unfolder.unfold(
+              sexp { Person.andand.find(1,2,3) }
+            )
+          )
+        )
+      end
+      
+      def test_alternate_andand_hylomorphism_with_a_parameter_list
+        unfolder = SexpEntity.new(:bind => [:receiver, :message, [:params]]) {
+          receiver.andand.message(params)
+        }
+        folder = SexpEntity.new(:bind => [:receiver, :message, [:params]]) {
+          lambda { |__G12345__|
+            __G12345__.message(params) unless __G12345__.nil?
+          }.call(receiver)
+        }
+        assert_equal(
+          sexp {
+            lambda { |__G12345__|
+              __G12345__.find(1,2,3) unless __G12345__.nil?
+            }.call(Person)
+          },
+          folder.fold(
+            unfolder.unfold(
+              sexp { Person.andand.find(1,2,3) }
+            )
+          )
+        )
+      end
+      
+      # TODO: * Processor class with a nice syntax ('literate'?)
+      # TODO: * Hygienic, implemented as dogfood. How the freak would that work?
+      
+      def test_unhygienic_andand
+        andand = Unhygienic.
+        from(:receiver, :message, [:parameters]) {
+          receiver.andand.message(parameters)
+        }.
+        to {
+          lambda { |andand_temp|
+            andand_temp.message(parameters) if andand_temp
+          }.call(receiver)
+        }
+        assert_equal(
+          'Hello' + ' World', 
+          with(andand) do
+              'Hello'.andand + ' World'
+          end
+        )
+        assert_nil(
+          with(andand) do
+              nil.andand + ' World'
+          end
+        )
+      end
+  
+    end
+
+  end
+
+end

data/test/test_call_by_name.rb

@@ -70,7 +70,7 @@ class TestCalledByName < Test::Unit::TestCase
     Rewrite.with(
       called_by_name(:foo) { |change_it, get_it| 
         assert_equal(0, get_it)
-        change_it
+        change_it # note the interpreter warning here: it thinks we are doing a useless variable reference
         assert_equal(100, get_it)
       }
     ) do

data/website/index.html

@@ -33,7 +33,7 @@
     <h1>rewrite</h1>
     <div id="version" class="clickable" onclick='document.location = "http://rubyforge.org/projects/rewrite"; return false'>
       <p>Get Version</p>
-      <a href="http://rubyforge.org/projects/rewrite" class="numbers">0.1.0</a>
+      <a href="http://rubyforge.org/projects/rewrite" class="numbers">0.2.0</a>
     </div>
     <h1>&#x2192; &#8216;rewrite&#8217;</h1>
 
@@ -104,12 +104,48 @@
 	<p>Rewrite restricts things like andand or try to your code and your code alone. Sure, if you introduce a bug in your code, you may break things that directly depend on your code. But if you introduce “try” using rewrite instead of modifying Object, you will not reach out across your project and break something entirely unrelated that happens to have defined its own version of try in a completely different way.</p>
 
 
-	<h2>New! called_by_name</h2>
+	<h2>called_by_name</h2>
 
 
 	<p>See <a href="http://weblog.raganwald.com/2008/06/macros-hygiene-and-call-by-name-in-ruby.html">Macros, Hygiene, and Call By Name in Ruby</a> for details, more docs to come presently&#8230;</p>
 
 
+	<h2>Unhygienic rewriting</h2>
+
+
+	<p>A new feature every much like a new human being: Vulnerable, disruptive, and a complete mess:</p>
+
+
+	<p><pre class='syntax'>
+<span class="ident">include</span> <span class="constant">Rewrite</span><span class="punct">::</span><span class="constant">With</span>
+
+<span class="ident">andand</span> <span class="punct">=</span> <span class="constant">Rewrite</span><span class="punct">::</span><span class="constant">ByExample</span><span class="punct">::</span><span class="constant">Unhygienic</span><span class="punct">.</span>
+  <span class="ident">from</span><span class="punct">(</span><span class="symbol">:receiver</span><span class="punct">,</span> <span class="symbol">:message</span><span class="punct">,</span> <span class="punct">[</span><span class="symbol">:parameters</span><span class="punct">])</span> <span class="punct">{</span>
+    <span class="ident">receiver</span><span class="punct">.</span><span class="ident">andand</span><span class="punct">.</span><span class="ident">message</span><span class="punct">(</span><span class="ident">parameters</span><span class="punct">)</span>
+  <span class="punct">}.</span><span class="ident">to</span> <span class="punct">{</span>
+    <span class="ident">lambda</span> <span class="punct">{</span> <span class="punct">|</span><span class="ident">andand_temp</span><span class="punct">|</span>
+      <span class="ident">andand_temp</span><span class="punct">.</span><span class="ident">message</span><span class="punct">(</span><span class="ident">parameters</span><span class="punct">)</span> <span class="keyword">if</span> <span class="ident">andand_temp</span>
+    <span class="punct">}.</span><span class="ident">call</span><span class="punct">(</span><span class="ident">receiver</span><span class="punct">)</span>
+  <span class="punct">}</span>
+
+<span class="ident">with</span> <span class="punct">(</span><span class="ident">andand</span><span class="punct">)</span> <span class="keyword">do</span>
+	<span class="comment"># ...</span>
+	<span class="ident">foo</span><span class="punct">.</span><span class="ident">andand</span><span class="punct">.</span><span class="ident">bar</span><span class="punct">(</span><span class="symbol">:bash</span><span class="punct">,</span> <span class="ident">blitz</span><span class="punct">(</span><span class="number">5</span><span class="punct">))</span>
+	<span class="comment"># ...</span>
+<span class="keyword">end</span>
+</pre></p>
+
+
+	<p>becomes:</p>
+
+
+	<p><pre class='syntax'>
+<span class="ident">lambda</span> <span class="punct">{</span> <span class="punct">|</span><span class="ident">andand_temp</span><span class="punct">|</span>
+  <span class="ident">andand_temp</span><span class="punct">.</span><span class="ident">bar</span><span class="punct">(</span><span class="symbol">:bash</span><span class="punct">,</span> <span class="ident">blitz</span><span class="punct">(</span><span class="number">5</span><span class="punct">))</span> <span class="keyword">if</span> <span class="ident">andand_temp</span>
+<span class="punct">}.</span><span class="ident">call</span><span class="punct">(</span><span class="ident">foo</span><span class="punct">)</span>
+</pre></p>
+
+
 	<h2>How does it work?</h2>
 
 
@@ -232,7 +268,7 @@ rake install_gem</pre>
 
 	<p>Comments are welcome. Send an email to <a href="mailto:raganwald+rewrite@gmail.com">Reg Braithwaite</a> email via the <a href="http://groups.google.com/group/rewrite">forum</a></p>
     <p class="coda">
-      <a href="http://weblog.raganwald.com/">Reginald Braithwaite</a>, 23rd June 2008<br>
+      <a href="http://weblog.raganwald.com/">Reginald Braithwaite</a>, 11th July 2008<br>
       Theme extended from <a href="http://rb2js.rubyforge.org/">Paul Battley</a>
     </p>
 </div>

data/website/index.txt

@@ -55,10 +55,41 @@ Also, imagine if you introduce try and are careful not to break anything. Now so
 
 Rewrite restricts things like andand or try to your code and your code alone. Sure, if you introduce a bug in your code, you may break things that directly depend on your code. But if you introduce “try” using rewrite instead of modifying Object, you will not reach out across your project and break something entirely unrelated that happens to have defined its own version of try in a completely different way.
 
-h2. New! called_by_name
+h2. called_by_name
 
 See "Macros, Hygiene, and Call By Name in Ruby":http://weblog.raganwald.com/2008/06/macros-hygiene-and-call-by-name-in-ruby.html for details, more docs to come presently...
 
+h2. Unhygienic rewriting
+
+A new feature every much like a new human being: Vulnerable, disruptive, and a complete mess:
+
+<pre syntax="ruby">
+include Rewrite::With
+
+andand = Rewrite::ByExample::Unhygienic.
+  from(:receiver, :message, [:parameters]) {
+    receiver.andand.message(parameters)
+  }.to {
+    lambda { |andand_temp|
+      andand_temp.message(parameters) if andand_temp
+    }.call(receiver)
+  }
+
+with (andand) do
+	# ...
+	foo.andand.bar(:bash, blitz(5))
+	# ...
+end
+</pre>
+
+becomes:
+
+<pre syntax="ruby">
+lambda { |andand_temp|
+  andand_temp.bar(:bash, blitz(5)) if andand_temp
+}.call(foo)
+</pre>
+
 h2. How does it work?
 
 Rewrite takes your code, converts it to an sexp with Parse Tree, then rewrites the sexp using one or more rewriters you specify. Finally, it converts the sexp back to Ruby with Ruby2Ruby and evals it. It does this when the code is first read, not every time it is invoked, so we mitigate the “do not use andand in a tight loop” problem.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rewrite
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Reg Braithwaite
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-06-23 00:00:00 -04:00
+date: 2008-07-11 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -103,6 +103,7 @@ specification_version: 2
 summary: Syntactic metaprogramming for Ruby
 test_files: 
 - test/test_andand.rb
+- test/test_by_example.rb
 - test/test_call_by_name.rb
 - test/test_call_by_thunk.rb
 - test/test_call_splatted_by_name.rb