rewrite 0.0.1

data/test/test_andand.rb

@@ -0,0 +1,120 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+include Rewrite::With
+include Rewrite::Prelude
+  
+  class Symbol
+    def to_proc
+      Proc.new { |*args| args.shift.__send__(self, *args) }
+    end
+  end
+
+class TestAndand < Test::Unit::TestCase
+  
+  def test_simple_andand
+    assert_equal(
+      'Hello' + ' World', 
+      with(andand) do
+          'Hello'.andand + ' World'
+      end
+    )
+    assert_nil(
+      with(andand) do
+          nil.andand + ' World'
+      end
+    )
+  end
+  
+  def test_with_parameters
+=begin
+  [:proc, 
+    nil, 
+    [:call, 
+      [:call, [:lit, 1], :andand], 
+      :+, 
+      [:array, [:lit, 2]]
+    ]
+  ]
+=end
+    assert_equal(
+      1.+(2),
+      with(andand) do
+        1.andand.+(2)
+      end
+    )
+    assert_nil(
+      with(andand) do
+        nil.andand.+(2)
+      end
+    )
+  end
+  
+  def test_with_a_block
+=begin
+  [:proc, 
+    nil,
+    [:iter, 
+      [:call, [:call, [:lit, 1..10], :andand], :inject], 
+      [:masgn, [:array, [:dasgn_curr, :x], [:dasgn_curr, :y]]], 
+      [:call, [:dvar, :x], :+, [:array, [:dvar, :y]]]
+    ]
+  ]
+=end
+    assert_equal(
+      (1..10).inject { |x, y| x + y },
+      with(andand) do
+        (1..10).andand.inject { |x, y| x + y }
+      end
+    )
+    assert_nil(
+      with(andand) do
+        nil.andand.inject { |x, y| x + y }
+      end
+    )
+  end
+  
+  def test_with_a_parameter_and_a_block
+    assert_equal(
+      (1..10).inject(42) { |x, y| x + y },
+      with(andand) do
+        (1..10).andand.inject(42) { |x, y| x + y }
+      end
+    )
+    assert_nil(
+      with(andand) do
+        nil.andand.inject(42) { |x, y| x + y }
+      end
+    )
+  end
+  
+  def test_with_a_block_pass
+    assert_equal(
+      (1..10).inject(42, &:+),
+      with(andand) do
+        (1..10).andand.inject(42, &:+)
+      end
+    )
+    assert_nil(
+      with(andand) do
+        nil.andand.inject(42, &:+)
+      end
+    )
+  end
+  
+  def test_nest
+    assert_equal(
+      (1..10).inject((1..5).inject(-5) { |x, y| x * y }) { |x, y| x + y },
+      with(andand) do
+        (1..10).andand.inject(
+          (1..5).andand.inject(-5) { |x, y| x * y }
+        ) { |x, y| x + y }
+      end
+    )
+    assert_nil(
+      with(andand) do
+        nil.andand.inject((1..5).andand.inject(-5) { |x, y| x * y }) { |x, y| x + y }
+      end
+    )
+  end
+  
+end

data/test/test_call_by_name.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestCalledByName < Test::Unit::TestCase
+
+  include Rewrite::Prelude
+  
+  def test_nullo_case
+    assert_equal(
+      Rewrite.arr_for do 
+         lambda { |foo| 
+           foo.call(lambda { :foo })
+         }.call(
+          lambda { |x| nil }
+         )
+      end, 
+      called_by_name(:foo) { |x| nil }.process(
+        Rewrite.sexp_for do
+          foo(:foo)
+        end
+      ).to_a
+    )
+  end
+  
+  def test_thunk_semantics
+    Rewrite.with(
+      called_by_name(:foo) { |change_it, get_it| 
+        assert_equal(0, get_it)
+        change_it
+        assert_equal(100, get_it)
+      }
+    ) do
+      x = 0
+      foo(x = 100, x)
+    end
+  end
+  
+end

data/test/test_call_by_thunk.rb

@@ -0,0 +1,106 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+module Rewrite
+
+  class TestCallByThunk < Test::Unit::TestCase
+    
+    def test_nothings
+      assert_equal(
+        Rewrite.arr_for do 
+           :baz
+        end, 
+        CallByThunk.new().process(
+          Rewrite.sexp_for do
+            :baz
+          end
+        ).to_a
+      )
+      assert_equal(
+        Rewrite.arr_for do 
+           :baz
+        end, 
+        CallByThunk.new(:foo).process(
+          Rewrite.sexp_for do
+            :baz
+          end
+        ).to_a
+      )
+      assert_equal(
+        Rewrite.arr_for do 
+           bar(:baz)
+        end, 
+        CallByThunk.new(:foo).process(
+          Rewrite.sexp_for do
+            bar(:baz)
+          end
+        ).to_a
+      )
+    end
+    
+    def test_convert_one_empty
+      assert_equal(
+        lambda { |foo|
+          Rewrite.arr_for do 
+             foo.call()
+          end
+        }.call(nil), 
+        CallByThunk.new(:foo).process(
+          Rewrite.sexp_for do
+            foo()
+          end
+        ).to_a
+      )
+    end
+    
+    def test_convert_one
+      assert_equal(
+        lambda { |foo| # make foo a dvar
+          Rewrite.arr_for do 
+             foo.call(lambda { :baz })
+          end
+        }.call(nil), 
+        CallByThunk.new(:foo).process(
+          Rewrite.sexp_for do
+            foo(:baz)
+          end
+        ).to_a
+      )
+    end
+    
+    def test_nested_invocation
+      assert_equal(
+        lambda { |fib|
+          Rewrite.arr_for do 
+             fib.call(lambda { fib.call(lambda { n-1 }) })
+          end
+        }.call(nil), 
+        CallByThunk.new(:fib).process(
+          Rewrite.sexp_for do
+            fib(fib(n-1))
+          end
+        ).to_a
+      )
+    end
+    
+    def test_nested_but_not_us
+      assert_equal(
+        lambda { |fib|
+          Rewrite.arr_for do 
+            foo(
+              fib.call(lambda { n-1 })
+            )
+          end
+        }.call(nil), 
+        CallByThunk.new(:fib).process(
+          Rewrite.sexp_for do
+            foo(
+              fib(n-1)
+            )
+          end
+        ).to_a
+      )
+    end
+    
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/rewrite'

data/test/test_rewriter_helpers.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestRewriteHelpers < Test::Unit::TestCase
+  
+  def test_simple_rewrite
+    
+    assert_equal(
+      lambda { |a| a.call }.to_sexp.to_a,
+      Rewrite::RewriteVariablesAsThunkCalls.new(:a).process(
+        lambda { |a| a }.to_sexp
+      ).to_a
+    )
+    
+    assert_equal(
+      lambda { |a, b| a.call + b }.to_sexp.to_a,
+      Rewrite::RewriteVariablesAsThunkCalls.new(:a).process(
+        lambda { |a,b| a + b }.to_sexp
+      ).to_a
+    )
+    
+  end
+  
+  def test_nested_rewrite
+    
+    assert_equal(
+      lambda { |a| lambda { |b| b } }.to_sexp.to_a,
+      Rewrite::VariableRewriter.new(:a, s(:dvar, :a)).process(
+        lambda { |a| lambda { |b| b } }.to_sexp
+      ).to_a
+    )
+    
+    assert_equal(
+      lambda { |a| lambda { |b| a.call } }.to_sexp.to_a,
+      Rewrite::RewriteVariablesAsThunkCalls.new(:a).process(
+        lambda { |a| lambda { |b| a } }.to_sexp
+      ).to_a
+    )
+    
+    assert_equal(
+      lambda { |a| lambda { |a| a } }.to_sexp.to_a,
+      Rewrite::RewriteVariablesAsThunkCalls.new(:a).process(
+        lambda { |a| lambda { |a| a } }.to_sexp
+      ).to_a
+    )
+    
+  end
+  
+  def test_multiple_rewites
+    
+    assert_equal(
+      lambda { |a,b| a.call || b.call }.to_sexp.to_a,
+      Rewrite::RewriteVariablesAsThunkCalls.new(:a,:b).process(
+        lambda { |a,b| a || b }.to_sexp
+      ).to_a
+    )
+    
+  end
+  
+end

data/test/test_syntax_let.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+module Rewrite
+
+  class TestDefVar < Test::Unit::TestCase
+    
+    def arr_for &proc
+      Rewrite.sexp_for(&proc).to_a
+    end
+    
+    def test_and_one
+      assert_equal(
+        arr_for { 
+          lambda { |foo| :baz }.call(:foo) 
+        }, 
+        DefVar.new(:foo, Rewrite.sexp_for { :foo }).process(
+          Rewrite.sexp_for { :baz }
+        ).to_a
+      )
+    end
+    
+    def test_one_and_one
+      assert_equal(
+        arr_for { 
+          lambda { |foo, bar| :baz }.call(:foo, :bar) 
+        }, 
+        DefVar.new(:bar, Rewrite.sexp_for { :bar }).process(
+          Rewrite.sexp_for { lambda { |foo| :baz }.call(:foo) }
+        ).to_a
+      )
+    end
+    
+    def test_two_and_one
+      assert_equal(
+        arr_for { 
+          lambda { |foo, bar, blitz| :baz }.call(:foo, :bar, :blitz) 
+        }, 
+        DefVar.new(:blitz, Rewrite.sexp_for { :blitz }).process(
+          Rewrite.sexp_for { lambda { |foo, bar| :baz }.call(:foo, :bar)  }
+        ).to_a
+      )
+    end
+
+  end
+
+  end

data/test/test_with.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+require 'rubygems'
+require 'parse_tree'
+require 'sexp_processor'
+
+class TestWith < Test::Unit::TestCase
+  
+  include Rewrite::With
+  
+  class NoopProcessor < SexpProcessor
+    
+  end
+  
+  def test_null_processor
+    assert_equal(
+      :foo, 
+      with(NoopProcessor.new) do
+          :foo
+      end
+    )
+  end
+  
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: rewrite
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Reg Braithwaite
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-17 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Syntactic metaprogramming for Ruby
+email: 
+- raganwald+rewrite@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: []
+
+has_rdoc: true
+homepage: http://rewrite.rubyforge.org
+post_install_message: |+
+  
+  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.
+  
+  
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: rewrite
+rubygems_version: 1.1.1
+signing_key: 
+specification_version: 2
+summary: Syntactic metaprogramming for Ruby
+test_files: 
+- 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