synvert-core 0.5.3 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa1fe37f86bbf786414a8e6f5190599bf5ee1e54
-  data.tar.gz: 818ff996234d1fb5400afdd9740c777ee7a3a691
+  metadata.gz: 53fe528849d65b7f8eb9b66f09d247396cfd4e2a
+  data.tar.gz: e7df07ddf60b80af2e487dfeb31caccba9b8d993
 SHA512:
-  metadata.gz: 4f12b89003300b961506a631fadb4981877dd49e012866ca742dc5af0f86a71aa2db00c2835939e21da96c95af55b4f71d2dcda55eb5ebb5b038cb32c158bfdd
-  data.tar.gz: 4efb84e75b9fb0c313596004b757d78cf40356c8aaae3b8a1d470eabd7f9ef4c92f9e856352ec7e1535db3fad8f0322958a245c9580506a710e129bea5a0eaed
+  metadata.gz: 062e20ab65705cb6a0eff85b6c574ae7e50b6add1e5093dbe96423fec012ae87e99217893193f421655d49de323fef7f09d061a8858c40e86acf1933e41aa90f
+  data.tar.gz: 3621636399af83a884659e1ffdf2063b3e4770897b74762095d1929fbca132a82f1a73d16d29d815c060ff49765c20085dc349d3a1bba023e54f06dd00773093

data/CHANGELOG.md

@@ -1,15 +1,11 @@
 # CHANGELOG
 
-## 0.5.3
-
-* Raise RewriterNotFound if rewriter not found
-
-## 0.5.2
+## 0.6.0 (2014-09-01)
 
+* Add goto_node dsl
+* Add ArgumentsNode to handle args both as a node and as an array
 * Add body for :defs node
-
-## 0.5.1
-
+* Raise RewriterNotFound if rewriter not found
 * Remove Rewriter::Instance class methods current and current_source
 
 ## 0.5.0 (2014-08-21)

data/lib/synvert/core/node_ext.rb

@@ -1,386 +1,411 @@
-# Parser::AST::Node monkey patch.
-class Parser::AST::Node
-  # Get name node of :class, :module, :def and :defs node.
-  #
-  # @return [Parser::AST::Node] name node.
-  # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-  def name
-    case self.type
-    when :class, :module, :def
-      self.children[0]
-    when :defs
-      self.children[1]
-    else
-      raise Synvert::Core::MethodNotSupported.new "name is not handled for #{self.inspect}"
+module Parser::AST
+  # ArgumentsNode allows to handle all args as one node or handle all args as an array.
+  class ArgumentsNode
+    # Initialize
+    #
+    # @param node [Parser::AST::Node] args node.
+    def initialize(node)
+      @node = node
     end
-  end
 
-  # Get parent_class node of :class node.
-  #
-  # @return [Parser::AST::Node] parent_class node.
-  # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-  def parent_class
-    if :class == self.type
-      self.children[1]
-    else
-      raise Synvert::Core::MethodNotSupported.new "parent_class is not handled for #{self.inspect}"
+    # If args node responds method itself, call method on args node.
+    # If args children (array) responds method,  call method on args children.
+    # Otherwise raise method missing error.
+    def method_missing(meth, *args, &block)
+      if @node.respond_to?(meth)
+        @node.send meth, *args, &block
+      elsif @node.children.respond_to?(meth)
+        @node.children.send meth, *args, &block
+      else
+        super
+      end
     end
   end
 
-  # Get receiver node of :send node.
-  #
-  # @return [Parser::AST::Node] receiver node.
-  # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-  def receiver
-    if :send == self.type
-      self.children[0]
-    else
-      raise Synvert::Core::MethodNotSupported.new "receiver is not handled for #{self.inspect}"
+  # Parser::AST::Node monkey patch.
+  class Node
+    # Get name node of :class, :module, :def and :defs node.
+    #
+    # @return [Parser::AST::Node] name node.
+    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
+    def name
+      case self.type
+      when :class, :module, :def
+        self.children[0]
+      when :defs
+        self.children[1]
+      else
+        raise Synvert::Core::MethodNotSupported.new "name is not handled for #{self.inspect}"
+      end
     end
-  end
 
-  # Get message node of :send node.
-  #
-  # @return [Parser::AST::Node] mesage node.
-  # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-  def message
-    if :send == self.type
-      self.children[1]
-    else
-      raise Synvert::Core::MethodNotSupported.new "message is not handled for #{self.inspect}"
+    # Get parent_class node of :class node.
+    #
+    # @return [Parser::AST::Node] parent_class node.
+    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
+    def parent_class
+      if :class == self.type
+        self.children[1]
+      else
+        raise Synvert::Core::MethodNotSupported.new "parent_class is not handled for #{self.inspect}"
+      end
     end
-  end
 
-  # Get arguments node of :send, :block or :defined? node.
-  #
-  # @return [Array<Parser::AST::Node>] arguments node.
-  # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-  def arguments
-    case self.type
-    when :send
-      self.children[2..-1]
-    when :block
-      self.children[1].children
-    when :defined?
-      self.children
-    else
-      raise Synvert::Core::MethodNotSupported.new "arguments is not handled for #{self.inspect}"
+    # Get receiver node of :send node.
+    #
+    # @return [Parser::AST::Node] receiver node.
+    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
+    def receiver
+      if :send == self.type
+        self.children[0]
+      else
+        raise Synvert::Core::MethodNotSupported.new "receiver is not handled for #{self.inspect}"
+      end
     end
-  end
 
-  # Get caller node of :block node.
-  #
-  # @return [Parser::AST::Node] caller node.
-  # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-  def caller
-    if :block == self.type
-      self.children[0]
-    else
-      raise Synvert::Core::MethodNotSupported.new "caller is not handled for #{self.inspect}"
+    # Get message node of :send node.
+    #
+    # @return [Parser::AST::Node] mesage node.
+    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
+    def message
+      if :send == self.type
+        self.children[1]
+      else
+        raise Synvert::Core::MethodNotSupported.new "message is not handled for #{self.inspect}"
+      end
     end
-  end
 
-  # Get body node of :begin or :block node.
-  #
-  # @return [Array<Parser::AST::Node>] body node.
-  # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-  def body
-    case self.type
-    when :begin
-      self.children
-    when :def, :block
-      return [] if self.children[2].nil?
-      :begin == self.children[2].type ? self.children[2].body : self.children[2..-1]
-    when :defs
-      return [] if self.children[3].nil?
-      :begin == self.children[3].type ? self.children[3].body : self.children[3..-1]
-    else
-      raise Synvert::Core::MethodNotSupported.new "body is not handled for #{self.inspect}"
+    # Get arguments node of :send, :block or :defined? node.
+    #
+    # @return [Array<Parser::AST::Node>] arguments node.
+    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
+    def arguments
+      case self.type
+      when :send
+        self.children[2..-1]
+      when :block
+        ArgumentsNode.new self.children[1]
+      when :defined?
+        self.children
+      else
+        raise Synvert::Core::MethodNotSupported.new "arguments is not handled for #{self.inspect}"
+      end
     end
-  end
 
-  # Get condition node of :if node.
-  #
-  # @return [Parser::AST::Node] condition node.
-  # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-  def condition
-    if :if == self.type
-      self.children[0]
-    else
-      raise Synvert::Core::MethodNotSupported.new "condition is not handled for #{self.inspect}"
+    # Get caller node of :block node.
+    #
+    # @return [Parser::AST::Node] caller node.
+    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
+    def caller
+      if :block == self.type
+        self.children[0]
+      else
+        raise Synvert::Core::MethodNotSupported.new "caller is not handled for #{self.inspect}"
+      end
     end
-  end
 
-  # Get keys node of :hash node.
-  #
-  # @return [Array<Parser::AST::Node>] keys node.
-  # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-  def keys
-    if :hash == self.type
-      self.children.map { |child| child.children[0] }
-    else
-      raise Synvert::Core::MethodNotSupported.new "keys is not handled for #{self.inspect}"
+    # Get body node of :begin or :block node.
+    #
+    # @return [Array<Parser::AST::Node>] body node.
+    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
+    def body
+      case self.type
+      when :begin
+        self.children
+      when :def, :block
+        return [] if self.children[2].nil?
+        :begin == self.children[2].type ? self.children[2].body : self.children[2..-1]
+      when :defs
+        return [] if self.children[3].nil?
+        :begin == self.children[3].type ? self.children[3].body : self.children[3..-1]
+      else
+        raise Synvert::Core::MethodNotSupported.new "body is not handled for #{self.inspect}"
+      end
     end
-  end
 
-  # Get values node of :hash node.
-  #
-  # @return [Array<Parser::AST::Node>] values node.
-  # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-  def values
-    if :hash == self.type
-      self.children.map { |child| child.children[1] }
-    else
-      raise Synvert::Core::MethodNotSupported.new "keys is not handled for #{self.inspect}"
+    # Get condition node of :if node.
+    #
+    # @return [Parser::AST::Node] condition node.
+    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
+    def condition
+      if :if == self.type
+        self.children[0]
+      else
+        raise Synvert::Core::MethodNotSupported.new "condition is not handled for #{self.inspect}"
+      end
     end
-  end
 
-  # Test if hash node contains specified key.
-  #
-  # @param [Object] key value.
-  # @return [Boolean] true if specified key exists.
-  # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-  def has_key?(key)
-    if :hash == self.type
-      self.children.any? { |pair_node| pair_node.key.to_value == key }
-    else
-      raise Synvert::Core::MethodNotSupported.new "has_key? is not handled for #{self.inspect}"
+    # Get keys node of :hash node.
+    #
+    # @return [Array<Parser::AST::Node>] keys node.
+    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
+    def keys
+      if :hash == self.type
+        self.children.map { |child| child.children[0] }
+      else
+        raise Synvert::Core::MethodNotSupported.new "keys is not handled for #{self.inspect}"
+      end
     end
-  end
 
-  # Get hash value node according to specified key.
-  #
-  # @param [Object] key value.
-  # @return [Parser::AST::Node] value node.
-  # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-  def hash_value(key)
-    if :hash == self.type
-      value_node = self.children.find { |pair_node| pair_node.key.to_value == key }
-      value_node ? value_node.value : nil
-    else
-      raise Synvert::Core::MethodNotSupported.new "has_key? is not handled for #{self.inspect}"
+    # Get values node of :hash node.
+    #
+    # @return [Array<Parser::AST::Node>] values node.
+    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
+    def values
+      if :hash == self.type
+        self.children.map { |child| child.children[1] }
+      else
+        raise Synvert::Core::MethodNotSupported.new "keys is not handled for #{self.inspect}"
+      end
     end
-  end
 
-  # Get key node of hash :pair node.
-  #
-  # @return [Parser::AST::Node] key node.
-  # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-  def key
-    if :pair == self.type
-      self.children.first
-    else
-      raise Synvert::Core::MethodNotSupported.new "key is not handled for #{self.inspect}"
+    # Test if hash node contains specified key.
+    #
+    # @param [Object] key value.
+    # @return [Boolean] true if specified key exists.
+    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
+    def has_key?(key)
+      if :hash == self.type
+        self.children.any? { |pair_node| pair_node.key.to_value == key }
+      else
+        raise Synvert::Core::MethodNotSupported.new "has_key? is not handled for #{self.inspect}"
+      end
     end
-  end
 
-  # Get value node of hash :pair node.
-  #
-  # @return [Parser::AST::Node] value node.
-  # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-  def value
-    if :pair == self.type
-      self.children.last
-    else
-      raise Synvert::Core::MethodNotSupported.new "value is not handled for #{self.inspect}"
+    # Get hash value node according to specified key.
+    #
+    # @param [Object] key value.
+    # @return [Parser::AST::Node] value node.
+    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
+    def hash_value(key)
+      if :hash == self.type
+        value_node = self.children.find { |pair_node| pair_node.key.to_value == key }
+        value_node ? value_node.value : nil
+      else
+        raise Synvert::Core::MethodNotSupported.new "has_key? is not handled for #{self.inspect}"
+      end
     end
-  end
 
-  # Return the exact value.
-  #
-  # @return [Object] exact value.
-  # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-  def to_value
-    case self.type
-    when :int, :str, :sym
-      self.children.last
-    when :true
-      true
-    when :false
-      false
-    when :array
-      self.children.map(&:to_value)
-    when :irange
-      (self.children.first.to_value..self.children.last.to_value)
-    when :begin
-      self.children.first.to_value
-    else
-      raise Synvert::Core::MethodNotSupported.new "to_value is not handled for #{self.inspect}"
+    # Get key node of hash :pair node.
+    #
+    # @return [Parser::AST::Node] key node.
+    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
+    def key
+      if :pair == self.type
+        self.children.first
+      else
+        raise Synvert::Core::MethodNotSupported.new "key is not handled for #{self.inspect}"
+      end
+    end
+
+    # Get value node of hash :pair node.
+    #
+    # @return [Parser::AST::Node] value node.
+    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
+    def value
+      if :pair == self.type
+        self.children.last
+      else
+        raise Synvert::Core::MethodNotSupported.new "value is not handled for #{self.inspect}"
+      end
     end
-  end
 
-  # Get the source code of current node.
-  #
-  # @return [String] source code.
-  def to_source
-    if self.loc.expression
-      self.loc.expression.source
+    # Return the exact value.
+    #
+    # @return [Object] exact value.
+    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
+    def to_value
+      case self.type
+      when :int, :str, :sym
+        self.children.last
+      when :true
+        true
+      when :false
+        false
+      when :array
+        self.children.map(&:to_value)
+      when :irange
+        (self.children.first.to_value..self.children.last.to_value)
+      when :begin
+        self.children.first.to_value
+      else
+        raise Synvert::Core::MethodNotSupported.new "to_value is not handled for #{self.inspect}"
+      end
     end
-  end
 
-  # Get the indent of current node.
-  #
-  # @return [Integer] indent.
-  def indent
-    self.loc.expression.column
-  end
+    # Get the source code of current node.
+    #
+    # @return [String] source code.
+    def to_source
+      if self.loc.expression
+        self.loc.expression.source
+      end
+    end
 
-  # Recursively iterate all child nodes of current node.
-  #
-  # @yield [child] Gives a child node.
-  # @yieldparam child [Parser::AST::Node] child node
-  def recursive_children
-    self.children.each do |child|
-      if Parser::AST::Node === child
-        yield child
-        child.recursive_children { |c| yield c }
+    # Get the indent of current node.
+    #
+    # @return [Integer] indent.
+    def indent
+      self.loc.expression.column
+    end
+
+    # Recursively iterate all child nodes of current node.
+    #
+    # @yield [child] Gives a child node.
+    # @yieldparam child [Parser::AST::Node] child node
+    def recursive_children
+      self.children.each do |child|
+        if Parser::AST::Node === child
+          yield child
+          child.recursive_children { |c| yield c }
+        end
       end
     end
-  end
 
-  # Match current node with rules.
-  #
-  # @param rules [Hash] rules to match.
-  # @return true if matches.
-  def match?(rules)
-    flat_hash(rules).keys.all? do |multi_keys|
-      if multi_keys.last == :any
-        actual_values = actual_value(self, multi_keys[0...-1])
-        expected = expected_value(rules, multi_keys)
-        actual_values.any? { |actual| match_value?(actual, expected) }
-      elsif multi_keys.last == :not
-        actual = actual_value(self, multi_keys[0...-1])
-        expected = expected_value(rules, multi_keys)
-        !match_value?(actual, expected)
-      else
-        actual = actual_value(self, multi_keys)
-        expected = expected_value(rules, multi_keys)
-        match_value?(actual, expected)
+    # Match current node with rules.
+    #
+    # @param rules [Hash] rules to match.
+    # @return true if matches.
+    def match?(rules)
+      flat_hash(rules).keys.all? do |multi_keys|
+        if multi_keys.last == :any
+          actual_values = actual_value(self, multi_keys[0...-1])
+          expected = expected_value(rules, multi_keys)
+          actual_values.any? { |actual| match_value?(actual, expected) }
+        elsif multi_keys.last == :not
+          actual = actual_value(self, multi_keys[0...-1])
+          expected = expected_value(rules, multi_keys)
+          !match_value?(actual, expected)
+        else
+          actual = actual_value(self, multi_keys)
+          expected = expected_value(rules, multi_keys)
+          match_value?(actual, expected)
+        end
       end
     end
-  end
 
-  # Get rewritten source code.
-  # @example
-  #   node.rewritten_source("create({{arguments}})") #=> "create(:post)"
-  #
-  # @param code [String] raw code.
-  # @return [String] rewritten code, replace string in block {{ }} in raw code.
-  # @raise [Synvert::Core::MethodNotSupported] if string in block {{ }} does not support.
-  def rewritten_source(code)
-    code.gsub(/{{(.*?)}}/m) do
-      old_code = $1
-      if self.respond_to? old_code.split(/\.|\[/).first
-        evaluated = self.instance_eval old_code
-        case evaluated
-        when Parser::AST::Node
-          evaluated.loc.expression.source
-        when Array
-          if evaluated.size > 0
-            source = evaluated.first.loc.expression.source_buffer.source
-            source[evaluated.first.loc.expression.begin_pos...evaluated.last.loc.expression.end_pos]
+    # Get rewritten source code.
+    # @example
+    #   node.rewritten_source("create({{arguments}})") #=> "create(:post)"
+    #
+    # @param code [String] raw code.
+    # @return [String] rewritten code, replace string in block {{ }} in raw code.
+    # @raise [Synvert::Core::MethodNotSupported] if string in block {{ }} does not support.
+    def rewritten_source(code)
+      code.gsub(/{{(.*?)}}/m) do
+        old_code = $1
+        if self.respond_to? old_code.split(/\.|\[/).first
+          evaluated = self.instance_eval old_code
+          case evaluated
+          when Parser::AST::Node
+            evaluated.loc.expression.source
+          when Array
+            if evaluated.size > 0
+              source = evaluated.first.loc.expression.source_buffer.source
+              source[evaluated.first.loc.expression.begin_pos...evaluated.last.loc.expression.end_pos]
+            end
+          when String, Symbol
+            evaluated
+          when NilClass
+            'nil'
+          else
+            raise Synvert::Core::MethodNotSupported.new "rewritten_source is not handled for #{evaluated.inspect}"
           end
-        when String, Symbol
-          evaluated
-        when NilClass
-          'nil'
         else
-          raise Synvert::Core::MethodNotSupported.new "rewritten_source is not handled for #{evaluated.inspect}"
+          "{{#{old_code}}}"
         end
-      else
-        "{{#{old_code}}}"
       end
     end
-  end
 
-private
+  private
 
-  # Compare actual value with expected value.
-  #
-  # @param actual [Object] actual value.
-  # @param expected [Object] expected value.
-  # @return [Integer] -1, 0 or 1.
-  # @raise [Synvert::Core::MethodNotSupported] if expected class is not supported.
-  def match_value?(actual, expected)
-    case expected
-    when Symbol
-      if Parser::AST::Node === actual
-        actual.to_source == ":#{expected}"
-      else
-        actual.to_sym == expected
-      end
-    when String
-      if Parser::AST::Node === actual
-        actual.to_source == expected || actual.to_source[1...-1] == expected
-      else
-        actual.to_s == expected
-      end
-    when Regexp
-      if Parser::AST::Node === actual
-        actual.to_source =~ Regexp.new(expected.to_s, Regexp::MULTILINE)
-      else
-        actual.to_s =~ Regexp.new(expected.to_s, Regexp::MULTILINE)
-      end
-    when Array
-      return false unless expected.length == actual.length
-      actual.zip(expected).all? { |a, e| match_value?(a, e) }
-    when NilClass
-      actual.nil?
-    when Numeric
-      if Parser::AST::Node === actual
-        actual.children[0] == expected
-      else
+    # Compare actual value with expected value.
+    #
+    # @param actual [Object] actual value.
+    # @param expected [Object] expected value.
+    # @return [Integer] -1, 0 or 1.
+    # @raise [Synvert::Core::MethodNotSupported] if expected class is not supported.
+    def match_value?(actual, expected)
+      case expected
+      when Symbol
+        if Parser::AST::Node === actual
+          actual.to_source == ":#{expected}"
+        else
+          actual.to_sym == expected
+        end
+      when String
+        if Parser::AST::Node === actual
+          actual.to_source == expected || actual.to_source[1...-1] == expected
+        else
+          actual.to_s == expected
+        end
+      when Regexp
+        if Parser::AST::Node === actual
+          actual.to_source =~ Regexp.new(expected.to_s, Regexp::MULTILINE)
+        else
+          actual.to_s =~ Regexp.new(expected.to_s, Regexp::MULTILINE)
+        end
+      when Array
+        return false unless expected.length == actual.length
+        actual.zip(expected).all? { |a, e| match_value?(a, e) }
+      when NilClass
+        actual.nil?
+      when Numeric
+        if Parser::AST::Node === actual
+          actual.children[0] == expected
+        else
+          actual == expected
+        end
+      when TrueClass
+        :true == actual.type
+      when FalseClass
+        :false == actual.type
+      when Parser::AST::Node
         actual == expected
+      else
+        raise Synvert::Core::MethodNotSupported.new "#{expected.class} is not handled for match_value?"
       end
-    when TrueClass
-      :true == actual.type
-    when FalseClass
-      :false == actual.type
-    when Parser::AST::Node
-      actual == expected
-    else
-      raise Synvert::Core::MethodNotSupported.new "#{expected.class} is not handled for match_value?"
     end
-  end
 
-  # Convert a hash to flat one.
-  #
-  # @example
-  #   flat_hash(type: 'block', caller: {type: 'send', receiver: 'RSpec'})
-  #     #=> {[:type] => 'block', [:caller, :type] => 'send', [:caller, :receiver] => 'RSpec'}
-  # @param h [Hash] original hash.
-  # @return flatten hash.
-  def flat_hash(h, k = [])
-    new_hash = {}
-    h.each_pair do |key, val|
-      if val.is_a?(Hash)
-        new_hash.merge!(flat_hash(val, k + [key]))
-      else
-        new_hash[k + [key]] = val
+    # Convert a hash to flat one.
+    #
+    # @example
+    #   flat_hash(type: 'block', caller: {type: 'send', receiver: 'RSpec'})
+    #     #=> {[:type] => 'block', [:caller, :type] => 'send', [:caller, :receiver] => 'RSpec'}
+    # @param h [Hash] original hash.
+    # @return flatten hash.
+    def flat_hash(h, k = [])
+      new_hash = {}
+      h.each_pair do |key, val|
+        if val.is_a?(Hash)
+          new_hash.merge!(flat_hash(val, k + [key]))
+        else
+          new_hash[k + [key]] = val
+        end
       end
+      new_hash
     end
-    new_hash
-  end
 
-  # Get actual value from the node.
-  #
-  # @param node [Parser::AST::Node]
-  # @param multi_keys [Array<Symbol>]
-  # @return [Object] actual value.
-  def actual_value(node, multi_keys)
-    multi_keys.inject(node) { |n, key|
-      if n
-        key == :source ? n.send(key) : n.send(key)
-      end
-    }
-  end
+    # Get actual value from the node.
+    #
+    # @param node [Parser::AST::Node]
+    # @param multi_keys [Array<Symbol>]
+    # @return [Object] actual value.
+    def actual_value(node, multi_keys)
+      multi_keys.inject(node) { |n, key|
+        if n
+          key == :source ? n.send(key) : n.send(key)
+        end
+      }
+    end
 
-  # Get expected value from rules.
-  #
-  # @param rules [Hash]
-  # @param multi_keys [Array<Symbol>]
-  # @return [Object] expected value.
-  def expected_value(rules, multi_keys)
-    multi_keys.inject(rules) { |o, key| o[key] }
+    # Get expected value from rules.
+    #
+    # @param rules [Hash]
+    # @param multi_keys [Array<Symbol>]
+    # @return [Object] expected value.
+    def expected_value(rules, multi_keys)
+      multi_keys.inject(rules) { |o, key| o[key] }
+    end
   end
 end

data/lib/synvert/core/rewriter.rb

@@ -29,6 +29,8 @@ module Synvert::Core
     autoload :Instance, 'synvert/core/rewriter/instance'
 
     autoload :Scope, 'synvert/core/rewriter/scope'
+    autoload :WithinScope, 'synvert/core/rewriter/scope'
+    autoload :GotoScope, 'synvert/core/rewriter/scope'
 
     autoload :Condition, 'synvert/core/rewriter/condition'
     autoload :IfExistCondition, 'synvert/core/rewriter/condition'

data/lib/synvert/core/rewriter/instance.rb

@@ -123,13 +123,22 @@ module Synvert::Core
     # DSL #
     #######
 
-    # Parse within_node dsl, it creates a [Synvert::Core::Rewriter::Scope] to find matching ast nodes,
+    # Parse within_node dsl, it creates a [Synvert::Core::Rewriter::WithinScope] to find matching ast nodes,
     # then continue operating on each matching ast node.
     #
     # @param rules [Hash] rules to find mathing ast nodes.
     # @param block [Block] block code to continue operating on the matching nodes.
     def within_node(rules, &block)
-      Rewriter::Scope.new(self, rules, &block).process
+      Rewriter::WithinScope.new(self, rules, &block).process
+    end
+
+    # Parse goto_node dsl, it creates a [Synvert::Core::Rewriter::GotoScope] to go to a child node,
+    # then continue operating on the child node.
+    #
+    # @param child_node_name [String] the name of the child node.
+    # @param block [Block] block code to continue operating on the matching nodes.
+    def goto_node(child_node_name, &block)
+      Rewriter::GotoScope.new(self, child_node_name, &block).process
     end
 
     alias with_node within_node

data/lib/synvert/core/rewriter/scope.rb

@@ -1,8 +1,12 @@
 # encoding: utf-8
 
 module Synvert::Core
-  # Scope finds the child nodes which match rules.
+  # Scope finds out nodes which match rules.
   class Rewriter::Scope
+  end
+
+  # WithinScope finds out nodes which match rules, then change its scope to matching node.
+  class Rewriter::WithinScope < Rewriter::Scope
     # Initialize a scope
     #
     # @param instance [Synvert::Core::Rewriter::Instance]
@@ -14,8 +18,8 @@ module Synvert::Core
       @block = block
     end
 
-    # Find the matching nodes. It checks the current node and iterates all child nodes,
-    # then run the block code for each matching node.
+    # Find out the matching nodes. It checks the current node and iterates all child nodes,
+    # then run the block code with each matching node.
     def process
       current_node = @instance.current_node
       return unless current_node
@@ -33,4 +37,28 @@ module Synvert::Core
       end
     end
   end
+
+  # Go to and change its scope to a child node.
+  class Rewriter::GotoScope < Rewriter::Scope
+    # Initialize a scope
+    #
+    # @param instance [Synvert::Core::Rewriter::Instance]
+    # @param child_node_name [String]
+    # @param block [Block]
+    def initialize(instance, child_node_name, &block)
+      @instance = instance
+      @child_node_name = child_node_name
+      @block = block
+    end
+
+    # Go to a child now, then run the block code with the the child node.
+    def process
+      current_node = @instance.current_node
+      return unless current_node
+      child_node = current_node.send @child_node_name
+      @instance.process_with_other_node child_node do
+        @instance.instance_eval &@block
+      end
+    end
+  end
 end

data/lib/synvert/core/version.rb

@@ -2,6 +2,6 @@
 
 module Synvert
   module Core
-    VERSION = "0.5.3"
+    VERSION = "0.6.0"
   end
 end

data/spec/synvert/core/rewriter/instance_spec.rb

@@ -12,7 +12,7 @@ module Synvert::Core
     it 'parses within_node' do
       scope = double()
       block = Proc.new {}
-      expect(Rewriter::Scope).to receive(:new).with(instance, type: 'send', message: 'create', &block).and_return(scope)
+      expect(Rewriter::WithinScope).to receive(:new).with(instance, type: 'send', message: 'create', &block).and_return(scope)
       expect(scope).to receive(:process)
       instance.within_node(type: 'send', message: 'create', &block)
     end
@@ -20,11 +20,19 @@ module Synvert::Core
     it 'parses with_node' do
       scope = double()
       block = Proc.new {}
-      expect(Rewriter::Scope).to receive(:new).with(instance, type: 'send', message: 'create', &block).and_return(scope)
+      expect(Rewriter::WithinScope).to receive(:new).with(instance, type: 'send', message: 'create', &block).and_return(scope)
       expect(scope).to receive(:process)
       instance.with_node(type: 'send', message: 'create', &block)
     end
 
+    it 'parses goto_node' do
+      scope = double()
+      block = Proc.new {}
+      expect(Rewriter::GotoScope).to receive(:new).with(instance, :caller, &block).and_return(scope)
+      expect(scope).to receive(:process)
+      instance.goto_node(:caller, &block)
+    end
+
     it 'parses if_exist_node' do
       condition = double()
       block = Proc.new {}

data/spec/synvert/core/rewriter/scope_spec.rb

@@ -1,29 +1,28 @@
 require 'spec_helper'
 
 module Synvert::Core
-  describe Rewriter::Scope do
-    let(:source) {
-"""
+  describe Rewriter::WithinScope do
+    let(:instance) {
+      rewriter = Rewriter.new('foo', 'bar')
+      Rewriter::Instance.new(rewriter, 'file pattern')
+    }
+    let(:source) {"""
 describe Post do
-  before :each do
-    @user = FactoryGirl.create :user
-  end
-
-  it 'gets posts' do
-    post1 = FactoryGirl.create :post
-    post2 = FactoryGirl.create :post
+  it 'gets post' do
+    FactoryGirl.create :post
   end
 end
-"""
-    }
+    """}
     let(:node) { Parser::CurrentRuby.parse(source) }
-    let(:instance) { double(:current_node => node, :current_node= => node) }
-    before { allow(instance).to receive(:process_with_node).and_yield }
+    before do
+      Rewriter::Instance.reset
+      instance.current_node = node
+    end
 
     describe '#process' do
       it 'not call block if no matching node' do
         run = false
-        scope = Rewriter::Scope.new instance, type: 'send', message: 'missing' do
+        scope = Rewriter::WithinScope.new instance, type: 'send', message: 'missing' do
           run = true
         end
         scope.process
@@ -32,11 +31,46 @@ end
 
       it 'call block if there is matching node' do
         run = false
-        scope = Rewriter::Scope.new instance, type: 'send', receiver: 'FactoryGirl', message: 'create', arguments: [':post'] do
+        type_in_scope = nil
+        scope = Rewriter::WithinScope.new instance, type: 'send', receiver: 'FactoryGirl', message: 'create', arguments: [':post'] do
+          run = true
+          type_in_scope = node.type
+        end
+        scope.process
+        expect(run).to be_truthy
+        expect(type_in_scope).to eq :send
+        expect(instance.current_node.type).to eq :block
+      end
+    end
+  end
+
+  describe Rewriter::GotoScope do
+    let(:instance) {
+      rewriter = Rewriter.new('foo', 'bar')
+      Rewriter::Instance.new(rewriter, 'file pattern')
+    }
+    let(:source) {'''
+Factory.define :user do |user|
+end
+    '''}
+    let(:node) { Parser::CurrentRuby.parse(source) }
+    before do
+      Rewriter::Instance.reset
+      instance.current_node = node
+    end
+
+    describe '#process' do
+      it 'call block with child node' do
+        run = false
+        type_in_scope = nil
+        scope = Rewriter::GotoScope.new instance, :caller do
           run = true
+          type_in_scope = node.type
         end
         scope.process
         expect(run).to be_truthy
+        expect(type_in_scope).to eq :send
+        expect(instance.current_node.type).to eq :block
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: synvert-core
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.6.0
 platform: ruby
 authors:
 - Richard Huang
@@ -176,3 +176,4 @@ test_files:
 - spec/synvert/core/rewriter/scope_spec.rb
 - spec/synvert/core/rewriter/warning_spec.rb
 - spec/synvert/core/rewriter_spec.rb
+has_rdoc: