rewrite 0.2.0 → 0.3.0

data/lib/rewrite/by_example/union_of_entities_sequence.rb

@@ -0,0 +1,39 @@
+$:.unshift File.dirname(__FILE__)
+
+require File.expand_path(File.dirname(__FILE__) +'/sequence.rb')
+
+module Rewrite
+  
+  module ByExample
+    
+    #--
+    #
+    # Acts like a union of sequences but is initialized with entities. Could be better!
+    class UnionOfEntitiesSequence < Sequence
+      
+      attr_accessor :matchers, :length_range
+      
+      def initialize(*matchers)
+        self.matchers = matchers.map { |matcher| 
+          LengthOne.new(ObjectToMatcher.from_object(matcher))
+        }
+        @length_range = @matchers.inject(0..0) { |range, matcher| range_union(range, matcher.length_range) }
+      end
+      
+      def unfolders_by_length(length)
+        self.matchers.inject([]) { |unfolders, matcher| unfolders + matcher.unfolders_by_length(length) }
+      end
+      
+      def range_union(range1, range2)
+        ([range1.begin, range2.begin].min)..([range1.end, range2.end].max)
+      end
+      
+      def to_s
+        "(#{matchers.map { |m| m.to_s }.join(' | ')})"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/rewrite/version.rb

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

data/test/test_by_example.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/test_helper.rb'
+require File.dirname(__FILE__) +  '/test_helper.rb'
 
 require 'sexp'
 
@@ -15,13 +15,16 @@ module Rewrite
       end
   
       def test_simple_entity_matcher
-        foo_andand_bar = SexpEntity.new( :call,
-          s(:call,
-            s(:vcall, :foo),
-            :andand
-          ),
-          :bar
-        )
+        foo_andand_bar = nil
+        ObjectToMatcher.quietly do
+          foo_andand_bar = ObjectToMatcher.binding().from_object( s(:call,
+            s(:call,
+              s(:vcall, :foo),
+              :andand
+            ),
+            :bar)
+          )
+        end
         assert_not_nil(foo_andand_bar.unfold(
           s(:call, s(:call, s(:vcall, :foo), :andand), :bar)
         ))
@@ -31,12 +34,12 @@ module Rewrite
       end
           
       def test_simple_bind
-        foo_andand_bar = SexpEntity.new( :call,
+        foo_andand_bar = ObjectToMatcher.from_sexp( :call,
           s(:call,
-            BindEntity.new(:receiver),
+            Bind.new(:receiver, AnyEntity.new),
             :andand
           ),
-          BindEntity.new(:message)
+          Bind.new(:message, AnyEntity.new)
         )
         assert_equal(
           {
@@ -50,8 +53,8 @@ module Rewrite
       end
       
       def test_any
-        any = SexpEntity.new(
-          Any.new(:foo, :bar)
+        any = ObjectToMatcher.from_sexp(
+          UnionOfEntitiesSequence.new(:foo, :bar)
         )
         assert_not_nil(any.unfold(
           s(:foo)
@@ -65,7 +68,7 @@ module Rewrite
       end
       
       def test_bind_expression_by_example
-        something_andand_bar = SexpEntity.new(:bind => [/__to_(.*)$/]) { __to_something.andand.bar }
+        something_andand_bar = ObjectToMatcher.binding(/__to_(.*)$/).from_example { __to_something.andand.bar }
         assert_equal(
           { :something => [:vcall, :foo] },
           something_andand_bar.unfold( sexp { foo.andand.bar } )
@@ -73,7 +76,7 @@ module Rewrite
       end
       
       def test_bind_consistency_by_example
-        something_plus_something = SexpEntity.new(:bind => [:__to_something]) {__to_something + __to_something }
+        something_plus_something = ObjectToMatcher.binding(:__to_something).from_example {__to_something + __to_something }
         assert_nil(
           something_plus_something.unfold(sexp { foo + bar })
         )
@@ -89,7 +92,7 @@ module Rewrite
       end
       
       def test_bind_method_name
-        foo_andand_something = SexpEntity.new(:bind => [/__to_(.*)$/]) { foo.andand.__to_something }
+        foo_andand_something = ObjectToMatcher.binding(/__to_(.*)$/).from_example { foo.andand.__to_something }
         assert_equal(
           { :something => :bar },
           foo_andand_something.unfold( sexp { foo.andand.bar } )
@@ -97,7 +100,7 @@ module Rewrite
       end
       
       def test_bind_one_parameter
-        foo_andand_bar_something = SexpEntity.new(:bind => [/__to_(.*)$/]) { foo.andand.bar(__to_something) }
+        foo_andand_bar_something = ObjectToMatcher.binding(/__to_(.*)$/).from_example { foo.andand.bar(__to_something) }
         assert_equal(
           { :something => [:lit, :bash] },
           foo_andand_bar_something.unfold( sexp { foo.andand.bar(:bash) } )
@@ -105,7 +108,7 @@ module Rewrite
       end
       
       def test_bind_sequence
-        unfolder = SexpEntity.new(:array, BindSequence.new(:something))
+        unfolder = ObjectToMatcher.from_object(s(:array, BindSequence.new(:something)))
         assert_equal(
           { :something => [[:lit, :bash], [:lit, :blitz]] },
           unfolder.unfold(
@@ -115,7 +118,7 @@ module Rewrite
       end
       
       def test_bind_parameter_list
-        foo_andand_bar_somethings = SexpEntity.new(:bind => [[/__splat_(.*)$/]]) { foo.andand.bar(__splat_something) }
+        foo_andand_bar_somethings = ObjectToMatcher.binding([/__splat_(.*)$/]).from_example { foo.andand.bar(__splat_something) }
         assert_equal(
           { :something => [[:lit, :bash], [:lit, :blitz]] },
           foo_andand_bar_somethings.unfold( sexp { foo.andand.bar(:bash, :blitz) } )
@@ -123,7 +126,7 @@ module Rewrite
       end
       
       def test_refolding_entities
-        foo_andand_bar_something = SexpEntity.new(:bind => [/__to_(.*)$/]) { foo.andand.bar(__to_something) }
+        foo_andand_bar_something = ObjectToMatcher.binding(/__to_(.*)$/).from_example { foo.andand.bar(__to_something) }
         assert_equal(
           sexp { foo.andand.bar(:bash) },
           foo_andand_bar_something.fold( { :something => [:lit, :bash] } )
@@ -131,7 +134,7 @@ module Rewrite
       end
       
       def test_refolding_sequences
-        foo_andand_bar_somethings = SexpEntity.new(:bind => [[/__splat_(.*)$/]]) { foo.andand.bar(__splat_something) }
+        foo_andand_bar_somethings = ObjectToMatcher.binding([/__splat_(.*)$/]).from_example { foo.andand.bar(__splat_something) }
         assert_equal(
           sexp { foo.andand.bar(:bash, :blitz) },
           foo_andand_bar_somethings.fold( { :something => [[:lit, :bash], [:lit, :blitz]] } )
@@ -139,7 +142,7 @@ module Rewrite
       end
       
       def test_simple_andand_refold
-        folder = SexpEntity.new(:bind => [/^__to_(.*)$/]) {
+        folder = ObjectToMatcher.binding(/^__to_(.*)$/).from_example {
           lambda { |__G12345__|
             __G12345__ && __G12345__.__to_message
           }.call(__to_receiver)
@@ -155,10 +158,10 @@ module Rewrite
       end
       
       def test_simple_andand_hylomorphism
-        unfolder = SexpEntity.new(:bind => [/^__to_(.*)$/]) {
+        unfolder = ObjectToMatcher.binding(/^__to_(.*)$/).from_example {
           __to_receiver.andand.__to_message
         }
-        folder = SexpEntity.new(:bind => [/^__to_(.*)$/]) {
+        folder = ObjectToMatcher.binding(/^__to_(.*)$/).from_example {
           lambda { |__G12345__|
             __G12345__ && __G12345__.__to_message
           }.call(__to_receiver)
@@ -169,19 +172,20 @@ module Rewrite
               __G12345__ && __G12345__.age
             }.call(Person.find_by_name('Otto'))
           },
-          folder.fold(
-            unfolder.unfold(
+          begin
+            unfolded = unfolder.unfold(
               sexp { Person.find_by_name('Otto').andand.age }
             )
-          )
+            folder.fold(unfolded)
+          end
         )
       end
       
       def test_andand_hylomorphism_with_a_parameter
-        unfolder = SexpEntity.new(:bind => [/^__to_(.*)$/]) {
+        unfolder = ObjectToMatcher.binding(/^__to_(.*)$/).from_example {
           __to_receiver.andand.__to_message(__to_parameter)
         }
-        folder = SexpEntity.new(:bind => [/^__to_(.*)$/]) {
+        folder = ObjectToMatcher.binding(/^__to_(.*)$/).from_example {
           lambda { |__G12345__|
             __G12345__ && __G12345__.__to_message(__to_parameter)
           }.call(__to_receiver)
@@ -201,7 +205,7 @@ module Rewrite
       end
       
       def test_alternate_folder
-        folder = SexpEntity.new(:bind => [/^__to_(.*)$/]) {
+        folder = ObjectToMatcher.binding(/^__to_(.*)$/).from_example {
           lambda { |__G12345__|
             __G12345__.__to_message unless __G12345__.nil?
           }.call(__to_receiver)
@@ -215,10 +219,12 @@ module Rewrite
       end
       
       def test_andand_hylomorphism_with_a_parameter_list
-        unfolder = SexpEntity.new(:bind => [/^__to_(.*)$/, [/^__splat_(.*)$/]]) {
+        unfolder = ObjectToMatcher.binding(/^__to_(.*)$/, [/^__splat_(.*)$/]).from_example {
           __to_receiver.andand.__to_message(__splat_parameters)
         }
-        folder = SexpEntity.new(:bind => [/^__to_(.*)$/, [/^__splat_(.*)$/]]) {
+        subject = sexp { Person.andand.find(1,2,3) }
+        unfolded = unfolder.unfold(subject)
+        folder = ObjectToMatcher.binding(/^__to_(.*)$/, [/^__splat_(.*)$/]).from_example {
           lambda { |__G12345__|
             __G12345__ && __G12345__.__to_message(__splat_parameters)
           }.call(__to_receiver)
@@ -230,18 +236,16 @@ module Rewrite
             }.call(Person)
           },
           folder.fold(
-            unfolder.unfold(
-              sexp { Person.andand.find(1,2,3) }
-            )
+            unfolded
           )
         )
       end
       
       def test_alternate_andand_hylomorphism_with_a_parameter_list
-        unfolder = SexpEntity.new(:bind => [:receiver, :message, [:params]]) {
+        unfolder = ObjectToMatcher.binding(:receiver, :message, [:params]).from_example {
           receiver.andand.message(params)
         }
-        folder = SexpEntity.new(:bind => [:receiver, :message, [:params]]) {
+        folder = ObjectToMatcher.binding(:receiver, :message, [:params]).from_example {
           lambda { |__G12345__|
             __G12345__.message(params) unless __G12345__.nil?
           }.call(receiver)
@@ -285,6 +289,26 @@ module Rewrite
           end
         )
       end
+      
+      def test_literal_symbol
+        litsym = LiteralEntity.new
+        assert_not_nil(
+          litsym.unfold(s(:lit, :foo))
+        )
+        assert_not_nil(
+          litsym.unfold(sexp { :foo })
+        )
+        assert_nil(
+          litsym.unfold(sexp { 'bar' })
+        )
+        assert_nil(
+          litsym.unfold(sexp { 'bas'.to_sym })
+        )
+      end
+      
+      def test_symbol_to_proc
+        
+      end
   
     end
 

data/test/test_object_to_sequence_and_matcher.rb

@@ -0,0 +1,128 @@
+require File.dirname(__FILE__) +  '/test_helper.rb'
+
+require 'sexp'
+
+module Rewrite
+  
+  module ByExample
+
+    class TestObjectToPattern < Test::Unit::TestCase
+
+      include Rewrite::With
+      
+      def sexp &proc
+        proc.to_sexp[2]
+      end
+      
+      def test_object_matcher_proc_capturer_integrity
+        assert_nothing_raised(Exception) do
+          ObjectToMatcher.proc_capturer
+        end
+      end
+      
+      def test_symbol_like_expression_matcher_integrity
+        assert_equal(
+          "s( (<:gvar> | <:dvar> | <:vcall> | <:lcall> | <:lit>), <__ => :variable_symbol> )",
+          ObjectToMatcher.symbol_like_expression_matcher.to_s
+        )
+      end
+      
+      def test_object_to_pattern
+        assert_equal(/^(foo)$/, ObjectToMatcher.object_to_pattern(:foo))
+        assert_equal(/^(foo)$/, ObjectToMatcher.object_to_pattern('foo'))
+      end
+      
+      def test_internal_binder
+        o2m = ObjectToMatcher.binding(:foo)
+        result = nil
+        ObjectToMatcher.quietly do
+          result = o2m.from_object(
+            s(:vcall, :foo)
+          )
+        end
+        assert_equal("__ => :foo", result.to_s)
+      end
+      
+      def test_splatter
+        result = nil
+        ObjectToMatcher.quietly do
+          result = ObjectToMatcher.binding([:splat]).from_object(
+              s(
+                :array,
+                s(:vcall, :splat)
+              )
+            )
+        end
+        assert_equal("s( <:array>, __* => :splat )", result.to_s)
+      end
+      
+      def test_binder_at_top_level
+        assert_equal(
+          ObjectToMatcher.binding('foo', :bar).from_object(
+            s(:vcall, :foo)
+          ).to_s, 
+          ObjectToMatcher.binding('foo', :bar).from_example { foo }.to_s
+        )
+        assert_equal(
+          "__ => :foo", 
+          ObjectToMatcher.binding('foo', :bar).from_object(
+            s(:vcall, :foo)
+          ).to_s
+        )
+        assert_equal(
+          "__ => :foo", 
+          ObjectToMatcher.binding('foo', :bar).from_example { foo }.to_s
+        )
+        assert_equal(
+          "s( <:call>, <__ => :foo>, <__ => :bar> )",
+          ObjectToMatcher.binding('foo', :bar).from_example { foo.bar }.to_s
+        )
+      end
+      
+      def test_proc_extraction
+        entity = ObjectToMatcher.from_object([:proc, nil,  Bind.new(:sexp, AnyEntity.new)])
+        assert_equal("s( <:proc>, <nil>, <__ => :sexp> )", entity.to_s)
+      end
+      
+      def test_proc_to_sexp
+        entity = ObjectToMatcher.from_example { a }
+        assert_equal("s( <:vcall>, <:a> )", entity.to_s)
+      end
+      
+      def test_unfold_simplest
+        unfolder = ObjectToMatcher.binding('foo', :bar).from_example { foo }
+        assert_not_nil(unfolder.unfold(sexp { a }), "top-level expression is not a match")
+      end
+      
+      def test_method_call
+        unfolder = ObjectToMatcher.binding('foo', :bar).from_example { foo.bar }
+        assert_not_nil(unfolder.unfold(sexp { a.b }))
+      end
+      
+      def test_unfolding_and_refolding
+        unfolder = ObjectToMatcher.binding(/^__to_(.*)$/).from_example {
+          __to_receiver.andand.__to_message
+        }
+        subject = sexp { foo.andand.bar }
+        unfolded = unfolder.unfold(subject)
+        assert_equal(
+          {:message=>:bar, :receiver=>[:vcall, :foo]}, 
+          unfolded
+        )
+        refolder = ObjectToMatcher.binding(/^__to_(.*)$/).from_example {
+          lambda { |andand_helper|
+            andand_helper.__to_message if andand_helper
+          }.call(__to_receiver)
+        }
+        rewritten = eval(refolder.fold(unfolded).to_s)
+        assert_equal(
+          "lambda { |andand_helper| andand_helper.bar if andand_helper }.call(foo)", 
+          Ruby2Ruby.new.process(rewritten)
+        )
+      end
+      
+    end
+    
+  end
+  
+end

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.2.0</a>
+      <a href="http://rubyforge.org/projects/rewrite" class="numbers">0.3.0</a>
     </div>
     <h1>&#x2192; &#8216;rewrite&#8217;</h1>
 
@@ -140,9 +140,11 @@
 
 
 	<p><pre class='syntax'>
+<span class="comment"># ...</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">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>
+<span class="comment"># ...</span>
 </pre></p>
 
 
@@ -268,7 +270,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>, 11th July 2008<br>
+      <a href="http://weblog.raganwald.com/">Reginald Braithwaite</a>, 18th July 2008<br>
       Theme extended from <a href="http://rb2js.rubyforge.org/">Paul Battley</a>
     </p>
 </div>

data/website/index.txt

@@ -85,9 +85,11 @@ end
 becomes:
 
 <pre syntax="ruby">
+# ...
 lambda { |andand_temp|
   andand_temp.bar(:bash, blitz(5)) if andand_temp
 }.call(foo)
+# ...
 </pre>
 
 h2. How does it work?