ruby_scribe 0.0.3 → 0.0.4

data/lib/ruby_scribe.rb

@@ -4,6 +4,7 @@ require "ruby_parser"
 
 require "ruby_scribe/emitter_helpers"
 require "ruby_scribe/emitter"
+require "ruby_scribe/transformer_helpers"
 require "ruby_scribe/transformer"
 require "ruby_scribe/ext/sexp"
 

data/lib/ruby_scribe/transformer.rb

@@ -1,9 +1,12 @@
 module RubyScribe
+  
   # 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) }))

data/lib/ruby_scribe/transformer_helpers.rb

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

data/lib/ruby_scribe/transformers/block_method_to_procifier.rb

@@ -0,0 +1,43 @@
+module RubyScribe
+  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)
+        if matches_block_to_use_tap?(e)
+          super transform_block_to_use_tap(e)
+        else
+          super
+        end
+      end
+      
+      def matches_block_to_use_tap?(e)
+        e.is_a?(Sexp) && e.kind == :iter &&  # Calls block
+        e.body[2] && e.body[2].kind == :call &&  # Body of block is a simple method call
+        e.body[2].body[0].kind == :lvar &&  # Simple method call is on a local variable
+        e.body[1].kind == :lasgn &&  # Block parameter is a single assign
+        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_scribe/transformers/custom.rb

@@ -0,0 +1,27 @@
+module RubyScribe
+  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
+    #   RubyScribe::Transformers::Custom.new do |expression|
+    #     if sexp?(expression) && expression.kind == :str
+    #       s(:str, expression.body[0].reverse)
+    #     else
+    #       super
+    #     end
+    #   end
+    # 
+    class Custom < RubyScribe::Transformer
+      def initialize(&block)
+        class_eval do
+          define_method(:transform, &block)
+        end
+      end
+    end
+    
+  end
+end

data/lib/ruby_scribe/transformers/eachifier.rb

@@ -1,9 +1,26 @@
 module RubyScribe
   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)
         if e.is_a?(Sexp) && e.kind == :for
-          transform_for_to_each(e)
+          super transform_for_to_each(e)
         else
           super
         end
@@ -17,5 +34,6 @@ module RubyScribe
         )
       end
     end
+    
   end
 end

data/lib/ruby_scribe/transformers/symbol_names.rb

@@ -0,0 +1,68 @@
+module RubyScribe
+  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
+    #   RubyScribe::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
+    #   RubyScribe::Transformers::SymbolNames.new {|name| Google::Translate.new(:fr).translate(name) }
+    # 
+    class SymbolNames < RubyScribe::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_scribe/transformers/tapifier.rb

@@ -0,0 +1,73 @@
+module RubyScribe
+  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)
+        if matches_method_to_use_tap?(e)
+          super transform_method_to_use_tap(e)
+        else
+          super
+        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_scribe/version.rb

@@ -1,3 +1,3 @@
 module RubyScribe
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/spec/matchers/should_transform_to.rb

@@ -3,7 +3,7 @@ RSpec::Matchers.define :transform_to do |desc, expected|
     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.new.transform(actual_as_sexp)
+    @transformed = described_class.transform(actual_as_sexp)
     @transformed == expected_as_sexp
   end
   
@@ -18,4 +18,8 @@ RSpec::Matchers.define :transform_to do |desc, expected|
   description do
     "transform with to #{desc}"
   end
+  
+  def transformed_as_ruby
+    RubyScribe::Emitter.new.emit(@transformed)
+  end
 end

data/spec/ruby_scribe/transformer_spec.rb

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-describe RubyScribe::Transformer do
+describe RubyScribe::Transformer.new do
   
   describe "a for block" do
     subject { %{

data/spec/ruby_scribe/transformers/block_method_to_procifier_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+describe RubyScribe::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_scribe/transformers/custom_spec.rb

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

data/spec/ruby_scribe/transformers/eachifier_spec.rb

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-describe RubyScribe::Transformers::Eachifier do
+describe RubyScribe::Transformers::Eachifier.new do
   
   describe "a for block" do
     subject { %{

data/spec/ruby_scribe/transformers/symbol_names_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+SymbolUnderscorer = RubyScribe::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_scribe/transformers/tapifier_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe RubyScribe::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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ruby_scribe
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: false
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Ben Hughes
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-27 00:00:00 +03:00
+date: 2010-10-28 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -78,7 +78,12 @@ files:
 - lib/ruby_scribe/ext/sexp.rb
 - lib/ruby_scribe/runner.rb
 - lib/ruby_scribe/transformer.rb
+- lib/ruby_scribe/transformer_helpers.rb
+- lib/ruby_scribe/transformers/block_method_to_procifier.rb
+- lib/ruby_scribe/transformers/custom.rb
 - lib/ruby_scribe/transformers/eachifier.rb
+- lib/ruby_scribe/transformers/symbol_names.rb
+- lib/ruby_scribe/transformers/tapifier.rb
 - lib/ruby_scribe/version.rb
 - lib/ruby_scribe.rb
 - spec/examples/identity.rb
@@ -89,7 +94,11 @@ files:
 - spec/ruby_scribe/emitter_examples_spec.rb
 - spec/ruby_scribe/emitter_spec.rb
 - spec/ruby_scribe/transformer_spec.rb
+- spec/ruby_scribe/transformers/block_method_to_procifier_spec.rb
+- spec/ruby_scribe/transformers/custom_spec.rb
 - spec/ruby_scribe/transformers/eachifier_spec.rb
+- spec/ruby_scribe/transformers/symbol_names_spec.rb
+- spec/ruby_scribe/transformers/tapifier_spec.rb
 - spec/spec_helper.rb
 - LICENSE
 - Rakefile