step_rewrite 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+vendor
+.idea/*
+.bundle
+*.gem
+pkg

data/Gemfile

@@ -0,0 +1,5 @@
+source :gemcutter
+source 'http://gems.github.com'
+
+# Specify your gem's dependencies in step_rewrite.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,47 @@
+PATH
+  remote: .
+  specs:
+    step_rewrite (0.0.1)
+      ParseTree (~> 3.0.6)
+      ruby2ruby (~> 1.2.5)
+      sexp_processor (~> 3.0.5)
+
+GEM
+  remote: http://rubygems.org/
+  remote: http://gems.github.com/
+  remote: http://gems.rubyforge.org/
+  specs:
+    ParseTree (3.0.6)
+      RubyInline (>= 3.7.0)
+      sexp_processor (>= 3.0.0)
+    RubyInline (3.8.6)
+      ZenTest (~> 4.3)
+    ZenTest (4.4.0)
+    diff-lcs (1.1.2)
+    rspec (2.0.0)
+      rspec-core (= 2.0.0)
+      rspec-expectations (= 2.0.0)
+      rspec-mocks (= 2.0.0)
+    rspec-core (2.0.0)
+    rspec-expectations (2.0.0)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.0)
+      rspec-core (= 2.0.0)
+      rspec-expectations (= 2.0.0)
+    ruby2ruby (1.2.5)
+      ruby_parser (~> 2.0)
+      sexp_processor (~> 3.0)
+    ruby_parser (2.0.5)
+      sexp_processor (~> 3.0)
+    sexp_processor (3.0.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  ParseTree (~> 3.0.6)
+  bundler (>= 1.0.0.rc.6)
+  rspec (~> 2.0.0.beta.22)
+  ruby2ruby (~> 1.2.5)
+  sexp_processor (~> 3.0.5)
+  step_rewrite!

data/README.textile

@@ -0,0 +1,24 @@
+h2. LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 FIX
+
+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,9 @@
+require 'bundler'
+require 'rspec'
+require 'rspec/core/rake_task'
+Bundler::GemHelper.install_tasks
+
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = %w(-fs --color)
+end
+

data/console

@@ -0,0 +1,30 @@
+#!/usr/bin/ruby
+
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+require 'optparse'
+
+options = { :sandbox => false, :irb => irb }
+OptionParser.new do |opt|
+  opt.banner = "Usage: console [environment] [options]"
+  opt.on('-s', '--sandbox', 'Rollback database modifications on exit.') { |v| options[:sandbox] = v }
+  opt.on("--irb=[#{irb}]", 'Invoke a different irb.') { |v| options[:irb] = v }
+  opt.on("--debugger", 'Enable ruby-debuggirng for the console.') { |v| options[:debugger] = v }
+  opt.parse!(ARGV)
+end
+
+libs = %( -r "#{File.dirname(__FILE__)}/lib/step_rewrite")
+
+
+if options[:debugger]
+  begin
+    require 'ruby-debug'
+    libs << " -r ruby-debug"
+    puts "=> Debugger enabled"
+  rescue Exception
+    puts "You need to install ruby-debug to run the console in debugging mode. With gems, use 'gem install ruby-debug'"
+    exit
+  end
+end
+
+exec "ruby -S #{options[:irb]} #{libs} --simple-prompt"

data/lib/step_rewrite.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'parse_tree'
+require 'parse_tree_extensions'
+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"

data/lib/step_rewrite/rewriter.rb

@@ -0,0 +1,61 @@
+module StepRewrite
+  class Rewriter < SexpProcessor
+    include SexpUtilities
+
+    def initialize(cb)
+      super()
+      self.strict = false
+      self.require_empty =  false
+      @cb = cb
+    end
+
+    def process_block(exp)
+      exp.shift
+      result = exp.reverse.inject([], &method(:accumulate))
+      exp.clear
+      result.size > 1 ? s(:block, *result) : result.first
+    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))
+      end
+    end
+
+    def special_call?(exp)
+      exp.first == :call &&
+              exp[3].last.class == Sexp &&
+              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/sexp_utilities.rb

@@ -0,0 +1,20 @@
+$:.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

data/lib/step_rewrite/version.rb

@@ -0,0 +1,3 @@
+module StepRewrite
+  VERSION = "0.0.1"
+end

data/spec/convert_matcher.rb

@@ -0,0 +1,77 @@
+module RSpec
+  module Matchers
+    class Convert
+      def initialize(given_code)
+        @given_code = code(&given_code)
+      end
+
+      def matches?(event_proc)
+        @new_code = event_proc.call(@given_code.deep_clone)
+        @expected_code ? @new_code == @expected_code : @new_code != @given_code
+      end
+
+      def to(&expected_code)
+        @expected_code = code(&expected_code)
+        self
+      end
+
+      def description
+        convert_to = "INTO \n#{expected_code_in_ruby}\n" if @expected_code
+        "Convert \n#{given_code_in_ruby}#{convert_to}\n"
+      end
+
+      [:expected, :given, :new].map{|t| "#{t}_code"}.each do |type|
+        define_method "#{type}_in_ruby" do
+          code = instance_variable_get("@#{type}")
+          Ruby2Ruby.new.process(code.deep_clone) rescue code
+        end
+      end
+
+      def code(&block)
+        Sexp.from_array(block.to_sexp)[3]
+      end
+
+      def failure_message_for_should
+<<-END
+given code was converted to
+#{new_code_in_ruby}
+aka
+expected
+#{@expected_code}
+got
+#{@new_code}
+END
+      rescue
+<<-END
+Expected
+#{@expected_code}
+got
+#{@new_code}
+END
+      end
+
+      def failure_message_for_should_not
+<<-END
+given code was converted to
+#{new_code_in_ruby}
+aka
+expected
+#{@given_code}
+got
+#{@new_code}
+END
+      rescue
+<<-END
+Expected
+#{@given_code}
+got
+#{@new_code}
+END
+      end
+  end
+
+    def convert(&given_code)
+      Matchers::Convert.new(given_code)
+    end
+  end
+end

data/spec/step_rewrite_spec.rb

@@ -0,0 +1,191 @@
+require File.expand_path('../../lib/step_rewrite', __FILE__)
+require File.expand_path('../convert_matcher', __FILE__)
+
+describe StepRewrite::Rewriter do
+  describe "#process" do
+    context 'when it sees the special callback symbol &cb' do
+      subject { lambda { |sexp| StepRewrite::Rewriter.new(:cb).process(sexp) } }
+
+      it do
+        should convert {
+          foo(&cb)
+          bar
+        }.to {
+          foo { bar }
+        }
+      end
+    end
+
+    context "when the special callback symbol is _ " do
+
+      subject { lambda { |sexp| StepRewrite::Rewriter.new(:_).process(sexp) } }
+
+      it do
+        should_not convert {
+          a = foo(1)
+          bar(a)
+        }
+      end
+
+      it do
+        should convert {
+          foo(&_)
+          bar
+        }.to {
+          foo { bar }
+        }
+      end
+
+      it do
+        should convert {
+          foo(&_)
+          bar
+          baz
+        }.to {
+          foo do
+            bar
+            baz
+          end
+        }
+      end
+
+      it do
+        should convert {
+          a = foo
+          bar
+          baz(a, &_)
+        }.to {
+          a = foo
+          bar
+          baz(a) {}
+        }
+      end
+
+      it do
+        should convert {
+          a = foo
+          bar(&_)
+          j = baz(a)
+          quux(j)
+        }.to {
+          a = foo
+          bar do
+            j = baz(a)
+            quux(j)
+          end
+        }
+      end
+
+      it do
+        should convert {
+          a = foo
+          bar(&_)
+          baz(a, &_)
+          quux
+        }.to {
+          a = foo
+          bar { baz(a) { quux } }
+        }
+      end
+
+      it do
+        should convert {
+          foo(a).bar(b, &_)
+          baz.qux(c, &_)
+          quux
+          corge(&_)
+          grault
+        }.to {
+          foo(a).bar(b) do
+            baz.qux(c) do
+              quux
+              corge { grault }
+            end
+          end
+        }
+      end
+
+      it do
+        should convert {
+          begin
+            foo(&_)
+            bar
+          end until baz
+        }.to {
+          begin
+            foo { bar }
+          end until baz
+        }
+      end
+
+      it do
+        should convert {
+          a = foo(&_)
+          bar(a)
+        }.to {
+          foo { |a| bar(a) }
+        }
+      end
+
+      it do
+        should convert {
+          a = 1
+          begin
+            a = foo(&_)
+            bar(a)
+          end until baz
+        }.to {
+          a = 1
+          begin
+            foo { |a| bar(a) }
+          end until baz
+        }
+      end
+
+      it do
+        should convert {
+          a, b, c = foo(&_)
+          bar(a, b)
+          }.to {
+          foo { |a, b, c| bar(a, b) }
+        }
+      end
+
+      it do
+        should convert {
+          *a = foo(&_)
+          bar(a)
+        }.to {
+          foo { |*a| bar(a) }
+        }
+      end
+
+      it do
+        should convert {
+          a, *b = foo(&_)
+          bar(b)
+        }.to {
+          foo { |a, *b| bar(b) }
+        }
+      end
+
+      it do
+        should convert {
+          a.b = foo(&_)
+          bar(a)
+        }.to {
+          foo { |a.b| bar(a) }
+        }
+      end
+
+      it do
+        should convert {
+          a.b.c = foo(&_)
+          bar(a.b)
+        }.to {
+          foo { |a.b.c| bar(a.b) }
+        }
+      end
+    end
+  end
+end

data/step_rewrite.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/step_rewrite/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "step_rewrite"
+  s.version     = StepRewrite::VERSION
+  s.platform    = Gem::Platform::RUBY
+  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.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "step_rewrite"
+
+  s.add_development_dependency "bundler", ">= 1.0.0.rc.6"
+  s.add_development_dependency "rspec", "~> 2.0.0.beta.22"
+  s.add_dependency "sexp_processor", "~> 3.0.5"
+  s.add_dependency 'ruby2ruby', "~> 1.2.5"
+  s.add_dependency 'ParseTree', "~> 3.0.6"
+
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+end

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification 
+name: step_rewrite
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Vishnu S Iyengar
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-16 00:00:00 +05:30
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15424057
+        segments: 
+        - 1
+        - 0
+        - 0
+        - rc
+        - 6
+        version: 1.0.0.rc.6
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 62196431
+        segments: 
+        - 2
+        - 0
+        - 0
+        - beta
+        - 22
+        version: 2.0.0.beta.22
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: sexp_processor
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 3
+        - 0
+        - 5
+        version: 3.0.5
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: ruby2ruby
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 1
+        - 2
+        - 5
+        version: 1.2.5
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: ParseTree
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 3
+        - 0
+        - 6
+        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
+email: pathsny@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .idea/encodings.xml
+- .idea/misc.xml
+- .idea/modules.xml
+- .idea/vcs.xml
+- Gemfile
+- Gemfile.lock
+- README.textile
+- Rakefile
+- console
+- lib/step_rewrite.rb
+- lib/step_rewrite/rewriter.rb
+- lib/step_rewrite/sexp_utilities.rb
+- lib/step_rewrite/version.rb
+- spec/convert_matcher.rb
+- spec/step_rewrite_spec.rb
+- step_rewrite.gemspec
+has_rdoc: true
+homepage: http://rubygems.org/gems/step_rewrite
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+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
+test_files: []
+