ruby_traverser 0.1.0

data/lib/traversal/misc.rb

@@ -0,0 +1,152 @@
+module Ruby
+  class Node
+    module Traversal
+      module Misc
+        def args?(value, with_block = nil) 
+          found = 0        
+          obj = has_a_block?(with_block) ? self.block : self
+          args_list = get_args_list(obj)
+          return false if !args_list    
+          args_list.elements.each do |arg|    
+            argument = retrieve_arg(arg)  
+            next if !valid_arg?(argument)
+            value.each do |v|            
+              v = v[:array] if v.respond_to?(:has_key?) && v[:array]              
+              found += 1 if argument == v
+            end
+          end     
+          return found == argument_count(value)
+        end                             
+
+        def argument_count(args)
+          args.reject{|arg| !valid_arg?(arg)}.size
+        end
+        
+        def valid_arg?(arg)
+          arg && arg != {} 
+        end
+        
+        def has_a_block?(with_block)
+          with_block && self.respond_to?(:block)
+        end                                
+
+        def get_args_list(obj)                         
+          return obj.params if obj.respond_to? :params 
+          return obj.arguments if obj.respond_to? :arguments 
+          # return obj if obj.class == Ruby::ArgsList       
+        end
+
+        def resolve_arg_wrapper(arg_wrapper)
+          return arg_wrapper.arg if arg_wrapper.respond_to? :arg            
+          return arg_wrapper.param if arg_wrapper.respond_to? :param            
+          return arg_wrapper if arg_wrapper.class == Ruby::Arg
+          arg_wrapper
+        end
+
+        def retrieve_arg(arg_wrapper)
+          arg = resolve_arg_wrapper(arg_wrapper)
+          argument = get_arg(arg)       
+          convert_value(argument, arg)
+        end
+
+        def convert_value(value, type = nil)
+          type_val = type || value
+          case type_val                    
+          when Ruby::Symbol  
+            value.to_sym
+          when Ruby::Integer
+            value.to_i                          
+          when Ruby::Float
+            value.to_f        
+          when Ruby::Hash
+            type ? get_hash(type) : value       
+          when Ruby::Array
+            type ? get_array(type) : value       
+          when Ruby::Assoc   
+            return get_assoc(type)
+          else
+            value
+          end
+        end      
+
+        def get_arg(arg)  
+          get_symbol(arg) || get_assoc(arg) || get_composite(arg) || get_identifier(arg) || get_token(arg) || resolve_arg_wrapper(arg)
+        end
+
+        def get_symbol(arg)
+          return nil if !(arg.class == Ruby::Symbol)
+          t = get_token(arg)
+          t ? t.to_sym : nil
+        end
+
+        def get_composite(arg)
+          return nil if !arg.respond_to? :elements
+          e = arg.elements
+          return get_arg(e[0]) if e.size == 1
+          get_hash(e) || get_array(e)
+        end
+
+        def get_array(args)
+          return nil if arg.class != Ruby::Array
+          arr = []  
+          args.each do |arg|
+             arr << get_arg(arg)
+          end
+          return arr if !arr.empty?
+          nil
+        end 
+
+        def get_hash(args)    
+          return nil if !args.class == Ruby::Hash
+          items = args.respond_to?(:elements) ? args.elements : args 
+          hash = {}  
+          items.each do |arg|  
+             hash_val = get_arg(arg) 
+             hash.merge!(hash_val)
+          end    
+          return hash if !hash.empty?
+          nil
+        end 
+
+        def get_assoc(arg)
+          return nil if !(arg.class == Ruby::Assoc) 
+          get_hash_item(arg)      
+        end
+
+        def get_hash_item(arg)   
+          return if !arg.respond_to? :key      
+          key = get_key(arg.key)
+          value = get_value(arg.value)
+          return {key => value}
+        end
+
+        def get_key(key)             
+          if key.respond_to? :identifier
+           id = get_identifier(key)
+          end
+          return id.to_sym if key.class == Ruby::Symbol
+          return get_token(key) if key.class == Ruby::Variable
+          id
+        end
+
+        # Needs rework!
+        def get_value(value)
+          real_value = get_arg(value)
+          convert_value(real_value, value)
+        end
+
+        def get_identifier(arg)
+          get_token(arg.identifier) if arg.respond_to? :identifier
+        end
+
+        def get_string(arg)
+          get_token(arg.elements[0]) if arg.class == Ruby::String
+        end
+
+        def get_token(arg)                             
+          arg.token if arg.respond_to? :token
+        end
+      end
+    end
+  end        
+end

data/lib/traversal/mixin.rb

@@ -0,0 +1,50 @@
+require 'traversal/module'
+require 'traversal/misc'
+require 'traversal/patch'
+
+module Ruby
+  class Node
+    include Traversal::Module
+    include Traversal::Misc
+    include Traversal::Patch      
+    
+    def has_const?(value)
+      if respond_to?(:const)
+        if namespace?(value)
+          name = value.split('::').last
+          return self.const.identifier.token == name
+        end
+      end
+      false
+    end
+
+    def has_block?
+      respond_to? :block
+    end      
+
+    def has_namespace?(value)
+      if respond_to?(:namespace)
+        return self.namespace.identifier.token == value
+      end
+      false
+    end
+
+    def has_identifier?(value)
+      if respond_to?(:identifier)
+        id = self.identifier
+
+        if namespace?(value)
+          return id.token.to_s == value.to_s if id.respond_to?(:token)
+          if id.respond_to?(:identifier)
+            name = value.split('::').last
+            return id.identifier.token == name
+          end
+        end
+      else
+        has_const?(value)
+      end
+    end
+  end    
+end   
+
+     

data/lib/traversal/module.rb

@@ -0,0 +1,52 @@
+module Ruby
+  class Node
+    module Traversal
+      module Module
+        def namespace?(full_name)
+          if full_name.split('::').size > 1
+            namespaces = full_name.split('::')[0..-2]
+            namespace = namespaces.join('::')
+
+            if class_or_module?
+              return module_namespace?(namespace)
+            end
+          end
+          true
+        end
+
+        def class_or_module?
+          [Ruby::Class, Ruby::Module].include?(self.class)
+        end
+
+        def module_namespace?(namespace)
+          namespace == get_full_namespace(get_namespace) 
+        end
+
+        def get_namespace
+          return self.const.namespace if self.respond_to?(:const)
+          self.identifier.namespace      
+        end
+
+        def get_full_namespace(ns)
+          if ns.respond_to?(:namespace)
+            name = ns.identifier.token 
+            parent_ns = get_full_namespace(ns.namespace)
+            name += ('::' + parent_ns) if !parent_ns.empty?
+            return name.split('::').reverse.join('::')
+          else
+            return ns.identifier.token if ns.respond_to?(:identifier)
+            ""
+          end
+        end      
+
+        def superclass?(value)      
+          if class_or_module?
+            ns = get_full_namespace(self.super_class) 
+            return ns == value
+          end
+          false      
+        end
+      end
+    end
+  end
+end

data/lib/traversal/patch.rb

@@ -0,0 +1,83 @@
+module Ruby
+  class Node
+    module Traversal
+      module Patch
+        def select(*args, &block)
+          result = []
+          result << self if matches?(args.dup, &block)
+          children.flatten.compact.inject(result) do |result, node|
+            if node.class.to_s == 'Symbol'
+              return result
+            end
+            selected = node.select(*args, &block)                        
+            result + selected
+          end   
+        end
+
+        def children
+          (self.try(:elements).to_a || prolog.try(:elements).to_a || []) + nodes
+        end
+
+        def matches?(args, &block) 
+          conditions = args.last.is_a?(::Hash) ? args.pop : {}
+          conditions[:is_a] = args unless args.empty?
+
+          type_condition = conditions[:is_a][0]
+          if type_condition
+            return nil if !has_type?(type_condition)
+          end
+
+          res = conditions.inject(!conditions.empty?) do |result, (type, value)|
+            block_result = (!block_given? || block.call(self))
+            check_res = check_pair(type, value)
+            return false if !check_res
+            result && check_res && block_result
+          end
+          res
+        end
+        
+        def check_pair(type, value)
+          res = case type
+          when :is_a
+            has_type?(value)
+          when :class
+            is_instance_of?(value)
+          when :token
+            has_token?(value)
+          when :left_token
+            left.has_token?(value)
+          when :right_token
+            right.has_token?(value)
+          when :value
+            has_value?(value)
+          when :identifier
+            has_identifier?(value)
+          when :const
+            has_const?(value)
+          when :block
+            has_block?
+          when :namespace          
+            has_namespace?(value)
+          when :superclass
+            superclass?(value)
+          when :args, :params
+            args?(value)                        
+          when :block_params          
+            args?(value, :withblock)          
+          when :pos, :position
+            position?(value)
+          when :right_of
+            right_of?(value)
+          when :left_of
+            left_of?(value) 
+          else
+            true
+          end
+          # puts "check pair type:#{type}, value:#{value} => #{res}, self: #{self.inspect}" if self.class == Ruby::Variable 
+          res
+        end 
+        
+      end # Patch
+    end
+  end
+end

data/ruby_traverser.gemspec

@@ -0,0 +1,79 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{ruby_traverser}
+  s.version = "0.1.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.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 = [
+    "LICENSE",
+    "README.markdown"
+  ]
+  s.files = [
+    ".gitignore",
+    "LICENSE",
+    "README.markdown",
+    "Rakefile",
+    "VERSION",
+    "lib/mutate/api.rb",
+    "lib/mutate/replacer.rb",
+    "lib/rails/api_wrapper.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/mutate_class_test.rb",
+    "test/mutate/mutate_test.rb",
+    "test/rails_api/gemfile_api.rb",
+    "test/test_helper.rb",
+    "test/traversal/gemfile_test.rb",
+    "test/traversal/ruby_api_traversal_test.rb"
+  ]
+  s.homepage = %q{http://github.com/kristianmandrup/ruby_trav}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{traverse and mutate ruby code using a nice DSL}
+  s.test_files = [
+    "spec/ruby_traverser_spec.rb",
+    "spec/spec_helper.rb",
+    "test/mutate/mutate_class_test.rb",
+    "test/mutate/mutate_test.rb",
+    "test/rails_api/gemfile_api.rb",
+    "test/test_helper.rb",
+    "test/traversal/gemfile_test.rb",
+    "test/traversal/ruby_api_traversal_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 2.0.0"])
+      s.add_runtime_dependency(%q<ripper2ruby>, ["> 0.0.2"])
+    else
+      s.add_dependency(%q<rspec>, [">= 2.0.0"])
+      s.add_dependency(%q<ripper2ruby>, ["> 0.0.2"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 2.0.0"])
+    s.add_dependency(%q<ripper2ruby>, ["> 0.0.2"])
+  end
+end
+

data/spec/ruby_traverser_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "RubyTrav" do
+  it "fails" do
+    fail "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'ruby_traverser'
+require 'rspec'
+require 'rspec/autorun'
+
+Rspec.configure do |c|
+  # c.mock_with :rspec
+end
+

data/test/mutate/mutate_class_test.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'yaml'
+
+class TraversalTest < Test::Unit::TestCase
+  include TestHelper
+
+  define_method :"test select Class that inherits from other Class and insert gem statements and a new method def" do                           
+    src = %q{  class Monty < Abc::Blip 
+  end}
+    
+    def_src = %q{
+def my_fun
+end}
+
+    def_code = Ripper::RubyBuilder.build(def_src)    
+    code = Ripper::RubyBuilder.build(src)              
+    code.inside_class('Monty', :superclass => 'Abc::Blip') do |b|
+      assert_equal Ruby::Class, b.class                                  
+      gem_abc = b.append_code("gem 'abc'")
+      blip = b.append_code("blip")
+      gem_123 = gem_abc.append_code("gem '123'")      
+      gem_123.append_comment("hello")      
+      my_def = b.append_code(def_src)      
+      
+      b.prepend_code("gem '789'")
+      puts b.to_ruby
+    end
+  end
+end   

data/test/mutate/mutate_test.rb

@@ -0,0 +1,90 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'yaml'
+
+class TraversalTest < Test::Unit::TestCase
+  include TestHelper
+
+  define_method :"test find gem statement inside group using DSL and then insert new gem statement" do                           
+    src = %q{                 
+group :test do
+  gem 'ripper', :src => 'github' 
+  gem 'blip'
+end  
+    }
+    
+    code = Ripper::RubyBuilder.build(src)                 
+    
+    code.inside_block('group', :args => [:test]) do |b|
+      call_node = b.find_call('gem', :args => ['ripper', {:src => 'github'}])
+      assert_equal Ruby::Call, call_node.class
+      b.append_code("gem 'abc'")
+      puts "mutated block:"
+      puts b.to_ruby
+    end       
+  end  
+
+  define_method :"test find gem statement inside group using DSL and then replace symbol argument with hash argument" do                           
+    src = %q{                 
+group :test do
+  gem 'ripper', :src
+end  
+    }
+
+    code = Ripper::RubyBuilder.build(src)                 
+    code.inside_block('group', :args => [:test]) do |b|
+      call_node = b.find_call('gem', :args => ['ripper'])
+      assert_equal Ruby::Call, call_node.class
+      call_node.replace(:arg => :src , :replace_code => "{:src => 'unknown'}")
+      puts b.to_ruby
+    end       
+  end  
+
+  define_method :"test find gem statement inside group using DSL and then replace matching hash with new hash" do                           
+    src = %q{                 
+group :test do
+  gem 'ripper', :src => 'blip'
+end  
+    }
+
+    code = Ripper::RubyBuilder.build(src)                 
+    code.inside_block('group', :args => [:test]) do |b|
+      call_node = b.find_call('gem', :args => ['ripper'])
+      assert_equal Ruby::Call, call_node.class
+      call_node.replace(:arg => {:src => 'blip'} , :replace_code => "{:src => 'unknown'}")
+      puts b.to_ruby
+    end       
+  end  
+   
+  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)
+      call_node = b.find_assignment('my_var')
+      assert_equal Ruby::Assignment, call_node.class
+      
+      call_node.replace(:value => "3")      
+      puts b.to_ruby
+    end
+  end  
+
+  define_method :"test select Class that inherits from other Class and insert new method def" do                           
+    src = %q{      
+      class Monty < Abc::Blip 
+      end 
+    }
+    code = Ripper::RubyBuilder.build(src)              
+    code.find_class('Monty', :superclass => 'Abc::Blip') do |b|
+      assert_equal Ruby::Class, b.class                                  
+      b.append_code("gem 'abc'")   
+      puts b.to_ruby      
+    end
+  end 
+  
+end

data/test/rails_api/gemfile_api.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'yaml'
+
+require 'rails/api_wrapper'
+
+class TraversalTest < Test::Unit::TestCase
+  include TestHelper
+
+  define_method :"test find gem statement inside group using DSL and then insert new gem statement" do                           
+    src = %q{                 
+group :test do
+  gem 'ripper', :src => 'github' 
+  gem 'blip'
+end  
+    }
+    
+    code = Ripper::RubyBuilder.build(src)                 
+
+    code.extend(RubyAPI::Rails::Gemfile)
+    code.inside_group :test do |b|
+      b.add_gem 'cucumber' if !b.find_gem 'cucumber'          
+      b.replace_gem 'blip', 'blap'
+    end
+    puts code.to_ruby
+  end
+end
+

data/test/test_helper.rb

@@ -0,0 +1,53 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'ripper/ruby_builder'
+require 'ruby_traverser'
+require 'ripper/event_log'
+require 'test/unit'
+require 'pp'
+require 'highlighters/ansi'
+
+module TestHelper
+  def build(src, filename = nil)
+    Ripper::RubyBuilder.build(src, filename)
+  end
+
+  def sexp(src)
+    pp Ripper::SexpBuilder.new(src).parse
+  end
+
+	def log(src)
+	  Ripper::EventLog.out(src)
+  end
+
+  def assert_build(src)
+    expr = build(src)
+    assert_equal src, expr.to_ruby(true)
+    assert_equal src, expr.src(true)
+    #   expr.all_nodes.each { |node| assert_equal Ruby::Program, node.root.class }
+    yield(expr) if block_given?
+    expr
+  end
+
+  def assert_node(node, assertions)
+    node = node.first if node.is_a?(Array)
+    assertions.each do |type, value|
+      case type
+      when :is_a
+        assert node.is_a?(value)
+      when :class
+        assert_equal value, node.class
+      when :pos, :position
+        assert_position(value, node)
+      end
+    end
+  end
+
+  def assert_position(position, node)
+    node = node.first if node.is_a?(Array)
+    assert_equal position, node.position.to_a
+  end
+end
+
+
+