synvert-core 1.0.5 → 1.2.0

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

@@ -1,28 +1,25 @@
 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
       tCHILD tSUBSEQUENT_SIBLING tNEXT_SIBLING
-      tOPEN_ATTRIBUTE tCLOSE_ATTRIBUTE tOPEN_DYNAMIC_ATTRIBUTE tCLOSE_DYNAMIC_ATTRIBUTE tOPEN_ARRAY tCLOSE_ARRAY tOPEN_SELECTOR tCLOSE_SELECTOR
+      tOPEN_ATTRIBUTE tCLOSE_ATTRIBUTE tOPEN_DYNAMIC_ATTRIBUTE tCLOSE_DYNAMIC_ATTRIBUTE
+      tOPEN_ARRAY tCLOSE_ARRAY tOPEN_SELECTOR tCLOSE_SELECTOR tOPEN_GOTO_SCOPE tCLOSE_GOTO_SCOPE
       tEQUAL tNOT_EQUAL tMATCH tNOT_MATCH tGREATER_THAN tGREATER_THAN_OR_EQUAL tLESS_THAN tLESS_THAN_OR_EQUAL tIN tNOT_IN tINCLUDES
       tARRAY_VALUE tDYNAMIC_ATTRIBUTE tBOOLEAN tFLOAT tINTEGER tNIL tREGEXP tSTRING tSYMBOL
 rule
   expression
-    : selector tCHILD expression { Compiler::Expression.new(selector: val[0], rest: val[2], relationship: :child) }
-    | selector tSUBSEQUENT_SIBLING expression { Compiler::Expression.new(selector: val[0], rest: val[2], relationship: :subsequent_sibling) }
-    | selector tNEXT_SIBLING expression { Compiler::Expression.new(selector: val[0], rest: val[2], relationship: :next_sibling) }
-    | selector expression { Compiler::Expression.new(selector: val[0], rest: val[1], relationship: :descendant) }
-    | selector { Compiler::Expression.new(selector: val[0]) }
-    | tCHILD expression { Compiler::Expression.new(rest: val[1], relationship: :child) }
+    : tCHILD expression { Compiler::Expression.new(rest: val[1], relationship: :child) }
     | tSUBSEQUENT_SIBLING expression { Compiler::Expression.new(rest: val[1], relationship: :subsequent_sibling) }
     | tNEXT_SIBLING expression { Compiler::Expression.new(rest: val[1], relationship: :next_sibling) }
+    | tOPEN_GOTO_SCOPE tIDENTIFIER tCLOSE_GOTO_SCOPE expression { Compiler::Expression.new(goto_scope: val[1], rest: val[3]) }
+    | tPSEUDO_CLASS tOPEN_SELECTOR expression tCLOSE_SELECTOR { Compiler::Expression.new(relationship: val[0].to_sym, rest: val[2]) }
+    | selector expression { Compiler::Expression.new(selector: val[0], rest: val[1]) }
+    | selector { Compiler::Expression.new(selector: val[0]) }
 
   selector
     : 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 { 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]) }
@@ -53,7 +50,7 @@ rule
     | tKEY tIN tOPEN_ARRAY array_value tCLOSE_ARRAY { Compiler::Attribute.new(key: val[0], value: val[3], operator: :in) }
 
   array_value
-    : value tCOMMA array_value { Compiler::Array.new(value: val[0], rest: val[2]) }
+    : value array_value { Compiler::Array.new(value: val[0], rest: val[1]) }
     | value { Compiler::Array.new(value: val[0]) }
 
   value

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.5'
+    VERSION = '1.2.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,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

@@ -200,6 +200,45 @@ module Synvert::Core::NodeQuery
         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 nil?' do
+        source = ".send[message=nil?]"
+        expected_tokens = [
+          [:tNODE_TYPE, "send"],
+          [:tOPEN_ATTRIBUTE, "["],
+          [:tKEY, "message"],
+          [:tEQUAL, "="],
+          [:tIDENTIFIER_VALUE, "nil?"],
+          [:tCLOSE_ATTRIBUTE, "]"]
+        ]
+        assert_tokens source, expected_tokens
+      end
+
       it 'matches attribute value' do
         source = '.pair[key={{value}}]'
         expected_tokens = [
@@ -403,7 +442,7 @@ module Synvert::Core::NodeQuery
       end
 
       it 'matches IN' do
-        source = '.send[message IN (create, build)]'
+        source = '.send[message IN (create build)]'
         expected_tokens = [
           [:tNODE_TYPE, "send"],
           [:tOPEN_ATTRIBUTE, "["],
@@ -411,7 +450,6 @@ module Synvert::Core::NodeQuery
           [:tIN, "IN"],
           [:tOPEN_ARRAY, "("],
           [:tIDENTIFIER_VALUE, "create"],
-          [:tCOMMA, ","],
           [:tIDENTIFIER_VALUE, "build"],
           [:tCLOSE_ARRAY, ")"],
           [:tCLOSE_ATTRIBUTE, "]"]
@@ -420,7 +458,7 @@ module Synvert::Core::NodeQuery
       end
 
       it 'matches NOT IN' do
-        source = '.send[message NOT IN (create, build)]'
+        source = '.send[message NOT IN (create build)]'
         expected_tokens = [
           [:tNODE_TYPE, "send"],
           [:tOPEN_ATTRIBUTE, "["],
@@ -428,7 +466,6 @@ module Synvert::Core::NodeQuery
           [:tNOT_IN, "NOT IN"],
           [:tOPEN_ARRAY, "("],
           [:tIDENTIFIER_VALUE, "create"],
-          [:tCOMMA, ","],
           [:tIDENTIFIER_VALUE, "build"],
           [:tCLOSE_ARRAY, ")"],
           [:tCLOSE_ATTRIBUTE, "]"]
@@ -560,7 +597,7 @@ module Synvert::Core::NodeQuery
         source = '.class:has(> .def)'
         expected_tokens = [
           [:tNODE_TYPE, "class"],
-          [:tHAS, "has"],
+          [:tPSEUDO_CLASS, "has"],
           [:tOPEN_SELECTOR, "("],
           [:tCHILD, ">"],
           [:tNODE_TYPE, "def"],
@@ -569,5 +606,35 @@ module Synvert::Core::NodeQuery
         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"],
+          [:tCLOSE_SELECTOR, ")"]
+        ]
+        assert_tokens source, expected_tokens
+      end
+    end
+
+    context 'goto_scope' do
+      it 'matches' do
+        source = '.block <body> > .def'
+        expected_tokens = [
+          [:tNODE_TYPE, "block"],
+          [:tOPEN_GOTO_SCOPE, "<"],
+          [:tIDENTIFIER, "body"],
+          [:tCLOSE_GOTO_SCOPE, ">"],
+          [:tCHILD, ">"],
+          [:tNODE_TYPE, "def"]
+        ]
+        assert_tokens source, expected_tokens
+      end
+    end
   end
 end

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

@@ -28,6 +28,11 @@ module Synvert::Core::NodeQuery
       assert_parser(source)
     end
 
+    it 'parses scope' do
+      source = '.block <body> > .send'
+      assert_parser(source)
+    end
+
     it 'parses :first-child' do
       source = '.class .def:first-child'
       assert_parser(source)
@@ -49,7 +54,17 @@ module Synvert::Core::NodeQuery
     end
 
     it 'parses :has selector' do
-      source = '.class:has(> .def)'
+      source = '.class :has(> .def)'
+      assert_parser(source)
+    end
+
+    it 'parses :not_has selector' do
+      source = '.class :not_has(> .def)'
+      assert_parser(source)
+    end
+
+    it 'parses root :has selector' do
+      source = ':has(.def)'
       assert_parser(source)
     end
 
@@ -94,12 +109,12 @@ module Synvert::Core::NodeQuery
     end
 
     it 'parses in operator' do
-      source = '.def[name in (foo, bar)]'
+      source = '.def[name in (foo bar)]'
       assert_parser(source)
     end
 
     it 'parses not_in operator' do
-      source = '.def[name not in (foo, bar)]'
+      source = '.def[name not in (foo bar)]'
       assert_parser(source)
     end
 
@@ -113,6 +128,16 @@ module Synvert::Core::NodeQuery
       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)
@@ -127,13 +152,22 @@ module Synvert::Core::NodeQuery
 
             def foobar(a, b)
               { a: a, b: b }
-              foo.merge(bar)
               arr[index]
+              arr[index] = value
+              nil?
+              call('')
             end
           end
         EOS
       }
 
+      let(:test_node) {
+        parse(<<~EOS)
+          RSpec.describe Synvert do
+          end
+        EOS
+      }
+
       it 'matches class node' do
         expression = parser.parse('.class[name=Synvert]')
         expect(expression.query_nodes(node)).to eq [node]
@@ -175,12 +209,12 @@ module Synvert::Core::NodeQuery
       end
 
       it 'matches in' do
-        expression = parser.parse('.def[name IN (foo, bar)]')
+        expression = parser.parse('.def[name IN (foo bar)]')
         expect(expression.query_nodes(node)).to eq [node.body.first, node.body.second]
       end
 
       it 'matches not in' do
-        expression = parser.parse('.def[name NOT IN (foo, bar)]')
+        expression = parser.parse('.def[name NOT IN (foo bar)]')
         expect(expression.query_nodes(node)).to eq [node.body.last]
       end
 
@@ -190,34 +224,34 @@ module Synvert::Core::NodeQuery
       end
 
       it 'matches equal array' do
-        expression = parser.parse('.def[arguments=(a, b)]')
+        expression = parser.parse('.def[arguments=(a b)]')
         expect(expression.query_nodes(node)).to eq [node.body.last]
 
-        expression = parser.parse('.def[arguments=(b, a)]')
+        expression = parser.parse('.def[arguments=(b a)]')
         expect(expression.query_nodes(node)).to eq []
       end
 
       it 'matches not equal array' do
-        expression = parser.parse('.def[arguments!=(a, b)]')
+        expression = parser.parse('.def[arguments!=(a b)]')
         expect(expression.query_nodes(node)).to eq [node.body.first, node.body.second]
 
-        expression = parser.parse('.def[arguments!=(b, a)]')
+        expression = parser.parse('.def[arguments!=(b a)]')
         expect(expression.query_nodes(node)).to eq [node.body.first, node.body.second, node.body.last]
       end
 
       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,23 +264,54 @@ module Synvert::Core::NodeQuery
         expect(expression.query_nodes(node)).to eq [node.body.last]
       end
 
+      it 'matches goto scope' do
+        expression = parser.parse('.def <body> > .send[message=:create]')
+        expect(expression.query_nodes(node)).to eq [node.body.first.body.last, node.body.second.body.last]
+
+        expression = parser.parse('.def <body> .send[message=:create]')
+        expect(expression.query_nodes(node)).to eq [node.body.first.body.last, node.body.second.body.last]
+      end
+
+      it 'matches multiple goto scope' do
+        expression = parser.parse('.block <caller.arguments> .const[name=Synvert]')
+        expect(expression.query_nodes(test_node)).to eq [test_node.caller.arguments.first]
+      end
+
       it 'matches has selector' do
         expression = parser.parse('.def:has(> .send[receiver=FactoryBot])')
         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 root has selector' do
+        expression = parser.parse(':has(.def[name=foobar])')
+        expect(expression.query_nodes(node)).to eq [node]
+      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.third
+        ]
+        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.third
+        ]
       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
@@ -261,15 +326,25 @@ module Synvert::Core::NodeQuery
         expect(expression.query_nodes(node)).to eq node.body.last.body.first.children
       end
 
-      it 'matches identifier' do
-        expression = parser.parse('.send[receiver=foo][message=merge]')
+      it 'matches []' do
+        expression = parser.parse('.send[message=[]]')
         expect(expression.query_nodes(node)).to eq [node.body.last.body.second]
       end
 
-      it 'matches []' do
-        expression = parser.parse('.send[message="[]"]')
+      it 'matches []=' do
+        expression = parser.parse('.send[message=:[]=]')
         expect(expression.query_nodes(node)).to eq [node.body.last.body.third]
       end
+
+      it 'matches nil and nil?' do
+        expression = parser.parse('.send[receiver=nil][message=nil?]')
+        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.5
+  version: 1.2.0
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-25 00:00:00.000000000 Z
+date: 2022-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport