synvert 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ee5d52cf95df07b26f5bb50cbee385209ce3b59d
-  data.tar.gz: b077dd95e2e34be6c39af959ca9d9a7fc3352ecb
+  metadata.gz: a16d51a6f5e6376390a8d50951f1adaca53f6737
+  data.tar.gz: 295744d184ca5bbea1cf1faa0fef5428aeb8a402
 SHA512:
-  metadata.gz: e3b9411dc8752fada8cd1a86eebb995d38e82fcdcc4169f6ef69941b743bbb025c3bf2e29015af3827f6d9116e7564b235f6d32ced48728ad30762e8380e389d
-  data.tar.gz: 372f93f527fa4d6a22c07f5b8c1bca2b178d9589df2155f1ec67b67486ea8abacd47a269ffecc9dbe931d2a45f56df2c2532fae4f2c2f78ade50cc18bbc49b5e
+  metadata.gz: 259cbde5e5e77897abcf7f7c3c0557f9ecfe13ce4ba0638035dbf96147c536465818044cdaa10cc648bd487bf54806aca1c8d1208a358c6a4d530ef8c56892c8
+  data.tar.gz: 52fc74d210b5236e2cccb196d460a485421c99f47d7d825b86d86edb4f6813195cea04b5bd1b5a3ae8ecd2dd6e59fb9250aef407266b12ed0952968d2be8affd

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # CHANGELOG
 
+## 0.0.4
+
+* Test snippets
+* Lazily execute blocks that allows executing any ruby code
+* Be able to save parsed data and use them later
+
 ## 0.0.3
 
 * Add snippet to upgrade rails 3.2 to rails 4.0

data/lib/synvert.rb

@@ -4,6 +4,7 @@ require 'bundler'
 require 'parser'
 require 'parser/current'
 require 'ast'
+require 'active_support/inflector'
 require 'synvert/node_ext'
 
 module Synvert

data/lib/synvert/node_ext.rb

@@ -1,6 +1,6 @@
 class Parser::AST::Node
   def name
-    if :class == self.type
+    if [:class, :def].include? self.type
       self.children[0]
     else
       raise NotImplementedError.new "name is not handled for #{self.inspect}"
@@ -60,25 +60,9 @@ class Parser::AST::Node
     end
   end
 
-  def to_ast
-    self
-  end
-
-  def to_s
-    case self.type
-    when :const
-      self.children.compact.map(&:to_s).join('::')
-    when :sym
-      ':' + self.children[0].to_s
-    when :str
-      "'" + self.children[0].to_s + "'"
-    when :arg, :lvar, :ivar
-      self.children[0].to_s
-    when :self
-      'self'
-    when :send
-      self.children[1].to_s
-    else
+  def source(instance)
+    if self.loc.expression
+      instance.current_source[self.loc.expression.begin_pos...self.loc.expression.end_pos]
     end
   end
 
@@ -101,21 +85,21 @@ class Parser::AST::Node
     end
   end
 
-  def match?(options)
+  def match?(instance, options)
     flat_hash(options).keys.all? do |multi_keys|
       if multi_keys.last == :any
-        actual_values = actual_value(self, multi_keys[0...-1])
+        actual_values = actual_value(self, instance, multi_keys[0...-1])
         expected = expected_value(options, multi_keys)
-        actual_values.any? { |actual| match_value?(actual, expected) }
+        actual_values.any? { |actual| match_value?(instance, actual, expected) }
       else
-        actual = actual_value(self, multi_keys)
+        actual = actual_value(self, instance, multi_keys)
         expected = expected_value(options, multi_keys)
-        match_value?(actual, expected)
+        match_value?(instance, actual, expected)
       end
     end
   end
 
-  def to_source(code)
+  def rewritten_source(code)
     code.gsub(/{{(.*?)}}/m) do
       evaluated = self.instance_eval $1
       case evaluated
@@ -128,23 +112,31 @@ class Parser::AST::Node
       when String
         evaluated
       else
-        raise NotImplementedError.new "to_source is not handled for #{evaluated.inspect}"
+        raise NotImplementedError.new "rewritten_source is not handled for #{evaluated.inspect}"
       end
     end
   end
 
 private
 
-  def match_value?(actual, expected)
+  def match_value?(instance, actual, expected)
     case expected
     when Symbol
       actual.to_sym == expected
     when String
-      actual.to_s == expected || actual.to_s == "'#{expected}'"
+      if Parser::AST::Node === actual
+        actual.source(instance) == expected
+      else
+        actual.to_s == expected
+      end
     when Regexp
-      actual.to_s =~ Regexp.new(expected.to_s, Regexp::MULTILINE)
+      if Parser::AST::Node === actual
+        actual.source(instance) =~ Regexp.new(expected.to_s, Regexp::MULTILINE)
+      else
+        actual.to_s =~ Regexp.new(expected.to_s, Regexp::MULTILINE)
+      end
     when Array
-      actual.zip(expected).all? { |a, e| match_value?(a, e) }
+      actual.zip(expected).all? { |a, e| match_value?(instance, a, e) }
     when NilClass
       actual.nil?
     when Parser::AST::Node
@@ -166,8 +158,12 @@ private
     new_hash
   end
 
-  def actual_value(node, multi_keys)
-    multi_keys.inject(node) { |n, key| n.send(key) if n }
+  def actual_value(node, instance, multi_keys)
+    multi_keys.inject(node) { |n, key|
+      if n
+        key == :source ? n.send(key, instance) : n.send(key)
+      end
+    }
   end
 
   def expected_value(options, multi_keys)

data/lib/synvert/rewriter.rb

@@ -1,6 +1,7 @@
 module Synvert
   class Rewriter
     autoload :Action, 'synvert/rewriter/action'
+    autoload :AppendAction, 'synvert/rewriter/action'
     autoload :InsertAction, 'synvert/rewriter/action'
     autoload :InsertAfterAction, 'synvert/rewriter/action'
     autoload :ReplaceWithAction, 'synvert/rewriter/action'
@@ -20,14 +21,21 @@ module Synvert
 
     def initialize(description, &block)
       @description = description
-      @instances = []
-      instance_eval &block if block_given?
+      @block = block
+      @assignments = {}
+    end
+
+    def set(name, key, value)
+      @assignments[name] ||= {}
+      @assignments[name][key] = value
+    end
+
+    def get(name, key)
+      @assignments[name] and @assignments[name][key]
     end
 
     def process
-      if @gem_spec.match?
-        @instances.each { |instance| instance.process }
-      end
+      self.instance_eval &@block
     end
 
     def gem_spec(name, version)
@@ -35,9 +43,9 @@ module Synvert
     end
 
     def within_file(file_pattern, &block)
-      instance = Rewriter::Instance.new(file_pattern)
-      instance.instance_eval &block if block_given?
-      @instances << instance
+      if @gem_spec.match?
+        Rewriter::Instance.new(self, file_pattern, &block).process
+      end
     end
 
     alias within_files within_file

data/lib/synvert/rewriter/action.rb

@@ -2,42 +2,92 @@
 
 module Synvert
   class Rewriter::Action
-    def initialize(code)
+    def initialize(instance, code)
+      @instance = instance
       @code = code
+      @node = @instance.current_node
     end
 
-    def rewrite(source, node)
-      raise NotImplementedError.new 'rewrite method is not implemented'
+    def line
+      @node.loc.expression.line
+    end
+
+    def rewritten_code
+      if rewritten_source.split("\n").length > 1
+        "\n\n" + rewritten_source.split("\n").map { |line|
+          indent(@node) + line
+        }.join("\n")
+      else
+        "\n" + indent(@node) + rewritten_source
+      end
+    end
+
+    def rewritten_source
+      @rewritten_source ||= @node.rewritten_source(@code)
+    end
+
+    def <=>(action)
+      self.begin_pos <=> action.begin_pos
     end
   end
 
   class Rewriter::ReplaceWithAction < Rewriter::Action
-    def rewrite(source, node)
-      begin_pos = node.loc.expression.begin_pos
-      end_pos = node.loc.expression.end_pos
-      source[begin_pos...end_pos] = node.to_source(@code)
-      source
+    def begin_pos
+      @node.loc.expression.begin_pos
+    end
+
+    def end_pos
+      @node.loc.expression.end_pos
+    end
+
+    def rewritten_code
+      @node.rewritten_source(@code)
+    end
+  end
+
+  class Rewriter::AppendAction < Rewriter::Action
+    def begin_pos
+      @node.loc.expression.end_pos - 4
+    end
+
+    def end_pos
+      begin_pos
+    end
+
+  private
+
+    def indent(node)
+      if [:block, :class].include? node.type
+        ' ' * (node.indent + 2)
+      else
+        ' ' * node.indent
+      end
     end
   end
 
   class Rewriter::InsertAction < Rewriter::Action
-    def rewrite(source, node)
-      source[insert_position(node), 0] = "\n" + insert_indent(node) + node.to_source(@code)
-      source
+    def begin_pos
+      insert_position(@node)
+    end
+
+    def end_pos
+      begin_pos
     end
 
+  private
+
     def insert_position(node)
       case node.type
       when :block
-        node.children[1].loc.expression.end_pos
+        node.children[1].children.empty? ? node.children[0].loc.expression.end_pos + 3 : node.children[1].loc.expression.end_pos
       when :class
-        node.children[0].loc.expression.end_pos
+        node.children[1] ? node.children[1].loc.expression.end_pos : node.children[0].loc.expression.end_pos
       else
         node.children.last.loc.expression.end_pos
       end
     end
 
-    def insert_indent(node)
+    def indent(node)
       if [:block, :class].include? node.type
         ' ' * (node.indent + 2)
       else
@@ -47,38 +97,36 @@ module Synvert
   end
 
   class Rewriter::InsertAfterAction < Rewriter::Action
-    def rewrite(source, node)
-      source[node.loc.expression.end_pos, 0] = "\n" + insert_indent(node) + node.to_source(@code)
-      source
+    def begin_pos
+      @node.loc.expression.end_pos
     end
 
-    def insert_indent(node)
+    def end_pos
+      begin_pos
+    end
+
+  private
+
+    def indent(node)
       ' ' * node.indent
     end
   end
 
   class Rewriter::RemoveAction < Rewriter::Action
-    def initialize
+    def initialize(instance, code=nil)
+      super
     end
 
-    def rewrite(source, node)
-      begin_pos = node.loc.expression.begin_pos
-      end_pos = node.loc.expression.end_pos
-      line = node.loc.expression.line
-      source[begin_pos...end_pos] = ''
-      remove_code_or_whole_line(source, line)
+    def begin_pos
+      @node.loc.expression.begin_pos
     end
 
-  private
-    def remove_code_or_whole_line(source, line)
-      newline_at_end_of_line = source[-1] == "\n"
-      source_arr = source.split("\n")
-      if source_arr[line - 1] && source_arr[line - 1].strip.empty?
-        source_arr.delete_at(line - 1)
-        source_arr.join("\n") + (newline_at_end_of_line ? "\n" : '')
-      else
-        source
-      end
+    def end_pos
+      @node.loc.expression.end_pos
+    end
+
+    def rewritten_code
+      ''
     end
   end
 end

data/lib/synvert/rewriter/condition.rb

@@ -2,28 +2,31 @@
 
 module Synvert
   class Rewriter::Condition
-    def initialize(options)
+    def initialize(instance, options, &block)
+      @instance = instance
       @options = options
+      @block = block
+    end
+
+    def process
+      @instance.instance_eval &@block if match?
     end
   end
 
   class Rewriter::UnlessExistCondition < Rewriter::Condition
-    def matching_nodes(nodes)
-      nodes.find_all { |node|
-        match = false
-        node.recursive_children do |child_node|
-          match = match || (child_node && child_node.match?(@options))
-        end
-        !match
-      }
+    def match?
+      match = false
+      @instance.current_node.recursive_children do |child_node|
+        match = match || (child_node && child_node.match?(@instance, @options))
+      end
+      !match
     end
   end
 
   class Rewriter::IfOnlyExistCondition < Rewriter::Condition
-    def matching_nodes(nodes)
-      nodes.find_all { |node|
-        :begin != node.body.type && node.body.match?(@options)
-      }
+    def match?
+      :begin != @instance.current_node.body.type &&
+        @instance.current_node.body.match?(@instance, @options)
     end
   end
 end

data/lib/synvert/rewriter/instance.rb

@@ -2,64 +2,102 @@
 
 module Synvert
   class Rewriter::Instance
-    def initialize(file_pattern)
+    attr_accessor :current_node, :current_source, :current_file
+
+    def initialize(rewriter, file_pattern, &block)
+      @rewriter = rewriter
+      @actions = []
       @file_pattern = file_pattern
-      @scopes_or_conditions = []
+      @block = block
     end
 
     def process
       parser = Parser::CurrentRuby.new
       file_pattern = File.join(Configuration.instance.get(:path), @file_pattern)
-      Dir.glob(file_pattern).each do |path|
-        source = File.read(path)
-        buffer = Parser::Source::Buffer.new path
+      Dir.glob(file_pattern).each do |file_path|
+        source = File.read(file_path)
+        buffer = Parser::Source::Buffer.new file_path
         buffer.source = source
 
         parser.reset
         ast = parser.parse buffer
 
-        matching_nodes = [ast]
-        @scopes_or_conditions.each do |scope_or_condition|
-          matching_nodes = scope_or_condition.matching_nodes(matching_nodes)
-        end
-        matching_nodes.reverse.each do |node|
-          source = @action.rewrite(source, node)
+        @current_file = file_path
+        @current_source = source
+        @current_node = ast
+        instance_eval &@block
+        @current_node = ast
+
+        @actions.sort.reverse.each do |action|
+          source[action.begin_pos...action.end_pos] = action.rewritten_code
+          source = remove_code_or_whole_line(source, action.line)
         end
-        File.write path, source
+        @actions = []
+
+        File.write file_path, source
       end
     end
 
+    def node
+      @current_node
+    end
+
     def within_node(options, &block)
-      @scopes_or_conditions << Rewriter::Scope.new(options)
-      instance_eval &block if block_given?
+      Rewriter::Scope.new(self, options, &block).process
     end
 
     alias with_node within_node
 
     def unless_exist_node(options, &block)
-      @scopes_or_conditions << Rewriter::UnlessExistCondition.new(options)
-      instance_eval &block if block_given?
+      Rewriter::UnlessExistCondition.new(self, options, &block).process
     end
 
     def if_only_exist_node(options, &block)
-      @scopes_or_conditions << Rewriter::IfOnlyExistCondition.new(options)
-      instance_eval &block if block_given?
+      Rewriter::IfOnlyExistCondition.new(self, options, &block).process
+    end
+
+    def append(code)
+      @actions << Rewriter::AppendAction.new(self, code)
     end
 
     def insert(code)
-      @action = Rewriter::InsertAction.new(code)
+      @actions << Rewriter::InsertAction.new(self, code)
     end
 
     def insert_after(node)
-      @action = Rewriter::InsertAfterAction.new(node)
+      @actions << Rewriter::InsertAfterAction.new(self, node)
     end
 
     def replace_with(code)
-      @action = Rewriter::ReplaceWithAction.new(code)
+      @actions << Rewriter::ReplaceWithAction.new(self, code)
     end
 
     def remove
-      @action = Rewriter::RemoveAction.new
+      @actions << Rewriter::RemoveAction.new(self)
+    end
+
+    def assign(name, key, value)
+      @rewriter.set name, key, value
+    end
+
+    def fetch(name, key)
+      @rewriter.get name, key
+    end
+
+  private
+
+    def remove_code_or_whole_line(source, line)
+      newline_at_end_of_line = source[-1] == "\n"
+      source_arr = source.split("\n")
+      if source_arr[line - 1] && source_arr[line - 1].strip.empty?
+        source_arr.delete_at(line - 1)
+        if source_arr[line - 2] && source_arr[line - 2].strip.empty? && source_arr[line - 1] && source_arr[line - 1].strip.empty?
+          source_arr.delete_at(line - 1)
+        end
+        source_arr.join("\n") + (newline_at_end_of_line ? "\n" : '')
+      else
+        source
+      end
     end
   end
 end