ruby_traverser 0.1.1 → 0.2.0

data/lib/manipulation/api.rb

@@ -0,0 +1,30 @@
+require 'manipulation/update/api'
+require 'manipulation/delete/api'
+require 'manipulation/insert/api'
+require 'manipulation/position'
+require 'manipulation/helpers'
+
+module RubyCodeAPI
+  module Manipulation  
+    include Insert
+    include Update
+    include Delete 
+    include RubyCodeAPI::Misc::Position
+    include RubyCodeAPI::Misc::Helper    
+  end
+end
+
+module Ruby
+  class Node
+    include RubyCodeAPI::Manipulation
+  end
+end
+
+# Core extensions
+
+class String
+  # Returns an indented string, all lines of string will be indented with count of chars
+  def indent(char, count)
+    (char * count) + gsub(/(\n+)/) { $1 + (char * count) }
+  end
+end

data/lib/manipulation/delete/api.rb

@@ -0,0 +1,10 @@
+module RubyCodeAPI
+  module Manipulation  
+    module Delete
+      def delete
+        # index = parent.find_index(self)
+        parent.get_elements.delete(self)    
+      end
+    end          
+  end
+end

data/lib/manipulation/helpers.rb

@@ -0,0 +1,30 @@
+module RubyCodeAPI
+  module Misc
+    module Helper
+      def find_index(obj)
+        get_elements.each_with_index do |elem, i|
+          if elem == obj
+            return i
+          end
+        end        
+      end
+
+      def elemental?
+        respond_to?(:body) || respond_to?(:elements)
+      end
+
+      def get_elements
+        case self
+        when Ruby::Class
+          body.elements
+        else
+          elements
+        end
+      end
+
+      def object
+        self.respond_to?(:block) ? self.block : self
+      end
+    end      
+  end
+end

data/lib/manipulation/insert/api.rb

@@ -0,0 +1,57 @@
+module RubyCodeAPI
+  module Manipulation  
+    module Insert
+      def append_code(code)
+        return append_code_simple(code) if !elemental?
+        obj = object
+        indentation = obj.last_indent  
+        code =  "\n#{code}\n".indent(' ', indentation)
+        ruby_code = Ripper::RubyBuilder.build(code)
+        inject_code = ruby_code.elements[0]
+        obj.get_elements << inject_code
+        inject_code
+      end
+
+      def append_code_simple(code)
+        indentation = position.col
+        code =  "\n#{code}\n".indent(' ', indentation)
+        ruby_code = Ripper::RubyBuilder.build(code)
+        inject_code = ruby_code.elements[0]
+        index = parent.find_index(self)
+        parent.get_elements.insert(index+1, inject_code)
+        inject_code
+      end
+
+      def prepend_code(code)
+        obj = object
+        indentation = obj.first_indent  
+        code =  "\n#{code}\n".indent(' ', indentation)
+        ruby_code = Ripper::RubyBuilder.build(code)
+        inject_code = ruby_code.elements[0]
+        obj.get_elements.insert(0, inject_code)
+        obj
+      end
+
+      def insert_comment(position, text, &block)
+        insert(position, "# #{text}", &block)    
+      end
+  
+      def insert(position, code, &block)
+        case position
+        when :after
+          s = append_code(code)
+        when :before
+          s = prepend_code(code)
+        else
+          raise Error, "Invalid position given: #{position}, must be either :before or :after"
+        end  
+    
+        if block_given?
+          block.arity < 1 ? s.instance_eval(&block) : block.call(s)      
+        else
+          s
+        end    
+      end  
+    end  
+  end
+end

data/lib/manipulation/position.rb

@@ -0,0 +1,44 @@
+module RubyCodeAPI
+  module Misc
+    module Position
+      protected
+
+      def last_indent
+        case self
+        when Ruby::Block, Ruby::Class
+          last_position(get_elements)                           
+        else
+          puts "unknown: #{obj.class}"
+        end
+      end
+
+      def last_position(elements) 
+        last_element = elements.last
+        return position.col 
+        return position.col if simple_pos?(last_element)
+        return last_element.identifier.position.col if elements && elements.size > 0
+        inside_indent
+      end
+
+      def simple_pos?(elem)       
+        [Ruby::Token, Ruby::Variable].include?(elem.class)
+      end
+
+      def first_indent
+        case self
+        when Ruby::Block, Ruby::Class
+          first_position(get_elements)                           
+        else
+          puts "unknown: #{obj.class}"
+        end
+      end
+
+      def first_position(elements) 
+        first_element = elements.first
+        return position.col if simple_pos?(first_element)
+        return first_element.identifier.position.col if elements && elements.size > 0
+        inside_indent
+      end
+    end
+  end
+end

data/lib/{mutate/replacer.rb → manipulation/update/api.rb}

@@ -7,7 +7,7 @@ module PositionReplacer
   def replace_pos_argument(options)                                    
     case self.arg
     when Ruby::String                                    
-      replace_arg_token(options[:replace_arg])
+      replace_arg_token(options[:with])
     end
   end
 
@@ -88,24 +88,35 @@ module ValueReplacer
   end 
 end
 
-module RubyAPI
-  module Mutator
-    module Replacer
+module RubyCodeAPI
+  module Manipulation  
+    module Update
       include PositionReplacer
       include TokenReplacer  
       include HashReplacer
       include ValueReplacer              
+
+      # update :select => {...}, :with => {...}
+      # update :select => {...}, :with_code => 'code'
+      def update(options, &block)                
+        s = replace_value(options) if options[:value]
+        s = replace options[:select].merge(options) if options[:select]        
+        if block_given?
+          block.arity < 1 ? s.instance_eval(&block) : block.call(s)      
+        else
+          s
+        end        
+      end
       
       # :arg => 'ripper', :replace_arg => 'rapper'
-      def replace(options)                       
-        if options[:value]
-          return replace_value(options) 
-        end
-        
-        if position_arg?(options[:arg])
-          return replace_position_arg(options) 
-        end
-        
+      def replace(options)                               
+        return replace_value(options) if options[:value]
+        return replace_position_arg(options) if position_arg?(options[:arg])
+        return replace_arg(options) if options[:arg]
+        raise Error, "Invalid options: #{options}"
+      end
+
+      def replace_arg(options)
         self.arguments.elements.each_with_index do |elem, i|
           case elem
           when Ruby::Arg
@@ -120,7 +131,7 @@ module RubyAPI
       def replace_argument(options)                                    
         case self.arg
         when Ruby::String                                    
-          replace_arg_token(options[:replace_arg]) if matching_string_arg?(options[:arg])  
+          replace_arg_token(options[:with]) if matching_string_arg?(options[:arg])  
         end
       end
 

data/lib/query/api.rb

@@ -0,0 +1,7 @@
+require 'query/find'
+
+module Ruby
+  class Node
+    include RubyCodeAPI::Query
+  end
+end

data/lib/query/find.rb

@@ -0,0 +1,73 @@
+require 'yaml'
+
+module RubyCodeAPI
+  module Query  
+    # Use this to generate all methods except for find_block which is a bit special
+    NODES = {
+      :module => Ruby::Module, 
+      :class => Ruby::Class, 
+      :variable => [Ruby::Variable, :token], 
+      :assignment => [Ruby::Assignment, :left_token], 
+      :call => Ruby::Call, 
+      :def => Ruby::Method
+    }
+    
+    def find(type, name, options = {}, &block) 
+      s = send :"find_#{type.to_s}", name, options
+      s.extend(options[:extend]) if options[:extend] 
+      if block_given?
+        block.arity < 1 ? s.instance_eval(&block) : block.call(s)      
+      else
+        s
+      end
+    end        
+
+    def inside(type, name, options = {}, &block) 
+      raise StandardError, "Must have block argument" if !block_given?
+      find(type, name, options = {}, &block)       
+    end
+
+    instance_eval do   
+      NODES.each_pair do |key, value| 
+        case value
+        when Array
+          define_method :"find_#{key}" do |name, options|
+            find_by(value[1], value[0], name, options)                
+          end
+        else
+          define_method :"find_#{key}" do |name, options|
+            find_by(:identifier, value, name, options)                
+          end
+        end
+      end
+    end
+
+    def find_by(key, type, name, options)
+      options.merge!(key => name)
+      get_obj.select(type, options).first
+    end
+
+    def find_block(name, options = {})  
+      options.merge!(:block => true) if !options.has_key?(:block_params)    
+      find_by(:identifier, Ruby::Call, name, options)      
+    end 
+    
+    alias_method :find_method, :find_def    
+    
+    protected
+    
+      def inside_indent
+        if self.class == Ruby::Class
+          pos = ldelim.position.col
+          return pos
+        end
+        2
+      end
+
+      def get_obj(options = {})
+        return self.block if self.class == Ruby::Method     
+        self
+      end  
+    
+  end
+end  

data/lib/rails/api.rb

@@ -0,0 +1,13 @@
+require 'rails/gemfile'
+
+module RubyCodeAPI
+  module Rails
+    include Gemfile
+  end
+end
+
+module Ruby
+  class Node
+    include RubyCodeAPI::Rails
+  end
+end

data/lib/rails/{api_wrapper.rb → gemfile.rb}

@@ -1,4 +1,4 @@
-module RubyAPI
+module RubyCodeAPI
   module Rails
     module Gemfile
       def inside_group(name, &block)

data/lib/ruby_traverser.rb

@@ -1,4 +1,2 @@
 require 'ripper2ruby'
-require 'traversal/mixin'
-require 'traversal/api/traversal'
-require 'mutate/api'
+require 'config/api'

data/ruby_traverser.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ruby_traverser}
-  s.version = "0.1.1"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Kristian Mandrup"]
-  s.date = %q{2010-04-27}
+  s.date = %q{2010-04-28}
   s.description = %q{traverse a ruby code model and optionally mutate it along the way using a nice rubyish DSL}
   s.email = %q{kmandrup@gmail.com}
   s.extra_rdoc_files = [
@@ -21,22 +21,30 @@ Gem::Specification.new do |s|
     "LICENSE",
     "README.markdown",
     "Rakefile",
+    "TODO.txt",
     "VERSION",
-    "lib/mutate/api.rb",
-    "lib/mutate/replacer.rb",
-    "lib/rails/api_wrapper.rb",
+    "lib/config/api.rb",
+    "lib/config/has_ext.rb",
+    "lib/config/misc.rb",
+    "lib/config/mixin.rb",
+    "lib/config/module.rb",
+    "lib/config/patch.rb",
+    "lib/manipulation/api.rb",
+    "lib/manipulation/delete/api.rb",
+    "lib/manipulation/helpers.rb",
+    "lib/manipulation/insert/api.rb",
+    "lib/manipulation/position.rb",
+    "lib/manipulation/update/api.rb",
+    "lib/query/api.rb",
+    "lib/query/find.rb",
+    "lib/rails/api.rb",
+    "lib/rails/gemfile.rb",
     "lib/ruby_traverser.rb",
-    "lib/traversal/api/finders.rb",
-    "lib/traversal/api/inside.rb",
-    "lib/traversal/api/traversal.rb",
-    "lib/traversal/misc.rb",
-    "lib/traversal/mixin.rb",
-    "lib/traversal/module.rb",
-    "lib/traversal/patch.rb",
     "ruby_traverser.gemspec",
     "spec/ruby_traverser_spec.rb",
     "spec/spec.opts",
     "spec/spec_helper.rb",
+    "test/mutate/delete_test.rb",
     "test/mutate/mutate_class_test.rb",
     "test/mutate/mutate_test.rb",
     "test/rails_api/gemfile_api.rb",
@@ -52,6 +60,7 @@ Gem::Specification.new do |s|
   s.test_files = [
     "spec/ruby_traverser_spec.rb",
     "spec/spec_helper.rb",
+    "test/mutate/delete_test.rb",
     "test/mutate/mutate_class_test.rb",
     "test/mutate/mutate_test.rb",
     "test/rails_api/gemfile_api.rb",

data/test/mutate/delete_test.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'yaml'
+
+class TraversalTest < Test::Unit::TestCase
+  include TestHelper
+
+
+  define_method :"test find assignment in method definition and replace value of right side" do                           
+    src = %q{    
+      def hello_world(a)
+        my_var = 2
+      end  
+    }    
+        
+    code = Ripper::RubyBuilder.build(src)               
+
+    code.inside(:def, 'hello_world', :params => ['a']) do |b|
+      # call_node = b.find_call('gem', :args => ['ripper', {:src => 'github'}], :verbose => true)
+      ass_node = b.find(:assignment, 'my_var')
+      assert_equal Ruby::Assignment, ass_node.class    
+      ass_node.delete
+      puts b.to_ruby
+    end
+  end
+end