ruby_scribe 0.0.4 → 0.1.0

data/lib/ruby_scribe/transformers/custom.rb

@@ -1,27 +0,0 @@
-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,39 +0,0 @@
-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
-          super transform_for_to_each(e)
-        else
-          super
-        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_scribe/transformers/symbol_names.rb

@@ -1,68 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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/spec/ruby_scribe/transformer_spec.rb

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

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

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

@@ -1,44 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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