synvert-core 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e678636827f8ffcad275fe7c6e6bcbee9d278a954bf33a80822ff7235944469
-  data.tar.gz: fa6c7ad36ed9fa50901f4b6f9f373190aa3ad0cbba4bdea539daf66376bc6e0c
+  metadata.gz: 603dafd1ddc6f40f8ef1479d359e39e1f4dbe90067bcfe51f721b15e9571c4d0
+  data.tar.gz: e423e49c531e6ba91f490657f34564f781f3313d82dbf9a863ee2c17985500a8
 SHA512:
-  metadata.gz: bd53c12635ecb49e6d2c6b43d8a0513ac0fd2c2c0b6de8081bc30318512ae7714c092c2e36a721059b2ec811ec521757a1b32889d2e6ff4cb516ce83877cfef6
-  data.tar.gz: 4a0e169b94bc54a61e944d3e44d5bd40a884783c73c2ad491dbb23a25c77c73bb2e120f0feb61494a8bf8762c234cbc3d983185e0bc2eb18a6ec8cb3d2c933ab
+  metadata.gz: e6177477cdf8c0cdd67d6dc533145017daebee61905b5e48b992261f6f458b8a949796aa86eb0cd8f161ffaa05b9325e1cd671b6d63fd645ece7f2101e67859c
+  data.tar.gz: c1daa4cca1056d9266c01037217cd6570f0b7ee0228491e408d43c7bf8bf753a52b2dbfbf20d6aa568876d7e1d7ee11727db40adbc56e17fc603ae091804475a

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # CHANGELOG
 
+## 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/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] }
@@ -66,9 +67,6 @@ rules
 :VALUE              /#{DOUBLE_QUOTE_STRING}/      { [:tSTRING, text[1...-1]] }
 :VALUE              /#{SINGLE_QUOTE_STRING}/      { [:tSTRING, text[1...-1]] }
 :VALUE              /#{NODE_TYPE}/                { [:tNODE_TYPE, text[1..]] }
-:VALUE              />/                           { [:tCHILD, text] }
-:VALUE              /~/                           { [:tSUBSEQUENT_SIBLING, text] }
-:VALUE              /\+/                          { [:tNEXT_SIBLING, text] }
 :VALUE              /#{OPEN_ATTRIBUTE}/           { @nested_count += 1; @state = :KEY; [:tOPEN_ATTRIBUTE, text] }
 :VALUE              /#{IDENTIFIER_VALUE}/         { [:tIDENTIFIER_VALUE, text] }
 :DYNAMIC_ATTRIBUTE  /#{CLOSE_DYNAMIC_ATTRIBUTE}/  { @state = :VALUE; [:tCLOSE_DYNAMIC_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
@@ -215,12 +217,6 @@ class Synvert::Core::NodeQuery::Lexer
             action { [:tSTRING, text[1...-1]] }
           when text = ss.scan(/#{NODE_TYPE}/) then
             action { [:tNODE_TYPE, text[1..]] }
-          when text = ss.scan(/>/) then
-            action { [:tCHILD, text] }
-          when text = ss.scan(/~/) then
-            action { [:tSUBSEQUENT_SIBLING, text] }
-          when text = ss.scan(/\+/) then
-            action { [:tNEXT_SIBLING, text] }
           when text = ss.scan(/#{OPEN_ATTRIBUTE}/) then
             action { @nested_count += 1; @state = :KEY; [:tOPEN_ATTRIBUTE, text] }
           when text = ss.scan(/#{IDENTIFIER_VALUE}/) 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.3'
+    VERSION = '1.1.0'
   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,39 @@ 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

@@ -153,13 +153,48 @@ module Synvert::Core::NodeQuery
       end
 
       it 'identifier can contain <, >, =' do
-        source = '.send[message=<=>]'
+        source = '.send[message=<]'
         expected_tokens = [
           [:tNODE_TYPE, "send"],
           [:tOPEN_ATTRIBUTE, "["],
           [:tKEY, "message"],
           [:tEQUAL, "="],
-          [:tIDENTIFIER_VALUE, "<=>"],
+          [:tIDENTIFIER_VALUE, "<"],
+          [:tCLOSE_ATTRIBUTE, "]"]
+        ]
+        assert_tokens source, expected_tokens
+
+        source = '.send[message==]'
+        expected_tokens = [
+          [:tNODE_TYPE, "send"],
+          [:tOPEN_ATTRIBUTE, "["],
+          [:tKEY, "message"],
+          [:tEQUAL, "="],
+          [:tIDENTIFIER_VALUE, "="],
+          [:tCLOSE_ATTRIBUTE, "]"]
+        ]
+        assert_tokens source, expected_tokens
+
+        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 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
@@ -525,7 +560,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,11 @@ module Synvert::Core::NodeQuery
       assert_parser(source)
     end
 
+    it 'parses empty string' do
+      source = '.send[arguments.first=""]'
+      assert_parser(source)
+    end
+
     describe '#query_nodes' do
       let(:node) {
         parse(<<~EOS)
@@ -230,6 +240,11 @@ 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]

metadata

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