synvert 0.0.17 → 0.1.0

data/lib/synvert/node_ext.rb

@@ -1,319 +0,0 @@
-# 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::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::MethodNotSupported.new "name is not handled for #{self.inspect}"
-    end
-  end
-
-  # Get receiver node of :send node.
-  #
-  # @return [Parser::AST::Node] receiver node.
-  # @raise [Synvert::MethodNotSupported] if calls on other node.
-  def receiver
-    if :send == self.type
-      self.children[0]
-    else
-      raise Synvert::MethodNotSupported.new "receiver is not handled for #{self.inspect}"
-    end
-  end
-
-  # Get message node of :send node.
-  #
-  # @return [Parser::AST::Node] mesage node.
-  # @raise [Synvert::MethodNotSupported] if calls on other node.
-  def message
-    if :send == self.type
-      self.children[1]
-    else
-      raise Synvert::MethodNotSupported.new "message is not handled for #{self.inspect}"
-    end
-  end
-
-  # Get arguments node of :send, :block or :defined? node.
-  #
-  # @return [Array<Parser::AST::Node>] arguments node.
-  # @raise [Synvert::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::MethodNotSupported.new "arguments is not handled for #{self.inspect}"
-    end
-  end
-
-  # Get caller node of :block node.
-  #
-  # @return [Parser::AST::Node] caller node.
-  # @raise [Synvert::MethodNotSupported] if calls on other node.
-  def caller
-    if :block == self.type
-      self.children[0]
-    else
-      raise Synvert::MethodNotSupported.new "caller is not handled for #{self.inspect}"
-    end
-  end
-
-  # Get body node of :begin or :block node.
-  #
-  # @return [Array<Parser::AST::Node>] body node.
-  # @raise [Synvert::MethodNotSupported] if calls on other node.
-  def body
-    case self.type
-    when :begin
-      self.children
-    when :block
-      :begin == self.children[2].type ? self.children[2].children : [self.children[2]]
-    else
-      raise Synvert::MethodNotSupported.new "body is not handled for #{self.inspect}"
-    end
-  end
-
-  # Get condition node of :if node.
-  #
-  # @return [Parser::AST::Node] condition node.
-  # @raise [Synvert::MethodNotSupported] if calls on other node.
-  def condition
-    if :if == self.type
-      self.children[0]
-    else
-      raise Synvert::MethodNotSupported.new "condition is not handled for #{self.inspect}"
-    end
-  end
-
-  # Get keys node of :hash node.
-  #
-  # @return [Array<Parser::AST::Node>] keys node.
-  # @raise [Synvert::MethodNotSupported] if calls on other node.
-  def keys
-    if :hash == self.type
-      self.children.map { |child| child.children[0] }
-    else
-      raise Synvert::MethodNotSupported.new "keys is not handled for #{self.inspect}"
-    end
-  end
-
-  # Get values node of :hash node.
-  #
-  # @return [Array<Parser::AST::Node>] values node.
-  # @raise [Synvert::MethodNotSupported] if calls on other node.
-  def values
-    if :hash == self.type
-      self.children.map { |child| child.children[1] }
-    else
-      raise Synvert::MethodNotSupported.new "keys is not handled for #{self.inspect}"
-    end
-  end
-
-  # Get key node of hash :pair node.
-  #
-  # @return [Parser::AST::Node] key node.
-  # @raise [Synvert::MethodNotSupported] if calls on other node.
-  def key
-    if :pair == self.type
-      self.children.first
-    else
-      raise Synvert::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::MethodNotSupported] if calls on other node.
-  def value
-    if :pair == self.type
-      self.children.last
-    else
-      raise Synvert::MethodNotSupported.new "value is not handled for #{self.inspect}"
-    end
-  end
-
-  # Get the source code of current node.
-  #
-  # @param instance [Synvert::Rewriter::Instance]
-  # @return [String] source code.
-  def source(instance)
-    if self.loc.expression
-      instance.current_source[self.loc.expression.begin_pos...self.loc.expression.end_pos]
-    end
-  end
-
-  # 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
-
-  # Match current node with rules.
-  #
-  # @param instance [Synvert::Rewriter::Instance] used to get crrent source code.
-  # @param rules [Hash] rules to match.
-  # @return true if matches.
-  def match?(instance, rules)
-    flat_hash(rules).keys.all? do |multi_keys|
-      if multi_keys.last == :any
-        actual_values = actual_value(self, instance, multi_keys[0...-1])
-        expected = expected_value(rules, multi_keys)
-        actual_values.any? { |actual| match_value?(instance, actual, expected) }
-      elsif multi_keys.last == :not
-        actual = actual_value(self, instance, multi_keys[0...-1])
-        expected = expected_value(rules, multi_keys)
-        !match_value?(instance, actual, expected)
-      else
-        actual = actual_value(self, instance, multi_keys)
-        expected = expected_value(rules, multi_keys)
-        match_value?(instance, actual, expected)
-      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::MethodNotSupported] if string in block {{ }} does not support.
-  def rewritten_source(code)
-    code.gsub(/{{(.*?)}}/m) do
-      evaluated = self.instance_eval $1
-      case evaluated
-      when Parser::AST::Node
-        source = evaluated.loc.expression.source_buffer.source
-        source[evaluated.loc.expression.begin_pos...evaluated.loc.expression.end_pos]
-      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
-        evaluated
-      when NilClass
-        'nil'
-      else
-        raise Synvert::MethodNotSupported.new "rewritten_source is not handled for #{evaluated.inspect}"
-      end
-    end
-  end
-
-private
-
-  # Compare actual value with expected value.
-  #
-  # @param instance [Synvert::Rewriter::Instance] used to get source code.
-  # @param actual [Object] actual value.
-  # @param expected [Object] expected value.
-  # @return [Integer] -1, 0 or 1.
-  # @raise [Synvert::MethodNotSupported] if expected class is not supported.
-  def match_value?(instance, actual, expected)
-    case expected
-    when Symbol
-      if Parser::AST::Node === actual
-        actual.source(instance) == ":#{expected}"
-      else
-        actual.to_sym == expected
-      end
-    when String
-      if Parser::AST::Node === actual
-        actual.source(instance) == expected || actual.source(instance)[1...-1] == expected
-      else
-        actual.to_s == expected
-      end
-    when Regexp
-      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?(instance, 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::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
-      end
-    end
-    new_hash
-  end
-
-  # Get actual value from the node.
-  #
-  # @param node [Parser::AST::Node]
-  # @param instance [Synvert::Rewriter::Instance]
-  # @param multi_keys [Array<Symbol>]
-  # @return [Object] actual value.
-  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
-
-  # 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

data/lib/synvert/rewriter/action.rb

@@ -1,224 +0,0 @@
-# encoding: utf-8
-
-module Synvert
-  # Action defines rewriter action, add, replace or remove code.
-  class Rewriter::Action
-    # Initialize an action.
-    #
-    # @param instance [Synvert::Rewriter::Instance]
-    # @param code {String] new code to add, replace or remove.
-    def initialize(instance, code)
-      @instance = instance
-      @code = code
-      @node = @instance.current_node
-    end
-
-    # Line number of the node.
-    #
-    # @return [Integer] line number.
-    def line
-      @node.loc.expression.line
-    end
-
-    # The rewritten source code with proper indent.
-    #
-    # @return [String] rewritten code.
-    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
-
-    # The rewritten source code.
-    #
-    # @return [String] rewritten source code.
-    def rewritten_source
-      @rewritten_source ||= @node.rewritten_source(@code)
-    end
-
-    # Compare actions by begin position.
-    #
-    # @param action [Synvert::Rewriter::Action]
-    # @return [Integer] -1, 0 or 1
-    def <=>(action)
-      self.begin_pos <=> action.begin_pos
-    end
-  end
-
-  # ReplaceWithAction to replace code.
-  class Rewriter::ReplaceWithAction < Rewriter::Action
-    # Begin position of code to replace.
-    #
-    # @return [Integer] begin position.
-    def begin_pos
-      @node.loc.expression.begin_pos
-    end
-
-    # End position of code to replace.
-    #
-    # @return [Integer] end position.
-    def end_pos
-      @node.loc.expression.end_pos
-    end
-
-    # The rewritten source code with proper indent.
-    #
-    # @return [String] rewritten code.
-    def rewritten_code
-      if rewritten_source.split("\n").length > 1
-        "\n\n" + rewritten_source.split("\n").map { |line|
-          indent(@node) + line
-        }.join("\n")
-      else
-        rewritten_source
-      end
-    end
-
-  private
-
-    # Indent of the node
-    #
-    # @param node [Parser::AST::Node]
-    # @return [String] n times whitesphace
-    def indent(node)
-      ' ' * node.indent
-    end
-  end
-
-  # AppendWithAction to append code to the bottom of node body.
-  class Rewriter::AppendAction < Rewriter::Action
-    # Begin position to append code.
-    #
-    # @return [Integer] begin position.
-    def begin_pos
-      if :begin == @node.type
-        @node.loc.expression.end_pos
-      else
-        @node.loc.expression.end_pos - 4
-      end
-    end
-
-    # End position, always same to begin position.
-    #
-    # @return [Integer] end position.
-    def end_pos
-      begin_pos
-    end
-
-  private
-
-    # Indent of the node.
-    #
-    # @param node [Parser::AST::Node]
-    # @return [String] n times whitesphace
-    def indent(node)
-      if [:block, :class].include? node.type
-        ' ' * (node.indent + 2)
-      else
-        ' ' * node.indent
-      end
-    end
-  end
-
-  # InsertAction to insert code to the top of node body.
-  class Rewriter::InsertAction < Rewriter::Action
-    # Begin position to insert code.
-    #
-    # @return [Integer] begin position.
-    def begin_pos
-      insert_position(@node)
-    end
-
-    # End position, always same to begin position.
-    #
-    # @return [Integer] end position.
-    def end_pos
-      begin_pos
-    end
-
-  private
-
-    # Insert position.
-    #
-    # @return [Integer] insert position.
-    def insert_position(node)
-      case node.type
-      when :block
-        node.children[1].children.empty? ? node.children[0].loc.expression.end_pos + 3 : node.children[1].loc.expression.end_pos
-      when :class
-        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
-
-    # Indent of the node.
-    #
-    # @param node [Parser::AST::Node]
-    # @return [String] n times whitesphace
-    def indent(node)
-      if [:block, :class].include? node.type
-        ' ' * (node.indent + 2)
-      else
-        ' ' * node.indent
-      end
-    end
-  end
-
-  # InsertAfterAction to insert code next to the node.
-  class Rewriter::InsertAfterAction < Rewriter::Action
-    # Begin position to insert code.
-    #
-    # @return [Integer] begin position.
-    def begin_pos
-      @node.loc.expression.end_pos
-    end
-
-    # End position, always same to begin position.
-    #
-    # @return [Integer] end position.
-    def end_pos
-      begin_pos
-    end
-
-  private
-
-    # Indent of the node.
-    #
-    # @param node [Parser::AST::Node]
-    # @return [String] n times whitesphace
-    def indent(node)
-      ' ' * node.indent
-    end
-  end
-
-  # RemoveAction to remove code.
-  class Rewriter::RemoveAction < Rewriter::Action
-    def initialize(instance, code=nil)
-      super
-    end
-
-    # Begin position of code to replace.
-    #
-    # @return [Integer] begin position.
-    def begin_pos
-      @node.loc.expression.begin_pos
-    end
-
-    # End position of code to replace.
-    #
-    # @return [Integer] end position.
-    def end_pos
-      @node.loc.expression.end_pos
-    end
-
-    # The rewritten code, always empty string.
-    def rewritten_code
-      ''
-    end
-  end
-end

data/lib/synvert/rewriter/condition.rb

@@ -1,56 +0,0 @@
-# encoding: utf-8
-
-module Synvert
-  # Condition checks if rules matches.
-  class Rewriter::Condition
-    # Initialize a condition.
-    #
-    # @param instance [Synvert::Rewriter::Instance]
-    # @param rules [Hash]
-    # @param block [Block]
-    # @return [Synvert::Rewriter::Condition]
-    def initialize(instance, rules, &block)
-      @instance = instance
-      @rules = rules
-      @block = block
-    end
-
-    # If condition matches, run the block code.
-    def process
-      @instance.instance_eval &@block if match?
-    end
-  end
-
-  # IfExistCondition checks if matching node exists in the node children.
-  class Rewriter::IfExistCondition < Rewriter::Condition
-    # check if any child node matches the rules.
-    def match?
-      match = false
-      @instance.current_node.recursive_children do |child_node|
-        match = match || (child_node && child_node.match?(@instance, @rules))
-      end
-      match
-    end
-  end
-
-  # UnlessExistCondition checks if matching node doesn't exist in the node children.
-  class Rewriter::UnlessExistCondition < Rewriter::Condition
-    # check if none of child node matches the rules.
-    def match?
-      match = false
-      @instance.current_node.recursive_children do |child_node|
-        match = match || (child_node && child_node.match?(@instance, @rules))
-      end
-      !match
-    end
-  end
-
-  # IfExistCondition checks if node has only one child node and the child node matches rules.
-  class Rewriter::IfOnlyExistCondition < Rewriter::Condition
-    # check if only have one child node and the child node matches rules.
-    def match?
-      @instance.current_node.body.size == 1 &&
-        @instance.current_node.body.first.match?(@instance, @rules)
-    end
-  end
-end

data/lib/synvert/rewriter/gem_spec.rb

@@ -1,42 +0,0 @@
-# encoding: utf-8
-
-module Synvert
-  # GemSpec checks and compares gem version.
-  class Rewriter::GemSpec
-    OPERATORS = {eq: '==', lt: '<', gt: '>', lte: '<=', gte: '>=', ne: '!='}
-
-    # Initialize a gem_spec.
-    #
-    # @param name [String] gem name
-    # @param comparator [Hash] comparator to gem version, e.g. {eg: '2.0.0'},
-    #   comparator key can be eq, lt, gt, lte, gte or ne.
-    def initialize(name, comparator)
-      @name = name
-      if Hash === comparator
-        @operator = comparator.keys.first
-        @version = Gem::Version.new comparator.values.first
-      else
-        @operator = :eq
-        @version = Gem::Version.new comparator
-      end
-    end
-
-    # Check if the specified gem version in Gemfile.lock matches gem_spec comparator.
-    #
-    # @return [Boolean] true if matches, otherwise false.
-    # @raise [Synvert::GemfileLockNotFound] raise if Gemfile.lock does not exist.
-    def match?
-      gemfile_lock_path = File.join(Configuration.instance.get(:path), 'Gemfile.lock')
-      if File.exists? gemfile_lock_path
-        parser = Bundler::LockfileParser.new(File.read(gemfile_lock_path))
-        if spec = parser.specs.find { |spec| spec.name == @name }
-          Gem::Version.new(spec.version).send(OPERATORS[@operator], @version)
-        else
-          false
-        end
-      else
-        raise GemfileLockNotFound.new 'Gemfile.lock does not exist'
-      end
-    end
-  end
-end