step_rewrite 0.1.0 → 0.2.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    step_rewrite (0.0.1)
+    step_rewrite (0.1.0)
       ParseTree (~> 3.0.6)
       ruby2ruby (~> 1.2.5)
       sexp_processor (~> 3.0.5)

data/{README.textile → LICENSE}

@@ -1,12 +1,8 @@
-h2. LICENSE:
-
-(The MIT License)
-
-Copyright (c) 2008 FIX
+Copyright (c) 2010 Vishnu Iyengar
 
 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
+"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
@@ -15,10 +11,10 @@ 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,
+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.
+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/README.rdoc

@@ -0,0 +1,143 @@
+= What is this for?
+
+This gem tries to solve a very specific problem when working with evented I/O code.
+Ideally, I suppose it would work with something like EventMachine[http://rubyeventmachine.com/], but I havent
+worked enough with EventMachine to know if that's the case. Its meant for cases
+where blocks are passed to methods solely to sequence a set of steps. Like in this example.
+
+    writeFile(path, "hello") do
+        File.open(path, "a") do |file|
+            write(file, "\nworld") do
+                close(file) do
+                    read(path) do |data|
+                        puts data.last
+                    end
+                end
+            end
+        end
+    end
+
+Traditionally blocks have been a lightweight strategy pattern. Not so with evented I/O.
+While each function takes a block, this is merely to sequence the rest of the program
+to execute after the function is executed.
+To understand the context a little better read this[http://blog.vishnuiyengar.com/2010/10/changing-rules.html]
+
+
+= Installation
+ gem install step_rewrite
+
+After installing the gem, the quick and dirty way to use it is to include the
+StepRewrite module in your code.
+
+    include StepRewrite
+    step do
+        path = "fileio.txt"
+        writeFile(path, "hello", &_)
+        file = File.open(path, "a", &_)
+        write(file, "\nworld", &_)
+        close(file, &_)
+        data = read(path, &_)
+        puts data.last
+    end
+
+The block passed to step is rewritten so that everywhere you have a method
+that takes &_ as a parameter, the rest of the code is passed as a block to it.
+So step rewrites this code into the code above and THEN evaluates it.
+
+= Rewrite Rules
+Any code of the form
+
+ foo(&_)
+ bar
+ baz
+
+gets rewritten to
+
+ foo do
+   bar
+   baz
+ end
+
+return values from such functions are converted into arguments to the block
+
+ a = foo(&_)
+ bar(a)
+ baz
+
+becomes
+
+ foo do |a|
+   bar(a)
+   baz
+ end
+
+This allows an infinite degree of nesting
+
+ foo(&_)
+ bar(&_)
+ baz(&_)
+ qux
+
+becomes
+ foo { bar { baz { qux } } }
+
+existing blocks or lambda parameters are not touched.
+
+= Other execution methods
+
+If the name step clashes with a method in your code, you can instead use the module method
+
+    StepRewrite.step do
+        path = "fileio.txt"
+        writeFile(path, "hello", &_)
+        file = File.open(path, "a", &_)
+        write(file, "\nworld", &_)
+        close(file, &_)
+        data = read(path, &_)
+        puts data.last
+    end
+
+if _ is a variable you are already using, you can configure the special callback identifier for
+rewriting.
+
+    StepRewrite.step(:cb) do
+        path = "fileio.txt"
+        writeFile(path, "hello", &cb)
+        file = File.open(path, "a", &cb)
+        write(file, "\nworld", &cb)
+        close(file, &cb)
+        data = read(path, &cb)
+        puts data.last
+    end
+
+= Define Method
+
+The problem with the above approach is that it does not cache the result of rewriting
+the code. If what you are writing is part of a long running server, the recommended
+style is to define a method instead.
+
+    require 'step_rewrite/module'
+
+    class IO
+        define_step_method :hello_world do
+            path = "fileio.txt"
+            writeFile(path, "hello", &_)
+            file = File.open(path, "a", &_)
+            write(file, "\nworld", &_)
+            close(file, &_)
+            data = read(path, &_)
+            puts data.last
+        end
+    end
+
+    IO.new.hello_world
+
+= How does this work?
+
+This gem makes use of the ParseTree[https://rubygems.org/gems/ParseTree] gem to
+extract the sexp out of any block and then rewrites it using various rules. This
+code is converted back into Ruby using Ruby2Ruby[https://rubygems.org/gems/ruby2ruby]
+and then evaled into a context
+== Copyright
+
+Copyright (c) 2010 Vishnu Iyengar. See LICENSE for details.

data/lib/step_rewrite.rb

@@ -6,6 +6,5 @@ require 'Ruby2Ruby'
 $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
-require "step_rewrite/sexp_utilities"
 require "step_rewrite/rewriter"
 require 'step_rewrite/step_rewrite'

data/lib/step_rewrite/rewriter.rb

@@ -1,7 +1,5 @@
 module StepRewrite
   class Rewriter < SexpProcessor
-    include SexpUtilities
-
     def initialize(cb)
       super()
       self.strict = false
@@ -11,34 +9,37 @@ module StepRewrite
 
     def process_block(exp)
       exp.shift
-      result = exp.reverse.inject([], &method(:accumulate))
+      result = exp.reverse.inject([]) {|acc, cur| accumulate(acc, process(cur))}
       exp.clear
-      result.size > 1 ? s(:block, *result) : result.first
+      group_expr(result)
+    end
+
+    def group_expr(acc)
+      acc.size > 1 ? s(:block, *acc) : acc.first
+    end
+
+    def remove_block(exp)
+      exp.tap{|e| e[3].pop}
     end
 
-    def accumulate(acc_exp, cur_exp)
-      case identify(cur_exp)
-        when :special_call then
-          cur_exp[3].pop
-          inner_exp = acc_exp.size > 1 ? s(:block, *acc_exp) : acc_exp.first
-          [s(*[:iter, cur_exp, nil] + [inner_exp].compact)]
-        when :special_asgn then
-          param = cur_exp[1]
-          cur_exp[2][3].pop
-          inner_exp = acc_exp.size > 1 ? s(:block, *acc_exp) : acc_exp.first
-          [s(*[:iter, cur_exp[2], s(:lasgn, param)] + [inner_exp].compact)]
-        when :masgn then
-          param = cur_exp[1][1..-1].to_a
-          cur_exp[2][1][3].pop
-          inner_exp = acc_exp.size > 1 ? s(:block, *acc_exp) : acc_exp.first
-          [s(*[:iter, cur_exp[2][1], s(:masgn, s(:array, *param))] + [inner_exp].compact)]
-        when :attrasgn then
-          next_exp = cur_exp.last.pop.tap{|x| x.last.pop}
-          param = cur_exp
-          inner_exp = acc_exp.size > 1 ? s(:block, *acc_exp) : acc_exp.first
-          [s(*[:iter, next_exp, param] + [inner_exp].compact)]
-        else
-          acc_exp.unshift(process_inner_expr(cur_exp))
+    def new_exp_containing(acc)
+      lambda do |call_exp, param|
+        [s(*[:iter, remove_block(call_exp), param] + [group_expr(acc)].compact)]
+      end
+    end
+
+    def accumulate(acc, cur)
+      new_exp = new_exp_containing(acc)
+      if special_call?(cur) then
+        new_exp.call(cur, nil)
+      elsif cur.first == :lasgn && special_call?(cur[2])
+        new_exp.call(cur[2], s(:lasgn, cur[1]))
+      elsif cur.first == :masgn && special_call?(cur[2][1])
+        new_exp.call(cur[2][1], s(:masgn, s(:array, *cur[1][1..-1].to_a)))
+      elsif cur.first == :attrasgn && special_call?(cur[3][1])
+        new_exp.call(cur[3][1], s(:attrasgn, *cur[1..-2] + [s(:arglist)]))
+      else
+        acc.unshift(cur)
       end
     end
 
@@ -48,12 +49,5 @@ module StepRewrite
               exp[3].last.first == :block_pass &&
               exp[3].last.last[2] == @cb
     end
-
-    def identify(exp)
-      return :special_call if special_call?(exp)
-      return :special_asgn if exp.first == :lasgn && special_call?(exp[2])
-      return :masgn if exp.first == :masgn && special_call?(exp[2][1])
-      return :attrasgn if exp.first == :attrasgn && special_call?(exp[3][1])
-    end
   end
 end

data/lib/step_rewrite/step_rewrite.rb

@@ -1,15 +1,15 @@
-require 'forwardable'
-
 module StepRewrite
-  include Forwardable
-
   def step(*args, &block)
     StepRewrite.step(*args, &block)
   end
 
+  def self.get_sexp(&block)
+    Sexp.from_array(block.to_sexp)
+  end
+
   def self.rewrite(callback_symbol = :_, &block)
-    old_sexp = Sexp.from_array(block.to_sexp)
-    new_sexp = StepRewrite::Rewriter.new(callback_symbol).process(old_sexp)
+    rewriter = StepRewrite::Rewriter.new(callback_symbol)
+    new_sexp = rewriter.process(get_sexp(&block))
     Ruby2Ruby.new.process(new_sexp)
   end
 

data/lib/step_rewrite/version.rb

@@ -1,3 +1,3 @@
 module StepRewrite
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/spec/lib/rewriter_spec.rb

@@ -199,6 +199,29 @@ describe StepRewrite::Rewriter do
           end
         }
       end
+
+      it do
+        should convert {
+          foo(&_)
+          begin
+            a = bar(&_)
+            baz do
+              b = qux(&_)
+              quux(a, b)
+            end
+          end
+        }.to {
+          foo do
+            begin
+              bar do |a|
+                baz do
+                  qux { |b| quux(a, b) }
+                end
+              end
+            end
+          end
+        }
+      end
     end
   end
 end

data/step_rewrite.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |s|
   s.authors     = ["Vishnu S Iyengar"]
   s.email       = %q{pathsny@gmail.com}
   s.homepage    = "http://rubygems.org/gems/step_rewrite"
-  s.summary     = %q{A Gem to Rewrite Ruby code from a special syntax into an evented IO form}
-  s.description = %q{A Gem to Rewrite Ruby code from a special syntax into an evented IO form}
+  s.summary     = %q{code rewriter for evented I/O}
+  s.description = %q{A Gem to Rewrite Ruby code from a special syntax into an evented IO form.}
 
   s.required_rubygems_version = ">= 1.3.6"
   s.rubyforge_project         = "step_rewrite"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: step_rewrite
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Vishnu S Iyengar
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-18 00:00:00 +05:30
+date: 2010-10-19 00:00:00 +05:30
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -102,7 +102,7 @@ dependencies:
         version: 3.0.6
   type: :runtime
   version_requirements: *id005
-description: A Gem to Rewrite Ruby code from a special syntax into an evented IO form
+description: A Gem to Rewrite Ruby code from a special syntax into an evented IO form.
 email: pathsny@gmail.com
 executables: []
 
@@ -112,19 +112,15 @@ extra_rdoc_files: []
 
 files: 
 - .gitignore
-- .idea/encodings.xml
-- .idea/misc.xml
-- .idea/modules.xml
-- .idea/vcs.xml
 - Gemfile
 - Gemfile.lock
-- README.textile
+- LICENSE
+- README.rdoc
 - Rakefile
 - console
 - lib/step_rewrite.rb
 - lib/step_rewrite/module.rb
 - lib/step_rewrite/rewriter.rb
-- lib/step_rewrite/sexp_utilities.rb
 - lib/step_rewrite/step_rewrite.rb
 - lib/step_rewrite/version.rb
 - spec/lib/module_spec.rb
@@ -168,6 +164,6 @@ rubyforge_project: step_rewrite
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: A Gem to Rewrite Ruby code from a special syntax into an evented IO form
+summary: code rewriter for evented I/O
 test_files: []
 

data/lib/step_rewrite/sexp_utilities.rb

@@ -1,20 +0,0 @@
-$:.unshift File.dirname(__FILE__)
-
-module SexpUtilities
-
-  def truthy?(sexp)
-    sexp.respond_to?(:[]) && (sexp[0] == :true || sexp[0] == :lit || sexp[0] == :str || sexp[0] == :array)
-  end
-
-  def falsy?(sexp)
-    sexp.respond_to?(:[]) && (sexp[0] == :nil || sexp[0] == :false)
-  end
-
-  def list?(sexp)
-    sexp.respond_to?(:[]) && sexp.respond_to?(:empty?) && sexp.respond_to?(:first)
-  end
-
-  def process_inner_expr(inner)
-    inner.kind_of?(Array) ? process(inner) : inner
-  end
-end