ruby_transform 0.1.1

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,40 @@
+PATH
+  remote: .
+  specs:
+    ruby_transform (0.1.1)
+      activesupport (~> 3.0.10)
+      i18n (~> 0.6.0)
+      ruby_parser (~> 2.3.1)
+      ruby_scribe (~> 0.1.0)
+      thor (~> 0.13)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.0.10)
+    diff-lcs (1.1.3)
+    i18n (0.6.0)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    ruby_parser (2.3.1)
+      sexp_processor (~> 3.0)
+    ruby_scribe (0.1.2)
+      activesupport (~> 3.0.10)
+      i18n (~> 0.6.0)
+      ruby_parser (~> 2.3.1)
+      thor (~> 0.13)
+    sexp_processor (3.0.7)
+    thor (0.14.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rspec (~> 2.0)
+  ruby_transform!

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Ben Hughes
+
+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/README.rdoc

@@ -0,0 +1,21 @@
+= Ruby Transform
+
+== Introduction
+
+Provides a series of s-expression transformations useful for automatic refactoring or morphing of Ruby/Rails/Sinatra code.
+
+== Example
+
+This is just one of many examples:
+
+= Block Method To Proc Transform
+Looks for cases where we're calling a single method on a single-parameter block argument.
+These instances can use the Ruby 1.9 and ActiveSupport "Symbol#to_proc" trick.
+
+Example:
+
+  collection.map {|d| d.name }
+
+Transforms To:
+  
+  collect.map(&:name)

data/Rakefile

@@ -0,0 +1,14 @@
+require "rubygems"
+require "rake"
+require "rake/rdoctask"
+
+desc "Generate documentation for the plugin."
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title    = "has_draft"
+  rdoc.options << "--line-numbers" << "--inline-source"
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Dir["#{File.dirname(__FILE__)}/lib/tasks/*.rake"].sort.each { |ext| load ext }

data/TODO.rdoc

@@ -0,0 +1,4 @@
+= TODO
+
+* Eventually going to need some similar concept of "checks" like exist in rails_best_practices.
+* What about transforms that work across files?  For example complex view snippets that can automatically be refactored to helpers.

data/bin/rubytransform

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require "ruby_transform/runner"
+
+RubyTransform::Runner.start

data/lib/ruby_transform/registry.rb

@@ -0,0 +1,38 @@
+module RubyTransform
+  class Registry < HashWithIndifferentAccess
+    def self.instance
+      @registry ||= new
+    end
+    
+    def self.[](name)
+      instance[name]
+    end
+    def self.[]=(name, value)
+      instance[name] = value
+    end
+    
+    def self.configure(&block)
+      instance.tap do |registry|
+        registry.instance_eval(&block) if block
+      end
+    end
+    
+    def register(name, transform = nil, &block)
+      if block
+        self[name.to_s] = RubyTransform::Transformers::Custom.new(&block)
+      elsif transform.is_a?(Array)
+        self[name.to_s] = RubyTransform::Transformers::Composite.new(transform.map {|t|
+          if t.is_a?(Symbol) or t.is_a?(String)
+            self[t] or raise ArgumentError, "#{t} is not a registered transform name."
+          else
+            t
+          end
+        })
+      elsif transform.is_a?(RubyTransform::Transformer)
+        self[name.to_s] = transform
+      else
+        raise ArgumentError, "Please provide a transform or custom block processor."
+      end
+    end
+  end
+end

data/lib/ruby_transform/runner.rb

@@ -0,0 +1,8 @@
+require "thor"
+require "ruby_transform"
+
+module RubyTransform
+  class Runner < Thor
+    
+  end
+end

data/lib/ruby_transform/transform_helpers.rb

@@ -0,0 +1,7 @@
+module RubyTransform
+  module TransformerHelpers
+    def sexp?(e)
+      e.is_a?(Sexp)
+    end
+  end
+end

data/lib/ruby_transform/transformer.rb

@@ -0,0 +1,18 @@
+module RubyTransform
+  
+  # Takes a raw S-expression and transforms it (replaces the node with the return value of the process method).
+  # This is meant to be subclassed, and in the process method you should either return a transformed version of the node, 
+  # or just call super which will leave the node in place and iterate through the children.
+  # 
+  class Transformer
+    include TransformerHelpers
+    
+    def transform(sexp)
+      if sexp.is_a?(Sexp)
+        Sexp.new(*([sexp.kind] + sexp.body.map {|c| transform(c) }))
+      else
+        sexp
+      end
+    end
+  end
+end

data/lib/ruby_transform/transformers/block_method_to_procifier.rb

@@ -0,0 +1,47 @@
+module RubyTransform
+  module Transformers
+    
+    # = Block Method To Proc Transform
+    # Looks for cases where we're calling a single method on a single-parameter block argument.
+    # These instances can use the Ruby 1.9 and ActiveSupport "Symbol#to_proc" trick.
+    # 
+    # Example:
+    # 
+    #   collection.map {|d| d.name }
+    # 
+    # Transforms To:
+    #   
+    #   collect.map(&:name)
+    # 
+    class BlockMethodToProcifier < Transformer
+      def transform(e)
+        super transform_block_methods_to_proc(e)
+      end
+      
+      def transform_block_methods_to_proc(e)
+        if sexp?(e) && matches_block_to_use_tap?(e)
+          transform_block_to_use_tap(e)
+        else
+          e
+        end
+      end
+      
+      def matches_block_to_use_tap?(e)
+        e.kind == :iter &&  # Calls block
+        e.body[2] && e.body[2].kind == :call &&  # Body of block is a simple method call
+        e.body[2] && e.body[2].body[0] && e.body[2].body[0].kind == :lvar &&  # Simple method call is on a local variable
+        e.body[1] && e.body[1].kind == :lasgn &&  # Block parameter is a single assign
+        e.body[2] && e.body[2].body[0].body[0] == e.body[1].body[0]  # Local variable is identical to the first block argument
+      end
+      
+      def transform_block_to_use_tap(e)
+        s(:call, 
+          e.body[0].body[0], 
+          e.body[0].body[1], 
+          s(:arglist, s(:block_pass, s(:lit, e.body[2].body[1])))
+        )
+      end
+    end
+    
+  end
+end

data/lib/ruby_transform/transformers/clear_explicit_returns.rb

@@ -0,0 +1,49 @@
+module RubyTransform
+  module Transformers
+    
+    # = Clear Explicit Returns
+    # Looks for cases where the last expression in a method contains an explicit "return" statement, which is unnecessary
+    # in ruby, and removes it.
+    # 
+    # Example:
+    # 
+    #   def my_method
+    #     a = 1
+    #     call_something(a)
+    #     return a
+    #   end
+    # 
+    # Transforms To:
+    #   
+    #   def my_method
+    #     a = 1
+    #     call_something(a)
+    #     a
+    #   end
+    #
+    class ClearExplicitReturns < RubyTransform::Transformer
+      def transform(e)
+        super(transform_explicit_returns(e))
+      end
+      
+      def transform_explicit_returns(e)
+        if matches_explicit_return_method?(e)
+          transform_explicit_return_method(e)
+        else
+          e
+        end
+      end
+      
+      def matches_explicit_return_method?(e)
+        e.is_a?(Sexp) && e.method? && e.block && e.block.body.last && e.block.body.last.kind == :return
+      end
+      
+      def transform_explicit_return_method(e)
+        e.clone.tap do |exp|
+          exp.block[-1] = exp.block[-1].body[0]
+        end
+      end
+    end
+    
+  end
+end

data/lib/ruby_transform/transformers/composite.rb

@@ -0,0 +1,28 @@
+module RubyTransform
+  module Transformers
+    
+    # = Composite Transformer
+    # Combines transformations by chaining them.
+    # 
+    # Example:
+    # 
+    #   RubyTransform::Transformers::Composite.new([
+    #     RubyTransform::Transformers::Eachifier.new,
+    #     RubyTransform::Transformers::BlockMethodToProcifier.new,
+    #     RubyTransform::Transformers::Tapifier.new
+    #   ])
+    # 
+    class Composite < RubyTransform::Transformer
+      def initialize(transformers = [])
+        class_eval do
+          define_method :transform do |e|
+            transformers.inject(e) do |transformed, transformer|
+              transformer.transform(transformed)
+            end
+          end
+        end
+      end
+    end
+    
+  end
+end

data/lib/ruby_transform/transformers/custom.rb

@@ -0,0 +1,27 @@
+module RubyTransform
+  module Transformers
+    
+    # = Custom Transformer
+    # Allows for implementation of the transform to happen in-line through a block passed to the initializer.
+    # 
+    # Example:
+    # 
+    #   # This contrived example reverses all string literals
+    #   RubyTransform::Transformers::Custom.new do |expression|
+    #     if sexp?(expression) && expression.kind == :str
+    #       s(:str, expression.body[0].reverse)
+    #     else
+    #       super
+    #     end
+    #   end
+    # 
+    class Custom < RubyTransform::Transformer
+      def initialize(&block)
+        class_eval do
+          define_method(:transform, &block)
+        end
+      end
+    end
+    
+  end
+end

data/lib/ruby_transform/transformers/eachifier.rb

@@ -0,0 +1,43 @@
+module RubyTransform
+  module Transformers
+    
+    # = For to Each Block Transform
+    # Finds instances using "for something in collection"-style of iteration and converts
+    # it to using a standard collection.each block.
+    #
+    # Example:
+    #   
+    #   for element in collection
+    #     do_something(element)
+    #   end
+    # 
+    # Converts To:
+    # 
+    #   collection.each do |element|
+    #     do_something(element)
+    #   end
+    # 
+    class Eachifier < Transformer
+      def transform(e)
+        super(transform_fors_to_eaches(e))
+      end
+      
+      def transform_fors_to_eaches(e)
+        if sexp?(e) && e.kind == :for
+          transform_for_to_each(e)
+        else
+          e
+        end
+      end
+      
+      def transform_for_to_each(e)
+        s(:iter, 
+          s(:call, e.body[0], :each, s(:arglist)), 
+          e.body[1],
+          e.body[2]
+        )
+      end
+    end
+    
+  end
+end

data/lib/ruby_transform/transformers/symbol_names.rb

@@ -0,0 +1,68 @@
+module RubyTransform
+  module Transformers
+    
+    # = Symbol Names
+    # Sometimes you'll come across code written by a Java developer who uses camel-cased names for variables and methods.
+    # This transformer will allow you to apply some transformation (defined through a block to initialize) to every symbol name
+    # in the application, which includes all of these:
+    # * Method Names (Definitions and Calls)
+    # * Local Variable Names
+    # * Instance Variable Names
+    # * Class Variable Names
+    # 
+    # Big Caveat: This transformer does not detect instances where the symbol name is referenced inside an eval-ed string, for example
+    # when you are instance_evaling some large string.  As always, run your tests after any transformation.
+    # 
+    # Example:
+    #   
+    #   # Underscores symbol names
+    #   RubyTransform::Transformers::SymbolNames.new {|name| name.underscore }
+    #   
+    #   # Given This:
+    #   def myMethod
+    #     myVariable = 1
+    #     @iVar = myMethod(myVariable)
+    #   end
+    #   
+    #   # Translates to This:
+    #   def my_method
+    #     my_variable = 1
+    #     @i_var = my_method(my_variable)
+    #   end
+    #   
+    #   # Or maybe translate from English to French
+    #   RubyTransform::Transformers::SymbolNames.new {|name| Google::Translate.new(:fr).translate(name) }
+    # 
+    class SymbolNames < RubyTransform::Transformer
+      def initialize(&block)
+        @name_transformer = block
+      end
+      
+      def transform(e)
+        super(transform_symbols(e))
+      end
+      
+      def transform_symbols(e)
+        return e unless sexp?(e)
+        
+        case e.kind
+        when :defn
+          e.clone.tap {|c| c[1] = @name_transformer.call(c[1].to_s).to_sym }
+        when :defs
+          e.clone.tap {|c| c[2] = @name_transformer.call(c[2].to_s).to_sym }
+        when :call
+          e.clone.tap {|c| c[2] = @name_transformer.call(c[2].to_s).to_sym }
+        when :lasgn, :lvar
+          e.clone.tap {|c| c[1] = @name_transformer.call(c[1].to_s).to_sym }
+        when :cvdecl, :cvasgn, :cvar
+          e.clone.tap {|c| c[1] = ("@@" + @name_transformer.call(c[1].to_s.gsub(/^@@/, ''))).to_sym }
+        when :iasgn, :ivar
+          e.clone.tap {|c| c[1] = ("@" + @name_transformer.call(c[1].to_s.gsub(/^@/, ''))).to_sym }
+        else
+          e
+        end
+      end
+    end
+    
+  end
+end

data/lib/ruby_transform/transformers/tapifier.rb

@@ -0,0 +1,77 @@
+module RubyTransform
+  module Transformers
+    
+    # = Method Temporary Variables to Tap Block
+    # Looks for instances of method declarations where:
+    # 1. A local variable is assigned to something as the first statement.
+    # 2. As the last statement, that local variable is returned is expressed.
+    # 
+    # These instances of using "temporary variables" to construct something for returning can be more 
+    # elegantly expressed by using the .tap idiom.
+    #
+    # Example:
+    # 
+    #   def my_method
+    #     temp = ""
+    #     temp << "Something"
+    #     call_something(temp)
+    #     temp
+    #   end
+    # 
+    # Converts To:
+    # 
+    #   def my_method
+    #     "".tap do |temp|
+    #       temp << "Something"
+    #       call_something(temp)
+    #     end
+    #   end
+    # 
+    class Tapifier < Transformer
+      def transform(e)
+        super(transform_tapify_candidates(e))
+      end
+      
+      def transform_tapify_candidates(e)
+        if matches_method_to_use_tap?(e)
+          transform_method_to_use_tap(e)
+        else
+          e
+        end
+      end
+      
+      def matches_method_to_use_tap?(e)
+        e.is_a?(Sexp) && [:defn, :defs].include?(e.kind) && 
+        matches_block_to_use_tap?(e.body[2])
+      end
+      
+      def matches_block_to_use_tap?(e)
+        return matches_block_to_use_tap?(e.body[0]) if e.body.size == 1 && e.body[0].kind == :block
+        
+        e.is_a?(Sexp) && e.kind == :block &&   # Some block (or method body)
+        e.body[0].kind == :lasgn &&  # The first line assigns to a local variable
+        expresses_local_variable?(e.body[-1], e.body[0].body[0])
+      end
+      
+      def expresses_local_variable?(e, local_variable)
+        (e.kind == :lvar && e.body[0] == local_variable) ||
+        (e.kind == :return && expresses_local_variable?(e.body[0], local_variable))
+      end
+      
+      def transform_method_to_use_tap(e)
+        s(e.kind, e.body[0], e.body[1], transform_block_to_use_tap(e.body[2]))
+      end
+      
+      def transform_block_to_use_tap(e)
+        return s(:scope, transform_block_to_use_tap(e.body[0])) if e.body.size == 1 && e.kind == :scope && e.body[0].kind == :block
+        
+        s(:block, s(:iter, 
+          s(:call, e.body[0].body[1], :tap, s(:arglist)),
+          s(:lasgn, e.body[0].body[0]),
+          s(*([:block] + e.body[1..-2]))
+        ))
+      end
+    end
+    
+  end
+end

data/lib/ruby_transform/version.rb

@@ -0,0 +1,3 @@
+module RubyTransform
+  VERSION = "0.1.1"
+end

data/lib/ruby_transform.rb

@@ -0,0 +1,8 @@
+require "rubygems"
+require "active_support"
+require "ruby_parser"
+require "ruby_scribe"
+
+Dir[File.join(File.dirname(__FILE__), "ruby_transform/**/**/*.rb")].each do |file|
+  require file
+end

data/spec/matchers/should_transform_to.rb

@@ -0,0 +1,25 @@
+RSpec::Matchers.define :transform_to do |desc, expected|
+  match do |actual|
+    actual_as_sexp = actual.is_a?(String) ? RubyParser.new.parse(actual) : actual
+    expected_as_sexp = expected.is_a?(String) ? RubyParser.new.parse(expected) : expected
+    
+    @transformed = described_class.transform(actual_as_sexp)
+    @transformed == expected_as_sexp
+  end
+  
+  failure_message_for_should do |actual|
+    "expected that:\n\n#{RubyParser.new.parse(actual)}\n\nwould transform to:\n\n#{RubyParser.new.parse(expected)}\n\nbut instead was:\n\n#{@transformed}"
+  end
+
+  failure_message_for_should_not do |actual|
+    "expected that:\n\n#{RubyParser.new.parse(actual)}\n\nwould not transform to:\n\n#{RubyParser.new.parse(expected)}\n\nbut instead was:\n\n#{@transformed}"
+  end
+  
+  description do
+    "transform with to #{desc}"
+  end
+  
+  def transformed_as_ruby
+    RubyTransform::Emitter.new.emit(@transformed)
+  end
+end

data/spec/ruby_transform/registry_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+describe RubyTransform::Registry do
+  before do
+    RubyTransform::Registry.configure do
+      register :blocks_to_symbols, RubyTransform::Transformers::BlockMethodToProcifier.new
+      register :eachify, RubyTransform::Transformers::Eachifier.new
+      register :tapify, RubyTransform::Transformers::Tapifier.new
+      
+      register :underscore_names, RubyTransform::Transformers::SymbolNames.new {|name| name.underscore }
+      
+      register :composite_with_objects, [
+        RubyTransform::Transformers::BlockMethodToProcifier.new,
+        RubyTransform::Transformers::Eachifier.new,
+        RubyTransform::Transformers::Tapifier.new
+      ]
+      
+      register :composite_with_symbols, [
+        :blocks_to_symbols,
+        :eachify,
+        :tapify
+      ]
+    end
+  end
+  
+  it "should have registered blocks to symbols" do
+    RubyTransform::Registry["blocks_to_symbols"].should be_a(RubyTransform::Transformers::BlockMethodToProcifier)
+  end
+  
+  it "should have registered eachify" do
+    RubyTransform::Registry["eachify"].should be_a(RubyTransform::Transformers::Eachifier)
+  end
+  
+  it "should have registered tapify" do
+    RubyTransform::Registry["tapify"].should be_a(RubyTransform::Transformers::Tapifier)
+  end
+  
+  it "should have registered underscore_names" do
+    RubyTransform::Registry["underscore_names"].should be_a(RubyTransform::Transformers::SymbolNames)
+  end
+  
+  it "should have registered composite_with_objects" do
+    RubyTransform::Registry["composite_with_objects"].should be_a(RubyTransform::Transformers::Composite)
+  end
+  
+  it "should have registered composite_with_symbols" do
+    RubyTransform::Registry["composite_with_symbols"].should be_a(RubyTransform::Transformers::Composite)
+  end
+end

data/spec/ruby_transform/transformer_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe RubyTransform::Transformer.new do
+  
+  describe "a for block" do
+    subject { %{
+      def my_method
+        call_something
+      
+        for element in array
+          do_something(element)
+        end
+      end
+    }}
+    
+    it { should transform_to("the same", %{
+      def my_method
+        call_something
+      
+        for element in array
+          do_something(element)
+        end
+      end
+    }) }
+  end
+  
+end

data/spec/ruby_transform/transformers/block_method_to_procifier_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+describe RubyTransform::Transformers::BlockMethodToProcifier.new do
+  
+  describe "a block call with method invocation" do
+    subject { %{collection.map {|d| d.name }}}
+    it { should transform_to("use Symbol#to_proc", %{collection.map(&:name)}) }
+  end
+  
+  describe "a block call with chained method invocation" do
+    subject { %{collection.map {|d| d.name.first }}}
+    it { should transform_to("itself", subject) }
+  end
+  
+  describe "a multiple-argument block call with method invocation" do
+    subject { %{collection.map {|d, i| d.name + i }}}
+    it { should transform_to("itself", subject) }
+  end
+  
+end

data/spec/ruby_transform/transformers/clear_explicit_returns.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe RubyTransform::Transformers::ClearExplicitReturns.new do
+  
+  describe "a method with explicit return" do
+    subject { %{
+      def my_method
+        a = 1
+        call_something(a)
+        return a
+      end
+    }}
+    
+    it { should transform_to("no return", %{
+      def my_method
+        a = 1
+        call_something(a)
+        a
+      end
+    }) }
+  end
+  
+end

data/spec/ruby_transform/transformers/composite_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+transformer = RubyTransform::Transformers::Composite.new([
+  RubyTransform::Transformers::Eachifier.new,
+  RubyTransform::Transformers::BlockMethodToProcifier.new,
+  RubyTransform::Transformers::Tapifier.new
+])
+
+describe(transformer) do
+  
+  describe "a block call with method invocation" do
+    subject { %{collection.map {|d| d.name }}}
+    it { should transform_to("use Symbol#to_proc", %{collection.map(&:name)}) }
+  end
+  
+  describe "a for block" do
+    subject { %{
+      def my_method
+        call_something
+      
+        for element in array
+          do_something(element)
+        end
+      end
+    }}
+    
+    it { should transform_to("each", %{
+      def my_method
+        call_something
+        
+        array.each do |element|
+          do_something(element)
+        end
+      end
+    }) }
+  end
+  # 
+  # describe "a method setting up and returning a temporary variable" do
+  #   subject {%{
+  #     def my_method
+  #       temp = ""
+  #       temp << "Something"
+  #       call_something(temp)
+  #       temp
+  #     end
+  #   }}
+  #   
+  #   it { should transform_to("wrap in #tap", %{
+  #     def my_method
+  #       "".tap do |temp|
+  #         temp << "Something"
+  #         call_something(temp)
+  #       end
+  #     end
+  #   }) }
+  # end
+  
+end

data/spec/ruby_transform/transformers/custom_transformer_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+transformer = RubyTransform::Transformers::Custom.new do |expression|
+  if sexp?(expression) && expression.kind == :str
+    s(:str, expression.body[0].reverse)
+  else
+    super(expression)
+  end
+end
+
+describe(transformer) do
+  
+  describe "some strings" do
+    subject { %{
+      s = "one"
+      t = "two"
+    }}
+    
+    it { should transform_to("reverse", %{
+      s = "eno"
+      t = "owt"
+    }) }
+  end
+  
+end

data/spec/ruby_transform/transformers/eachifier_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe RubyTransform::Transformers::Eachifier.new do
+  
+  describe "a for block" do
+    subject { %{
+      def my_method
+        call_something
+      
+        for element in array
+          do_something(element)
+        end
+      end
+    }}
+    
+    it { should transform_to("each", %{
+      def my_method
+        call_something
+        
+        array.each do |element|
+          do_something(element)
+        end
+      end
+    }) }
+  end
+  
+end

data/spec/ruby_transform/transformers/symbol_names_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+SymbolUnderscorer = RubyTransform::Transformers::SymbolNames.new do |name|
+  name.underscore
+end
+
+describe SymbolUnderscorer do
+  
+  describe "method definition" do
+    subject { %{def myMethod; end; def self.anotherMethod; end} }
+    it { should transform_to("underscored", %{def my_method; end; def self.another_method; end}) }
+  end
+  
+  describe "method call" do
+    subject { %{myMethod.doSomething} }
+    it { should transform_to("underscored", %{my_method.do_something}) }
+  end
+  
+  describe "method arguments" do
+    subject { %{my(argOne, argTwo)} }
+    it { should transform_to("underscored", %{my(arg_one, arg_two)}) }
+  end
+  
+  describe "block arguments" do
+    subject { %{collection.each {|argOne, argTwo| something }} }
+    it { should transform_to("underscored", %{collection.each {|arg_one, arg_two| something }}) }
+  end
+  
+  describe "local variable" do
+    subject { %{def my; myVariable = 1; myVariable; end} }
+    it { should transform_to("underscored", %{def my; my_variable = 1; my_variable; end}) }
+  end
+  
+  describe "instance variable" do
+    subject { %{@myVariable = 1; @myVariable} }
+    it { should transform_to("underscored", %{@my_variable = 1; @my_variable}) }
+  end
+  
+  describe "class variable" do
+    subject { %{@@myVariable = 1; @@myVariable; def my; @@myVariable = 1; end} }
+    it { should transform_to("underscored", %{@@my_variable = 1; @@my_variable; def my; @@my_variable = 1; end}) }
+  end
+  
+end

data/spec/ruby_transform/transformers/tapifier_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe RubyTransform::Transformers::Tapifier.new do
+  
+  describe "a method setting up and returning a temporary variable" do
+    subject {%{
+      def my_method
+        temp = ""
+        temp << "Something"
+        call_something(temp)
+        temp
+      end
+    }}
+    
+    it { should transform_to("wrap in #tap", %{
+      def my_method
+        "".tap do |temp|
+          temp << "Something"
+          call_something(temp)
+        end
+      end
+    }) }
+  end
+  
+  describe "a method setting up and explicitly returning a temporary variable" do
+    subject {%{
+      def my_method
+        temp = ""
+        temp << "Something"
+        call_something(temp)
+        return temp
+      end
+    }}
+    
+    it { should transform_to("wrap in #tap", %{
+      def my_method
+        "".tap do |temp|
+          temp << "Something"
+          call_something(temp)
+        end
+      end
+    }) }
+  end
+  
+  describe "a method setting up and not returning a temporary variable" do
+    subject {%{
+      def my_method
+        temp = ""
+        temp << "Something"
+        call_something(temp)
+      end
+    }}
+    
+    it { should transform_to("itself", subject) }
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$:.unshift(File.join(File.dirname(__FILE__), "../lib"))
+
+require "rubygems"
+require "rspec"
+require "ruby_transform"
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/matchers/**/*.rb"].each {|f| require f}

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: ruby_transform
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Ben Hughes
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: &70114553708920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70114553708920
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70114553704060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.10
+  type: :runtime
+  prerelease: false
+  version_requirements: *70114553704060
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: &70114553703580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70114553703580
+- !ruby/object:Gem::Dependency
+  name: ruby_parser
+  requirement: &70114553703100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *70114553703100
+- !ruby/object:Gem::Dependency
+  name: ruby_scribe
+  requirement: &70114553702620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70114553702620
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70114553702140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: *70114553702140
+description: Provides a series of s-expression transformations useful for automatic
+  refactoring or morphing of Ruby/Rails/Sinatra code.
+email: ben@railsgarden.com
+executables:
+- rubytransform
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ruby_transform/registry.rb
+- lib/ruby_transform/runner.rb
+- lib/ruby_transform/transform_helpers.rb
+- lib/ruby_transform/transformer.rb
+- lib/ruby_transform/transformers/block_method_to_procifier.rb
+- lib/ruby_transform/transformers/clear_explicit_returns.rb
+- lib/ruby_transform/transformers/composite.rb
+- lib/ruby_transform/transformers/custom.rb
+- lib/ruby_transform/transformers/eachifier.rb
+- lib/ruby_transform/transformers/symbol_names.rb
+- lib/ruby_transform/transformers/tapifier.rb
+- lib/ruby_transform/version.rb
+- lib/ruby_transform.rb
+- spec/matchers/should_transform_to.rb
+- spec/ruby_transform/registry_spec.rb
+- spec/ruby_transform/transformer_spec.rb
+- spec/ruby_transform/transformers/block_method_to_procifier_spec.rb
+- spec/ruby_transform/transformers/clear_explicit_returns.rb
+- spec/ruby_transform/transformers/composite_spec.rb
+- spec/ruby_transform/transformers/custom_transformer_spec.rb
+- spec/ruby_transform/transformers/eachifier_spec.rb
+- spec/ruby_transform/transformers/symbol_names_spec.rb
+- spec/ruby_transform/transformers/tapifier_spec.rb
+- spec/spec_helper.rb
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- Rakefile
+- README.rdoc
+- TODO.rdoc
+- bin/rubytransform
+homepage: http://github.com/rubiety/ruby_transform
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.4
+requirements: []
+rubyforge_project: ruby_transform
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: S-expression transformations for Ruby.
+test_files: []