synvert-core 1.0.4 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0554ef349e1fe725c68cd277b40751ca7373b04fe118313bf70fdf307852e01
-  data.tar.gz: 283a4ca6bf2d0fc09ba1f63bb5831524dc0634184072c340d7092a9253a93700
+  metadata.gz: b3972bef6a4c4b41b4211e2f45d889c6e3c71b08b1b2b039ca3511a620f79ccf
+  data.tar.gz: 7ddecb20188351e72e59b4a72c67a45d395638ae7a20d3c4d46f3fef0184de3c
 SHA512:
-  metadata.gz: 9152e5eea03cbc9a842fdad557cc8ea9ecb2e7d3dc3480708b886100393c0167a804f3cd0f4fd5aca968c4992ce85b0b604d36ab6beabe9ac4023e6102e2c05e
-  data.tar.gz: 4b35baab2ebe3c76a9151e0148dc185a8e6776d4dd6ece7abcd2cb3cd4ad21bc63b5cc68b75d6410827ef9089bf52fc6871bacb1e44c39cffce36faef07b9a8f
+  metadata.gz: b89480e5d9d05fe0651b5cd9edd1a4408a52364d449d0632baf062dd40251670b8c7d98370fa831f6961454498e9fbfffa67011a4fabb45f21e6031933643c36
+  data.tar.gz: c23844951b2938268289099f852f01d554e46a7aa80ad301011d05cc40a022864dd872a8097c71575a42e8770730dbfea2deea8d867af0412022506751cf2671

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # CHANGELOG
 
+## 1.1.1 (2022-04-27)
+
+* Parse empty string properly in node query language
+* Parse `[]` and `[]=` properly in node query language
+
+## 1.1.0 (2022-04-26)
+
+* Dynamic define Node methods by `TYPE_CHILDREN` const
+* Add `Node#to_hash`
+* Parse empty string in node query language
+* Identifier value can contain `?`, `<`, `=`, `>` in node query language
+
 ## 1.0.0 (2022-04-25)
 
 * Introduce new node query language

data/lib/synvert/core/node_ext.rb

@@ -27,11 +27,41 @@ module Parser::AST
   # +type: 'send', receiver: { type: 'send', receiver: { type: 'send', message: 'config' }, message: 'active_record' }, message: 'identity_map='+
   #
   # Source Code to Ast Node
-  # {https://synvert-playground.xinminlabs.com?language=ruby}
+  # {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.
+    # It extends {Parser::AST::Node} and set parent for its child nodes.
     def initialize(type, children = [], properties = {})
       @mutable_attributes = {}
       super
@@ -62,88 +92,32 @@ module Parser::AST
       parent.children[index + 1..]
     end
 
-    # Get the name of node.
-    # It supports :arg, :blockarg, :class, :const, :cvar, :def, :defs, :ivar,
-    # :lvar, :mlhs, :module and :restarg nodes.
-    # @example
-    #   node # => s(:class, s(:const, nil, :Synvert), nil, nil)
-    #   node.name # => s(:const, nil, :Synvert)
-    # @return [Parser::AST::Node] name of node.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def name
-      case type
-      when :class, :module, :def, :arg, :blockarg, :restarg, :lvar, :ivar, :cvar
-        children[0]
-      when :defs, :const
-        children[1]
-      when :mlhs
-        self
-      else
-        raise Synvert::Core::MethodNotSupported, "name is not handled for #{debug_info}"
-      end
-    end
+    # Dyamically defined method
+    # caller, key, left_value, message, name, parent_class, parent_const, receivr, rgith_value and value.
+    # based on const TYPE_CHILDREN.
+    %i[caller key left_value message name 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
 
-    # Get parent_class of node.
-    # It supports :class node.
-    # @example
-    #   node # s(:class, s(:const, nil, :Post), s(:const, s(:const, nil, :ActiveRecord), :Base), nil)
-    #   node.parent_class # s(:const, s(:const, nil, :ActiveRecord), :Base)
-    # @return [Parser::AST::Node] parent_class of node.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def parent_class
-      if :class == type
-        children[1]
-      else
-        raise Synvert::Core::MethodNotSupported, "parent_class is not handled for #{debug_info}"
+        raise Synvert::Core::MethodNotSupported, "#{method_name} is not handled for #{debug_info}"
       end
     end
 
-    # Get parent constant of node.
-    # It supports :const node.
+    # Return the left value of node.
+    # It supports :and, :cvagn, :lvasgn, :masgn, :or and :or_asgn nodes.
     # @example
-    #   node # s(:const, s(:const, nil, :Synvert), :Node)
-    #   node.parent_const # s(:const, nil, :Synvert)
-    # @return [Parser::AST::Node] parent const of node.
+    #   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 parent_const
-      if :const == type
-        children[0]
-      else
-        raise Synvert::Core::MethodNotSupported, "parent_const is not handled for #{debug_info}"
-      end
-    end
+    def left_value
+      return children[0].children[0] if type == :or_asgn
 
-    # Get receiver of node.
-    # It support :csend and :send nodes.
-    # @example
-    #   node # s(:send, s(:const, nil, :FactoryGirl), :create, s(:sym, :post))
-    #   node.receiver # s(:const, nil, :FactoryGirl)
-    # @return [Parser::AST::Node] receiver of node.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def receiver
-      if %i[csend send].include?(type)
-        children[0]
-      else
-        raise Synvert::Core::MethodNotSupported, "receiver is not handled for #{debug_info}"
-      end
-    end
+      index = TYPE_CHILDREN[type]&.index(:left_value)
+      return children[index] if index
 
-    # Get message of node.
-    # It support :csend, :send, :super and :zsuper nodes.
-    # @example
-    #   node # s(:send, s(:const, nil, :FactoryGirl), :create, s(:sym, :post))
-    #   node.message # :create
-    # @return [Symbol] mesage of node.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def message
-      case type
-      when :super, :zsuper
-        :super
-      when :send, :csend
-        children[1]
-      else
-        raise Synvert::Core::MethodNotSupported, "message is not handled for #{debug_info}"
-      end
+      raise Synvert::Core::MethodNotSupported, "#{left_value} is not handled for #{debug_info}"
     end
 
     # Get arguments of node.
@@ -168,21 +142,6 @@ module Parser::AST
       end
     end
 
-    # Get caller of node.
-    # It support :block node.
-    # @example
-    #   node # s(:block, s(:send, s(:const, nil, :RSpec), :configure), s(:args, s(:arg, :config)), nil)
-    #   node.caller # s(:send, s(:const, nil, :RSpec), :configure)
-    # @return [Parser::AST::Node] caller of node.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def caller
-      if :block == type
-        children[0]
-      else
-        raise Synvert::Core::MethodNotSupported, "caller is not handled for #{debug_info}"
-      end
-    end
-
     # Get body of node.
     # It supports :begin, :block, :class, :def, :defs and :module node.
     # @example
@@ -281,66 +240,6 @@ module Parser::AST
       end
     end
 
-    # Get key node of hash :pair node.
-    # @example
-    #   node # s(:pair, s(:sym, :foo), s(:str, "bar"))
-    #   node.key # s(:sym, :foo)
-    # @return [Parser::AST::Node] key of node.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def key
-      if :pair == type
-        children.first
-      else
-        raise Synvert::Core::MethodNotSupported, "key is not handled for #{debug_info}"
-      end
-    end
-
-    # Get value node of hash :pair node.
-    # @example
-    #   node # s(:pair, s(:sym, :foo), s(:str, "bar"))
-    #   node.value # s(:str, "bar")
-    # @return [Parser::AST::Node] value of node.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def value
-      if :pair == type
-        children.last
-      else
-        raise Synvert::Core::MethodNotSupported, "value 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(:masgn, s(:mlhs, s(:lvasgn, :a), s(:lvasgn, :b)), s(:array, s(:int, 1), s(:int, 2)))
-    #   node.left_value # s(:mlhs, s(:lvasgn, :a), s(:lvasgn, :b))
-    # @return [Parser::AST::Node] left value of node.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def left_value
-      if %i[masgn lvasgn ivasgn cvasgn and or].include? type
-        children[0]
-      elsif :or_asgn == type
-        children[0].children[0]
-      else
-        raise Synvert::Core::MethodNotSupported, "left_value is not handled for #{debug_info}"
-      end
-    end
-
-    # Return the right value of node.
-    # It supports :cvasgn, :ivasgn, :lvasgn, :masgn, :or and :or_asgn nodes.
-    # @example
-    #   node # s(:masgn, s(:mlhs, s(:lvasgn, :a), s(:lvasgn, :b)), s(:array, s(:int, 1), s(:int, 2)))
-    #   node.right_value # s(:array, s(:int, 1), s(:int, 2))
-    # @return [Array<Parser::AST::Node>] right value of node.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def right_value
-      if %i[masgn lvasgn ivasgn cvasgn or_asgn and or].include? type
-        children[1]
-      else
-        raise Synvert::Core::MethodNotSupported, "right_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
@@ -717,6 +616,28 @@ module Parser::AST
       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.

data/lib/synvert/core/node_query/compiler/selector.rb

@@ -7,12 +7,14 @@ module Synvert::Core::NodeQuery::Compiler
     # @param node_type [String] the node type
     # @param attribute_list [Synvert::Core::NodeQuery::Compiler::AttributeList] the attribute list
     # @param index [Integer] the index
-    # @param has_expression [Synvert::Core::NodeQuery::Compiler::Expression] the has expression
-    def initialize(node_type: nil, attribute_list: nil, index: nil, has_expression: nil)
+    # @param pseudo_class [String] the pseudo class, can be <code>has</code> or <code>not_has</code>
+    # @param pseudo_expression [Synvert::Core::NodeQuery::Compiler::Expression] the pseudo expression
+    def initialize(node_type: nil, attribute_list: nil, index: nil, pseudo_class: nil, pseudo_expression: nil)
       @node_type = node_type
       @attribute_list = attribute_list
       @index = index
-      @has_expression = has_expression
+      @pseudo_class = pseudo_class
+      @pseudo_expression = pseudo_expression
     end
 
     # Filter nodes by index.
@@ -27,14 +29,14 @@ module Synvert::Core::NodeQuery::Compiler
     def match?(node, _operator = :==)
       (!@node_type || (node.is_a?(::Parser::AST::Node) && @node_type.to_sym == node.type)) &&
         (!@attribute_list || @attribute_list.match?(node)) &&
-        (!@has_expression || @has_expression.match?(node))
+        (!@pseudo_class || (@pseudo_class == 'has' && @pseudo_expression.match?(node)) || (@pseudo_class == 'not_has' && !@pseudo_expression.match?(node)))
     end
 
     def to_s
       str = ".#{@node_type}#{@attribute_list}"
-      return str if !@index && !@has_expression
+      return str if !@index && !@pseudo_class
 
-      return "#{str}:has(#{@has_expression})" if @has_expression
+      return "#{str}:#{@pseudo_class}(#{@pseudo_expression})" if @pseudo_class
 
       case @index
       when 0

data/lib/synvert/core/node_query/compiler/string.rb

@@ -16,17 +16,6 @@ module Synvert::Core::NodeQuery::Compiler
       SIMPLE_VALID_OPERATORS
     end
 
-    # Get the actual value of a node.
-    # @param node [Parser::AST::Node] the node
-    # @return [String] if node is a Parser::AST::Node, return the node source code, otherwise, return the string value.
-    def actual_value(node)
-      if node.is_a?(::Parser::AST::Node)
-        node.to_source
-      else
-        node.to_s
-      end
-    end
-
     def to_s
       "\"#{@value}\""
     end

data/lib/synvert/core/node_query/lexer.rex

@@ -20,8 +20,8 @@ macros
   REGEXP                   /\/(#{REGEXP_BODY})(?<!\\)\/([imxo]*)/
   SYMBOL                   /:[\w!\?<>=]+/
   TRUE                     /true/
-  SINGLE_QUOTE_STRING      /'(.+?)'/
-  DOUBLE_QUOTE_STRING      /"(.+?)"/
+  SINGLE_QUOTE_STRING      /'(.*?)'/
+  DOUBLE_QUOTE_STRING      /"(.*?)"/
 
 rules
 
@@ -31,7 +31,8 @@ rules
                     /:last-child/                 { [:tINDEX, -1] }
                     /:nth-child\(\d+\)/           { [:tINDEX, text.sub(':nth-child(', '').to_i - 1] }
                     /:nth-last-child\(\d+\)/      { [:tINDEX, -text.sub(':nth-last-child(', '').to_i] }
-                    /:has/                        { [:tHAS, text[1..-1]] }
+                    /:has/                        { [:tPSEUDO_CLASS, text[1..-1]] }
+                    /:not_has/                    { [:tPSEUDO_CLASS, text[1..-1]] }
                     /#{NODE_TYPE}/                { [:tNODE_TYPE, text[1..]] }
                     />/                           { [:tCHILD, text] }
                     /~/                           { [:tSUBSEQUENT_SIBLING, text] }
@@ -53,6 +54,10 @@ rules
 :KEY                /in/i                         { @state = :VALUE; [:tIN, text] }
 :KEY                /#{IDENTIFIER}/               { [:tKEY, text] }
 :VALUE              /\s+/
+:VALUE              /\[\]=/                       { [:tIDENTIFIER_VALUE, text] }
+:VALUE              /\[\]/                        { [:tIDENTIFIER_VALUE, text] }
+:VALUE              /:\[\]=/                      { [:tSYMBOL, text[1..-1].to_sym] }
+:VALUE              /:\[\]/                       { [:tSYMBOL, text[1..-1].to_sym] }
 :VALUE              /#{OPEN_DYNAMIC_ATTRIBUTE}/   { @state = :DYNAMIC_ATTRIBUTE; [:tOPEN_DYNAMIC_ATTRIBUTE, text] }
 :VALUE              /#{OPEN_ARRAY}/               { @state = :ARRAY_VALUE; [:tOPEN_ARRAY, text] }
 :VALUE              /#{CLOSE_ATTRIBUTE}/          { @nested_count -= 1; @state = @nested_count == 0 ? nil : :VALUE; [:tCLOSE_ATTRIBUTE, text] }

data/lib/synvert/core/node_query/lexer.rex.rb

@@ -33,8 +33,8 @@ class Synvert::Core::NodeQuery::Lexer
   REGEXP                  = /\/(#{REGEXP_BODY})(?<!\\)\/([imxo]*)/
   SYMBOL                  = /:[\w!\?<>=]+/
   TRUE                    = /true/
-  SINGLE_QUOTE_STRING     = /'(.+?)'/
-  DOUBLE_QUOTE_STRING     = /"(.+?)"/
+  SINGLE_QUOTE_STRING     = /'(.*?)'/
+  DOUBLE_QUOTE_STRING     = /"(.*?)"/
   # :startdoc:
   # :stopdoc:
   class LexerError < StandardError ; end
@@ -134,7 +134,9 @@ class Synvert::Core::NodeQuery::Lexer
           when text = ss.scan(/:nth-last-child\(\d+\)/) then
             action { [:tINDEX, -text.sub(':nth-last-child(', '').to_i] }
           when text = ss.scan(/:has/) then
-            action { [:tHAS, text[1..-1]] }
+            action { [:tPSEUDO_CLASS, text[1..-1]] }
+          when text = ss.scan(/:not_has/) then
+            action { [:tPSEUDO_CLASS, text[1..-1]] }
           when text = ss.scan(/#{NODE_TYPE}/) then
             action { [:tNODE_TYPE, text[1..]] }
           when text = ss.scan(/>/) then
@@ -189,6 +191,14 @@ class Synvert::Core::NodeQuery::Lexer
           case
           when ss.skip(/\s+/) then
             # do nothing
+          when text = ss.scan(/\[\]=/) then
+            action { [:tIDENTIFIER_VALUE, text] }
+          when text = ss.scan(/\[\]/) then
+            action { [:tIDENTIFIER_VALUE, text] }
+          when text = ss.scan(/:\[\]=/) then
+            action { [:tSYMBOL, text[1..-1].to_sym] }
+          when text = ss.scan(/:\[\]/) then
+            action { [:tSYMBOL, text[1..-1].to_sym] }
           when text = ss.scan(/#{OPEN_DYNAMIC_ATTRIBUTE}/) then
             action { @state = :DYNAMIC_ATTRIBUTE; [:tOPEN_DYNAMIC_ATTRIBUTE, text] }
           when text = ss.scan(/#{OPEN_ARRAY}/) then

data/lib/synvert/core/node_query/parser.racc.rb

@@ -208,7 +208,7 @@ racc_token_table = {
   :tIDENTIFIER => 5,
   :tIDENTIFIER_VALUE => 6,
   :tINDEX => 7,
-  :tHAS => 8,
+  :tPSEUDO_CLASS => 8,
   :tCOMMA => 9,
   :tCHILD => 10,
   :tSUBSEQUENT_SIBLING => 11,
@@ -271,7 +271,7 @@ Racc_token_to_s_table = [
   "tIDENTIFIER",
   "tIDENTIFIER_VALUE",
   "tINDEX",
-  "tHAS",
+  "tPSEUDO_CLASS",
   "tCOMMA",
   "tCHILD",
   "tSUBSEQUENT_SIBLING",
@@ -363,15 +363,15 @@ def _reduce_11(val, _values)
 end
 
 def _reduce_12(val, _values)
- Compiler::Selector.new(node_type: val[0], attribute_list: val[1], has_expression: val[4])
+ Compiler::Selector.new(node_type: val[0], attribute_list: val[1], pseudo_class: val[2], pseudo_expression: val[4])
 end
 
 def _reduce_13(val, _values)
- Compiler::Selector.new(node_type: val[0], has_expression: val[3])
+ Compiler::Selector.new(node_type: val[0], pseudo_class: val[1], pseudo_expression: val[3])
 end
 
 def _reduce_14(val, _values)
- Compiler::Selector.new(attribute_list: val[0], has_expression: val[3])
+ Compiler::Selector.new(attribute_list: val[0], pseudo_class: val[1], pseudo_expression: val[3])
 end
 
 def _reduce_15(val, _values)

data/lib/synvert/core/node_query/parser.y

@@ -1,6 +1,6 @@
 class Synvert::Core::NodeQuery::Parser
 options no_result_var
-token tNODE_TYPE tATTRIBUTE tKEY tIDENTIFIER tIDENTIFIER_VALUE tINDEX tHAS tCOMMA
+token tNODE_TYPE tATTRIBUTE tKEY tIDENTIFIER tIDENTIFIER_VALUE tINDEX tPSEUDO_CLASS tCOMMA
       tCHILD tSUBSEQUENT_SIBLING tNEXT_SIBLING
       tOPEN_ATTRIBUTE tCLOSE_ATTRIBUTE tOPEN_DYNAMIC_ATTRIBUTE tCLOSE_DYNAMIC_ATTRIBUTE tOPEN_ARRAY tCLOSE_ARRAY tOPEN_SELECTOR tCLOSE_SELECTOR
       tEQUAL tNOT_EQUAL tMATCH tNOT_MATCH tGREATER_THAN tGREATER_THAN_OR_EQUAL tLESS_THAN tLESS_THAN_OR_EQUAL tIN tNOT_IN tINCLUDES
@@ -20,9 +20,9 @@ rule
     : tNODE_TYPE attribute_list tINDEX { Compiler::Selector.new(node_type: val[0], attribute_list: val[1], index: val[2]) }
     | tNODE_TYPE tINDEX { Compiler::Selector.new(node_type: val[0], index: val[1]) }
     | attribute_list tINDEX { Compiler::Selector.new(attribute_list: val[0], index: val[1]) }
-    | tNODE_TYPE attribute_list tHAS tOPEN_SELECTOR expression tCLOSE_SELECTOR { Compiler::Selector.new(node_type: val[0], attribute_list: val[1], has_expression: val[4]) }
-    | tNODE_TYPE tHAS tOPEN_SELECTOR expression tCLOSE_SELECTOR { Compiler::Selector.new(node_type: val[0], has_expression: val[3]) }
-    | attribute_list tHAS tOPEN_SELECTOR expression tCLOSE_SELECTOR { Compiler::Selector.new(attribute_list: val[0], has_expression: val[3]) }
+    | tNODE_TYPE attribute_list tPSEUDO_CLASS tOPEN_SELECTOR expression tCLOSE_SELECTOR { Compiler::Selector.new(node_type: val[0], attribute_list: val[1], pseudo_class: val[2], pseudo_expression: val[4]) }
+    | tNODE_TYPE tPSEUDO_CLASS tOPEN_SELECTOR expression tCLOSE_SELECTOR { Compiler::Selector.new(node_type: val[0], pseudo_class: val[1], pseudo_expression: val[3]) }
+    | attribute_list tPSEUDO_CLASS tOPEN_SELECTOR expression tCLOSE_SELECTOR { Compiler::Selector.new(attribute_list: val[0], pseudo_class: val[1], pseudo_expression: val[3]) }
     | tNODE_TYPE attribute_list { Compiler::Selector.new(node_type: val[0], attribute_list: val[1]) }
     | tNODE_TYPE { Compiler::Selector.new(node_type: val[0]) }
     | attribute_list { Compiler::Selector.new(attribute_list: val[0]) }

data/lib/synvert/core/node_query.rb

@@ -19,6 +19,7 @@
 #
 # It also supports some custom selectors:
 #
+# * not_has: +.class:not_has(.def)+, it's same as +:not(:has())+ in css, just to make implementation easy.
 # * nested selector: +.send[arguments = [size = 2][first = .sym][last = .hash]]+
 # * array value: +.send[arguments = (a, b)]+
 # * IN operator: +.send[message IN (try, try!)]+

data/lib/synvert/core/version.rb

@@ -2,6 +2,6 @@
 
 module Synvert
   module Core
-    VERSION = '1.0.4'
+    VERSION = '1.1.1'
   end
 end

data/spec/synvert/core/node_ext_spec.rb

@@ -76,11 +76,6 @@ describe Parser::AST::Node do
       expect(node.name).to eq :@@foo
     end
 
-    it 'gets for mlhs node' do
-      node = parse('var.each { |(param1, param2)| }')
-      expect(node.arguments.first.name).to eq node.arguments.first
-    end
-
     it 'gets for restarg node' do
       node = parse('object.each { |*entry| }')
       expect(node.arguments.first.name).to eq :entry
@@ -116,16 +111,6 @@ describe Parser::AST::Node do
       node = parse('user&.update(name: name)')
       expect(node.message).to eq :update
     end
-
-    it 'gets for super node' do
-      node = parse('super(params)')
-      expect(node.message).to eq :super
-    end
-
-    it 'gets for zuper node' do
-      node = parse('super do; end')
-      expect(node.caller.message).to eq :super
-    end
   end
 
   describe '#parent_const' do
@@ -1042,4 +1027,45 @@ describe Parser::AST::Node do
       end
     end
   end
+
+  describe '#to_hash' do
+    it 'gets hash' do
+      node = parse(<<~EOS)
+        class Synvert
+          def foobar(foo, bar)
+            foo + bar
+          end
+        end
+      EOS
+      expect(node.to_hash).to eq(
+        {
+          type: :class,
+          parent_class: nil,
+          name: {
+            type: :const,
+            parent_const: nil,
+            name: :Synvert
+          },
+          body: [
+            {
+              type: :def,
+              name: :foobar,
+              arguments: [
+                { type: :arg, name: :foo },
+                { type: :arg, name: :bar }
+              ],
+              body: [
+                {
+                  type: :send,
+                  receiver: { name: :foo, type: :lvar },
+                  message: :+,
+                  arguments: [{ name: :bar, type: :lvar }]
+                }
+              ]
+            }
+          ]
+        }
+      )
+    end
+  end
 end

data/spec/synvert/core/node_query/lexer_spec.rb

@@ -187,6 +187,45 @@ module Synvert::Core::NodeQuery
         assert_tokens source, expected_tokens
       end
 
+      it 'matches empty string' do
+        source = ".send[arguments.first='']"
+        expected_tokens = [
+          [:tNODE_TYPE, "send"],
+          [:tOPEN_ATTRIBUTE, "["],
+          [:tKEY, "arguments.first"],
+          [:tEQUAL, "="],
+          [:tSTRING, ""],
+          [:tCLOSE_ATTRIBUTE, "]"]
+        ]
+        assert_tokens source, expected_tokens
+      end
+
+      it 'matches :[] message' do
+        source = ".send[message=[]]"
+        expected_tokens = [
+          [:tNODE_TYPE, "send"],
+          [:tOPEN_ATTRIBUTE, "["],
+          [:tKEY, "message"],
+          [:tEQUAL, "="],
+          [:tIDENTIFIER_VALUE, "[]"],
+          [:tCLOSE_ATTRIBUTE, "]"]
+        ]
+        assert_tokens source, expected_tokens
+      end
+
+      it 'matches :[] message' do
+        source = ".send[message=:[]=]"
+        expected_tokens = [
+          [:tNODE_TYPE, "send"],
+          [:tOPEN_ATTRIBUTE, "["],
+          [:tKEY, "message"],
+          [:tEQUAL, "="],
+          [:tSYMBOL, :[]=],
+          [:tCLOSE_ATTRIBUTE, "]"]
+        ]
+        assert_tokens source, expected_tokens
+      end
+
       it 'matches attribute value' do
         source = '.pair[key={{value}}]'
         expected_tokens = [
@@ -547,7 +586,22 @@ module Synvert::Core::NodeQuery
         source = '.class:has(> .def)'
         expected_tokens = [
           [:tNODE_TYPE, "class"],
-          [:tHAS, "has"],
+          [:tPSEUDO_CLASS, "has"],
+          [:tOPEN_SELECTOR, "("],
+          [:tCHILD, ">"],
+          [:tNODE_TYPE, "def"],
+          [:tCLOSE_SELECTOR, ")"]
+        ]
+        assert_tokens source, expected_tokens
+      end
+    end
+
+    context ':not_has' do
+      it 'matches' do
+        source = '.class:not_has(> .def)'
+        expected_tokens = [
+          [:tNODE_TYPE, "class"],
+          [:tPSEUDO_CLASS, "not_has"],
           [:tOPEN_SELECTOR, "("],
           [:tCHILD, ">"],
           [:tNODE_TYPE, "def"],

data/spec/synvert/core/node_query/parser_spec.rb

@@ -53,6 +53,11 @@ module Synvert::Core::NodeQuery
       assert_parser(source)
     end
 
+    it 'parses :not_has selector' do
+      source = '.class:not_has(> .def)'
+      assert_parser(source)
+    end
+
     it 'parses multiple attributes' do
       source = '.send[receiver=nil][message=:create]'
       assert_parser(source)
@@ -108,6 +113,21 @@ module Synvert::Core::NodeQuery
       assert_parser(source)
     end
 
+    it 'parses empty string' do
+      source = '.send[arguments.first=""]'
+      assert_parser(source)
+    end
+
+    it 'parses []=' do
+      source = '.send[message=[]=]'
+      assert_parser(source)
+    end
+
+    it 'parses :[]' do
+      source = '.send[message=:[]]'
+      assert_parser(source)
+    end
+
     describe '#query_nodes' do
       let(:node) {
         parse(<<~EOS)
@@ -124,6 +144,8 @@ module Synvert::Core::NodeQuery
               { a: a, b: b }
               foo.merge(bar)
               arr[index]
+              arr[index] = value
+              call('')
             end
           end
         EOS
@@ -202,17 +224,17 @@ module Synvert::Core::NodeQuery
 
       it 'matches descendant node' do
         expression = parser.parse('.class .send[message=:create]')
-        expect(expression.query_nodes(node)).to eq [node.body.first.children.last, node.body.second.children.last]
+        expect(expression.query_nodes(node)).to eq [node.body.first.body.last, node.body.second.body.last]
       end
 
       it 'matches three level descendant node' do
         expression = parser.parse('.class .def .send[message=:create]')
-        expect(expression.query_nodes(node)).to eq [node.body.first.children.last, node.body.second.children.last]
+        expect(expression.query_nodes(node)).to eq [node.body.first.body.last, node.body.second.body.last]
       end
 
       it 'matches child node' do
         expression = parser.parse('.def > .send[message=:create]')
-        expect(expression.query_nodes(node)).to eq [node.body.first.children.last, node.body.second.children.last]
+        expect(expression.query_nodes(node)).to eq [node.body.first.body.last, node.body.second.body.last]
       end
 
       it 'matches next sibling node' do
@@ -230,18 +252,31 @@ module Synvert::Core::NodeQuery
         expect(expression.query_nodes(node)).to eq [node.body.first, node.body.second]
       end
 
+      it 'matches not_has selector' do
+        expression = parser.parse('.def:not_has(> .send[receiver=FactoryBot])')
+        expect(expression.query_nodes(node)).to eq [node.body.last]
+      end
+
       it 'matches arguments.size' do
-        expression = parser.parse('.send[arguments.size=2]')
-        expect(expression.query_nodes(node)).to eq [node.body.first.children.last, node.body.second.children.last]
-        expression = parser.parse('.send[arguments.size>2]')
+        expression = parser.parse('.def .send[arguments.size=2]')
+        expect(expression.query_nodes(node)).to eq [
+          node.body.first.body.last,
+          node.body.second.body.last,
+          node.body.third.body.fourth
+        ]
+        expression = parser.parse('.def .send[arguments.size>2]')
         expect(expression.query_nodes(node)).to eq []
-        expression = parser.parse('.send[arguments.size>=2]')
-        expect(expression.query_nodes(node)).to eq [node.body.first.children.last, node.body.second.children.last]
+        expression = parser.parse('.def .send[arguments.size>=2]')
+        expect(expression.query_nodes(node)).to eq [
+          node.body.first.body.last,
+          node.body.second.body.last,
+          node.body.third.body.fourth
+        ]
       end
 
       it 'matches arguments' do
         expression = parser.parse('.send[arguments=[size=2][first=.sym][last=.hash]]')
-        expect(expression.query_nodes(node)).to eq [node.body.first.children.last, node.body.second.children.last]
+        expect(expression.query_nodes(node)).to eq [node.body.first.body.last, node.body.second.body.last]
       end
 
       it 'matches regexp value' do
@@ -262,9 +297,19 @@ module Synvert::Core::NodeQuery
       end
 
       it 'matches []' do
-        expression = parser.parse('.send[message="[]"]')
+        expression = parser.parse('.send[message=[]]')
         expect(expression.query_nodes(node)).to eq [node.body.last.body.third]
       end
+
+      it 'matches []=' do
+        expression = parser.parse('.send[message=:[]=]')
+        expect(expression.query_nodes(node)).to eq [node.body.last.body.fourth]
+      end
+
+      it 'matches empty string' do
+        expression = parser.parse('.send[message=call][arguments.first=""]')
+        expect(expression.query_nodes(node)).to eq [node.body.last.body.last]
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: synvert-core
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.1.1
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-25 00:00:00.000000000 Z
+date: 2022-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport