synvert-core 1.4.0 → 1.6.0

data/lib/synvert/core/node_ext.rb

@@ -29,311 +29,6 @@ module Parser::AST
   # Source Code to Ast Node
   # {https://synvert-playground.xinminlabs.com/ruby}
   class Node
-    TYPE_CHILDREN = {
-      and: %i[left_value right_value],
-      arg: %i[name],
-      begin: %i[body],
-      block: %i[caller arguments body],
-      blockarg: %i[name],
-      const: %i[parent_const name],
-      class: %i[name parent_class body],
-      csend: %i[receiver message arguments],
-      cvasgn: %i[left_value right_value],
-      cvar: %i[name],
-      def: %i[name arguments body],
-      definded?: %i[arguments],
-      defs: %i[self name arguments body],
-      hash: %i[pairs],
-      ivasgn: %i[left_value right_value],
-      ivar: %i[name],
-      lvar: %i[name],
-      lvasgn: %i[left_value right_value],
-      masgn: %i[left_value right_value],
-      module: %i[name body],
-      or: %i[left_value right_value],
-      or_asgn: %i[left_value right_value],
-      pair: %i[key value],
-      restarg: %i[name],
-      send: %i[receiver message arguments],
-      super: %i[arguments],
-      zsuper: %i[]
-    }
-
-    # Initialize a Node.
-    #
-    # It extends {Parser::AST::Node} and set parent for its child nodes.
-    def initialize(type, children = [], properties = {})
-      @mutable_attributes = {}
-      super
-      # children could be nil for s(:array)
-      Array(children).each do |child_node|
-        if child_node.is_a?(Parser::AST::Node)
-          child_node.parent = self
-        end
-      end
-    end
-
-    # Get the parent node.
-    # @return [Parser::AST::Node] parent node.
-    def parent
-      @mutable_attributes[:parent]
-    end
-
-    # Set the parent node.
-    # @param node [Parser::AST::Node] parent node.
-    def parent=(node)
-      @mutable_attributes[:parent] = node
-    end
-
-    # Get the sibling nodes.
-    # @return [Array<Parser::AST::Node>] sibling nodes.
-    def siblings
-      index = parent.children.index(self)
-      parent.children[index + 1..]
-    end
-
-    # Dyamically defined method
-    # caller, key, left_value, message, name, pairs, parent_class, parent_const, receivr, rgith_value and value.
-    # based on const TYPE_CHILDREN.
-    %i[
-      caller
-      key
-      left_value
-      message
-      name
-      pairs
-      parent_class
-      parent_const
-      receiver
-      right_value
-      value
-    ].each do |method_name|
-      define_method(method_name) do
-        index = TYPE_CHILDREN[type]&.index(method_name)
-        return children[index] if index
-
-        raise Synvert::Core::MethodNotSupported, "#{method_name} is not handled for #{debug_info}"
-      end
-    end
-
-    # Return the left value of node.
-    # It supports :and, :cvagn, :lvasgn, :masgn, :or and :or_asgn nodes.
-    # @example
-    #   node # s(:or_asgn, s(:lvasgn, :a), s(:int, 1))
-    #   node.left_value # :a
-    # @return [Parser::AST::Node] left value of node.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def left_value
-      return children[0].children[0] if type == :or_asgn
-
-      index = TYPE_CHILDREN[type]&.index(:left_value)
-      return children[index] if index
-
-      raise Synvert::Core::MethodNotSupported, "#{left_value} is not handled for #{debug_info}"
-    end
-
-    # Get arguments of node.
-    # It supports :block, :csend, :def, :defined?, :defs and :send nodes.
-    # @example
-    #   node # s(:send, s(:const, nil, :FactoryGirl), :create, s(:sym, :post), s(:hash, s(:pair, s(:sym, :title), s(:str, "post"))))
-    #   node.arguments # [s(:sym, :post), s(:hash, s(:pair, s(:sym, :title), s(:str, "post")))]
-    # @return [Array<Parser::AST::Node>] arguments of node.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def arguments
-      case type
-      when :def, :block
-        children[1].children
-      when :defs
-        children[2].children
-      when :send, :csend
-        children[2..-1]
-      when :defined?
-        children
-      else
-        raise Synvert::Core::MethodNotSupported, "arguments is not handled for #{debug_info}"
-      end
-    end
-
-    # Get body of node.
-    # It supports :begin, :block, :class, :def, :defs and :module node.
-    # @example
-    #   node # s(:block, s(:send, s(:const, nil, :RSpec), :configure), s(:args, s(:arg, :config)), s(:send, nil, :include, s(:const, s(:const, nil, :EmailSpec), :Helpers)))
-    #   node.body # [s(:send, nil, :include, s(:const, s(:const, nil, :EmailSpec), :Helpers))]
-    # @return [Array<Parser::AST::Node>] body of node.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def body
-      case type
-      when :begin
-        children
-      when :def, :block, :class, :module
-        return [] if children[2].nil?
-
-        :begin == children[2].type ? children[2].body : children[2..-1]
-      when :defs
-        return [] if children[3].nil?
-
-        :begin == children[3].type ? children[3].body : children[3..-1]
-      else
-        raise Synvert::Core::MethodNotSupported, "body is not handled for #{debug_info}"
-      end
-    end
-
-    # Get condition of node.
-    # It supports :if node.
-    # @example
-    #   node # s(:if, s(:defined?, s(:const, nil, :Bundler)), nil, nil)
-    #   node.condition # s(:defined?, s(:const, nil, :Bundler))
-    # @return [Parser::AST::Node] condition of node.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def condition
-      if :if == type
-        children[0]
-      else
-        raise Synvert::Core::MethodNotSupported, "condition is not handled for #{debug_info}"
-      end
-    end
-
-    # Get keys of :hash node.
-    # @example
-    #   node # s(:hash, s(:pair, s(:sym, :foo), s(:sym, :bar)), s(:pair, s(:str, "foo"), s(:str, "bar")))
-    #   node.keys # [s(:sym, :foo), s(:str, "foo")]
-    # @return [Array<Parser::AST::Node>] keys of node.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def keys
-      if :hash == type
-        children.map { |child| child.children[0] }
-      else
-        raise Synvert::Core::MethodNotSupported, "keys is not handled for #{debug_info}"
-      end
-    end
-
-    # Get values of :hash node.
-    # @example
-    #   node # s(:hash, s(:pair, s(:sym, :foo), s(:sym, :bar)), s(:pair, s(:str, "foo"), s(:str, "bar")))
-    #   node.values # [s(:sym, :bar), s(:str, "bar")]
-    # @return [Array<Parser::AST::Node>] values of node.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def values
-      if :hash == type
-        children.map { |child| child.children[1] }
-      else
-        raise Synvert::Core::MethodNotSupported, "keys is not handled for #{debug_info}"
-      end
-    end
-
-    # Check if :hash node contains specified key.
-    # @example
-    #   node # s(:hash, s(:pair, s(:sym, :foo), s(:sym, :bar)))
-    #   node.key?(:foo) # true
-    # @param [Symbol, String] key value.
-    # @return [Boolean] true if specified key exists.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def key?(key)
-      if :hash == type
-        children.any? { |pair_node| pair_node.key.to_value == key }
-      else
-        raise Synvert::Core::MethodNotSupported, "key? is not handled for #{debug_info}"
-      end
-    end
-
-    # Get :hash value node according to specified key.
-    # @example
-    #   node # s(:hash, s(:pair, s(:sym, :foo), s(:sym, :bar)))
-    #   node.hash_value(:foo) # s(:sym, :bar)
-    # @param [Symbol, String] key value.
-    # @return [Parser::AST::Node] hash value of node.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def hash_value(key)
-      if :hash == type
-        value_node = children.find { |pair_node| pair_node.key.to_value == key }
-        value_node&.value
-      else
-        raise Synvert::Core::MethodNotSupported, "hash_value is not handled for #{debug_info}"
-      end
-    end
-
-    # Return the exact value of node.
-    # It supports :array, :begin, :erange, :false, :float, :irange, :int, :str, :sym and :true nodes.
-    # @example
-    #   node # s(:array, s(:str, "str"), s(:sym, :str))
-    #   node.to_value # ['str', :str]
-    # @return [Object] exact value.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def to_value
-      case type
-      when :int, :float, :str, :sym
-        children.last
-      when :true
-        true
-      when :false
-        false
-      when :nil
-        nil
-      when :array
-        children.map(&:to_value)
-      when :irange
-        (children.first.to_value..children.last.to_value)
-      when :erange
-        (children.first.to_value...children.last.to_value)
-      when :begin
-        children.first.to_value
-      else
-        self
-      end
-    end
-
-    # Respond key value and source for hash node, e.g.
-    # @example
-    #   node # s(:hash, s(:pair, s(:sym, :foo), s(:sym, :bar)))
-    #   node.foo_value # :bar
-    #   node.foo_source # ":bar"
-    def method_missing(method_name, *args, &block)
-      if :args == type && children.respond_to?(method_name)
-        return children.send(method_name, *args, &block)
-      elsif :hash == type && method_name.to_s.include?('_value')
-        key = method_name.to_s.sub('_value', '')
-        return hash_value(key.to_sym)&.to_value if key?(key.to_sym)
-        return hash_value(key.to_s)&.to_value if key?(key.to_s)
-
-        return nil
-      elsif :hash == type && method_name.to_s.include?('_source')
-        key = method_name.to_s.sub('_source', '')
-        return hash_value(key.to_sym)&.to_source if key?(key.to_sym)
-        return hash_value(key.to_s)&.to_source if key?(key.to_s)
-
-        return nil
-      end
-
-      super
-    end
-
-    def respond_to_missing?(method_name, *args)
-      if :args == type && children.respond_to?(method_name)
-        return true
-      elsif :hash == type && method_name.to_s.include?('_value')
-        key = method_name.to_s.sub('_value', '')
-        return true if key?(key.to_sym) || key?(key.to_s)
-      elsif :hash == type && method_name.to_s.include?('_source')
-        key = method_name.to_s.sub('_source', '')
-        return true if key?(key.to_sym) || key?(key.to_s)
-      end
-
-      super
-    end
-
-    # Return the debug info.
-    #
-    # @return [String] file, line, source and node.
-    def debug_info
-      "\n" +
-        [
-          "file: #{loc.expression.source_buffer.name}",
-          "line: #{loc.expression.line}",
-          "source: #{to_source}",
-          "node: #{inspect}"
-        ].join("\n")
-    end
-
     # Get the file name of node.
     #
     # @return [String] file name.
@@ -341,13 +36,6 @@ module Parser::AST
       loc.expression&.source_buffer.name
     end
 
-    # Get the source code of node.
-    #
-    # @return [String] source code.
-    def to_source
-      loc.expression&.source
-    end
-
     # Get the column of node.
     #
     # @return [Integer] column.
@@ -362,197 +50,6 @@ module Parser::AST
       loc.expression.line
     end
 
-    # Get child node by the name.
-    #
-    # @param child_name [String] name of child node.
-    # @return [Parser::AST::Node] the child node.
-    def child_node_by_name(child_name)
-      direct_child_name, nested_child_name = child_name.to_s.split('.', 2)
-      if respond_to?(direct_child_name)
-        child_node = send(direct_child_name)
-
-        return child_node.child_node_by_name(nested_child_name) if nested_child_name
-
-        return nil if child_node.nil?
-
-        return child_node if child_node.is_a?(Parser::AST::Node)
-
-        return child_node
-      end
-
-      raise Synvert::Core::MethodNotSupported,
-            "child_node_by_name is not handled for #{debug_info}, child_name: #{child_name}"
-    end
-
-    # Get the source range of child node.
-    #
-    # @param child_name [String] name of child node.
-    # @return [Parser::Source::Range] source range of child node.
-    def child_node_range(child_name)
-      case [type, child_name.to_sym]
-      when %i[block pipes], %i[def parentheses], %i[defs parentheses]
-        Parser::Source::Range.new(
-          '(string)',
-          arguments.first.loc.expression.begin_pos - 1,
-          arguments.last.loc.expression.end_pos + 1
-        )
-      when %i[block arguments], %i[def arguments], %i[defs arguments]
-        Parser::Source::Range.new(
-          '(string)',
-          arguments.first.loc.expression.begin_pos,
-          arguments.last.loc.expression.end_pos
-        )
-      when %i[class name], %i[def name], %i[defs name]
-        loc.name
-      when %i[defs dot]
-        loc.operator
-      when %i[defs self]
-        Parser::Source::Range.new('(string)', loc.operator.begin_pos - 'self'.length, loc.operator.begin_pos)
-      when %i[send dot], %i[csend dot]
-        loc.dot
-      when %i[send message], %i[csend message]
-        if loc.operator
-          Parser::Source::Range.new('(string)', loc.selector.begin_pos, loc.operator.end_pos)
-        else
-          loc.selector
-        end
-      when %i[send parentheses], %i[csend parentheses]
-        if loc.begin && loc.end
-          Parser::Source::Range.new('(string)', loc.begin.begin_pos, loc.end.end_pos)
-        end
-      else
-        direct_child_name, nested_child_name = child_name.to_s.split('.', 2)
-        if respond_to?(direct_child_name)
-          child_node = send(direct_child_name)
-
-          return child_node.child_node_range(nested_child_name) if nested_child_name
-
-          return nil if child_node.nil?
-
-          if child_node.is_a?(Parser::AST::Node)
-            return(
-              Parser::Source::Range.new(
-                '(string)',
-                child_node.loc.expression.begin_pos,
-                child_node.loc.expression.end_pos
-              )
-            )
-          end
-
-          # arguments
-          return nil if child_node.empty?
-
-          return(
-            Parser::Source::Range.new(
-              '(string)',
-              child_node.first.loc.expression.begin_pos,
-              child_node.last.loc.expression.end_pos
-            )
-          )
-        end
-
-        raise Synvert::Core::MethodNotSupported,
-              "child_node_range is not handled for #{debug_info}, child_name: #{child_name}"
-      end
-    end
-
-    # Recursively iterate all child nodes of node.
-    #
-    # @yield [child] Gives a child node.
-    # @yieldparam child [Parser::AST::Node] child node
-    def recursive_children(&block)
-      children.each do |child|
-        if child.is_a?(Parser::AST::Node)
-          stop = yield child
-          child.recursive_children(&block) unless stop == :stop
-        end
-      end
-    end
-
-    # Match node with rules.
-    # It provides some additional keywords to match rules, +any+, +contain+, +not+, +in+, +not_in+, +gt+, +gte+, +lt+, +lte+.
-    # @example
-    #   type: 'send', arguments: { any: 'Lifo::ShowExceptions' }
-    #   type: { in: ['send', 'csend'] }
-    #   type: :send, arguments: { length: { gt: 2 } }
-    # @param rules [Hash] rules to match.
-    # @return true if matches.
-    def match?(rules)
-      keywords = %i[any contain not in not_in gt gte lt lte]
-      flat_hash(rules).keys.all? do |multi_keys|
-        last_key = multi_keys.last
-        actual = keywords.include?(last_key) ? actual_value(multi_keys[0...-1]) : actual_value(multi_keys)
-        expected = expected_value(rules, multi_keys)
-        case last_key
-        when :any, :contain
-          actual.any? { |actual_value| match_value?(actual_value, expected) }
-        when :not
-          !match_value?(actual, expected)
-        when :in
-          expected.any? { |expected_value| match_value?(actual, expected_value) }
-        when :not_in
-          expected.all? { |expected_value| !match_value?(actual, expected_value) }
-        when :gt
-          actual > expected
-        when :gte
-          actual >= expected
-        when :lt
-          actual < expected
-        when :lte
-          actual <= expected
-        else
-          match_value?(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::Core::MethodNotSupported] if string in block !{{ }} does not support.
-    def rewritten_source(code)
-      code.gsub(/{{(.*?)}}/m) do
-        old_code = Regexp.last_match(1)
-        if respond_to?(old_code.split('.').first)
-          evaluated = child_node_by_name(old_code)
-          case evaluated
-          when Parser::AST::Node
-            if evaluated.type == :args
-              evaluated.loc.expression.source[1...-1]
-            else
-              evaluated.loc.expression.source
-            end
-          when Array
-            if evaluated.size > 0
-              file_source = evaluated.first.loc.expression.source_buffer.source
-              source = file_source[evaluated.first.loc.expression.begin_pos...evaluated.last.loc.expression.end_pos]
-              lines = source.split "\n"
-              lines_count = lines.length
-              if lines_count > 1 && lines_count == evaluated.size
-                new_code = []
-                lines.each_with_index { |line, index|
-                  new_code << (index == 0 ? line : line[evaluated.first.indent - 2..-1])
-                }
-                new_code.join("\n")
-              else
-                source
-              end
-            end
-          when String, Symbol, Integer, Float
-            evaluated
-          when NilClass
-            'nil'
-          else
-            raise Synvert::Core::MethodNotSupported, "rewritten_source is not handled for #{evaluated.inspect}"
-          end
-        else
-          "{{#{old_code}}}"
-        end
-      end
-    end
-
     # Strip curly braces for hash.
     # @example
     #   node # s(:hash, s(:pair, s(:sym, :foo), s(:str, "bar")))
@@ -627,141 +124,5 @@ module Parser::AST
         to_source
       end
     end
-
-    # Convert node to a hash, so that it can be converted to a json.
-    def to_hash
-      result = { type: type }
-      if TYPE_CHILDREN[type]
-        TYPE_CHILDREN[type].each do |key|
-          value = send(key)
-          result[key] =
-            case value
-            when Array
-              value.map { |v| v.respond_to?(:to_hash) ? v.to_hash : v }
-            when Parser::AST::Node
-              value.to_hash
-            else
-              value
-            end
-        end
-      else
-        result[:children] = children.map { |c| c.respond_to?(:to_hash) ? c.to_hash : c }
-      end
-      result
-    end
-
-    private
-
-    # Compare actual value with expected value.
-    #
-    # @param actual [Object] actual value.
-    # @param expected [Object] expected value.
-    # @return [Boolean]
-    # @raise [Synvert::Core::MethodNotSupported] if expected class is not supported.
-    def match_value?(actual, expected)
-      return true if actual == expected
-
-      case expected
-      when Symbol
-        if actual.is_a?(Parser::AST::Node)
-          actual.to_source == ":#{expected}" || actual.to_source == expected.to_s
-        else
-          actual.to_sym == expected
-        end
-      when String
-        if actual.is_a?(Parser::AST::Node)
-          actual.to_source == expected || actual.to_source == unwrap_quote(expected) ||
-            unwrap_quote(actual.to_source) == expected || unwrap_quote(actual.to_source) == unwrap_quote(expected)
-        else
-          actual.to_s == expected || wrap_quote(actual.to_s) == expected
-        end
-      when Regexp
-        if actual.is_a?(Parser::AST::Node)
-          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
-        if actual.is_a?(Parser::AST::Node)
-          :nil == actual.type
-        else
-          actual.nil?
-        end
-      when Numeric
-        if actual.is_a?(Parser::AST::Node)
-          actual.children[0] == expected
-        else
-          actual == expected
-        end
-      when TrueClass
-        :true == actual.type
-      when FalseClass
-        :false == actual.type
-      when Parser::AST::Node
-        actual == expected
-      when Synvert::Core::Rewriter::AnyValue
-        !actual.nil?
-      else
-        raise Synvert::Core::MethodNotSupported, "#{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 multi_keys [Array<Symbol, String>]
-    # @return [Object] actual value.
-    def actual_value(multi_keys)
-      multi_keys.inject(self) { |n, key| n.send(key) if n }
-    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
-
-    # Wrap the string with single or double quote.
-    def wrap_quote(string)
-      if string.include?("'")
-        "\"#{string}\""
-      else
-        "'#{string}'"
-      end
-    end
-
-    # Unwrap the quote from the string.
-    def unwrap_quote(string)
-      if (string[0] == '"' && string[-1] == '"') || (string[0] == "'" && string[-1] == "'")
-        string[1...-1]
-      else
-        string
-      end
-    end
   end
 end