RubyGems - synvert-core - Versions diffs - 1.3.0 → 1.5.0 - Mend

synvert-core 1.3.0 → 1.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (75) hide show

checksums.yaml +4 -4
data/.gitignore +0 -4
data/CHANGELOG.md +16 -0
data/Gemfile +0 -3
data/Guardfile +0 -9
data/README.md +30 -12
data/Rakefile +1 -15
data/lib/synvert/core/engine/erb.rb +1 -1
data/lib/synvert/core/engine.rb +1 -1
data/lib/synvert/core/node_ext.rb +0 -466
data/lib/synvert/core/rewriter/action/replace_erb_stmt_with_expr_action.rb +20 -17
data/lib/synvert/core/rewriter/condition/if_exist_condition.rb +1 -1
data/lib/synvert/core/rewriter/condition/unless_exist_condition.rb +1 -1
data/lib/synvert/core/rewriter/instance.rb +89 -135
data/lib/synvert/core/rewriter/scope/query_scope.rb +2 -2
data/lib/synvert/core/rewriter/scope/within_scope.rb +4 -4
data/lib/synvert/core/rewriter.rb +0 -10
data/lib/synvert/core/version.rb +1 -1
data/lib/synvert/core.rb +4 -6
data/spec/synvert/core/engine/erb_spec.rb +3 -3
data/spec/synvert/core/node_ext_spec.rb +0 -795
data/spec/synvert/core/rewriter/action/replace_erb_stmt_with_expr_action_spec.rb +21 -1
data/spec/synvert/core/rewriter/instance_spec.rb +49 -112
data/spec/synvert/core/rewriter/scope/goto_scope_spec.rb +1 -4
data/spec/synvert/core/rewriter/scope/query_scope_spec.rb +8 -4
data/spec/synvert/core/rewriter/scope/within_scope_spec.rb +1 -4
data/synvert-core-ruby.gemspec +4 -2
metadata +44 -61
data/lib/synvert/core/array_ext.rb +0 -48
data/lib/synvert/core/node_query/compiler/array.rb +0 -34
data/lib/synvert/core/node_query/compiler/attribute.rb +0 -39
data/lib/synvert/core/node_query/compiler/attribute_list.rb +0 -24
data/lib/synvert/core/node_query/compiler/boolean.rb +0 -23
data/lib/synvert/core/node_query/compiler/comparable.rb +0 -86
data/lib/synvert/core/node_query/compiler/dynamic_attribute.rb +0 -51
data/lib/synvert/core/node_query/compiler/expression.rb +0 -58
data/lib/synvert/core/node_query/compiler/float.rb +0 -23
data/lib/synvert/core/node_query/compiler/identifier.rb +0 -41
data/lib/synvert/core/node_query/compiler/integer.rb +0 -23
data/lib/synvert/core/node_query/compiler/invalid_operator_error.rb +0 -7
data/lib/synvert/core/node_query/compiler/nil.rb +0 -23
data/lib/synvert/core/node_query/compiler/parse_error.rb +0 -7
data/lib/synvert/core/node_query/compiler/regexp.rb +0 -37
data/lib/synvert/core/node_query/compiler/selector.rb +0 -138
data/lib/synvert/core/node_query/compiler/simple_selector.rb +0 -29
data/lib/synvert/core/node_query/compiler/string.rb +0 -23
data/lib/synvert/core/node_query/compiler/symbol.rb +0 -23
data/lib/synvert/core/node_query/compiler.rb +0 -25
data/lib/synvert/core/node_query/lexer.rex +0 -108
data/lib/synvert/core/node_query/lexer.rex.rb +0 -321
data/lib/synvert/core/node_query/parser.racc.rb +0 -322
data/lib/synvert/core/node_query/parser.y +0 -62
data/lib/synvert/core/node_query.rb +0 -37
data/lib/synvert/core/rewriter/action/append_action.rb +0 -28
data/lib/synvert/core/rewriter/action/delete_action.rb +0 -32
data/lib/synvert/core/rewriter/action/insert_action.rb +0 -34
data/lib/synvert/core/rewriter/action/insert_after_action.rb +0 -22
data/lib/synvert/core/rewriter/action/prepend_action.rb +0 -44
data/lib/synvert/core/rewriter/action/remove_action.rb +0 -53
data/lib/synvert/core/rewriter/action/replace_action.rb +0 -33
data/lib/synvert/core/rewriter/action/replace_with_action.rb +0 -36
data/lib/synvert/core/rewriter/action/wrap_action.rb +0 -37
data/lib/synvert/core/rewriter/action.rb +0 -102
data/spec/synvert/core/node_query/lexer_spec.rb +0 -640
data/spec/synvert/core/node_query/parser_spec.rb +0 -382
data/spec/synvert/core/rewriter/action/append_action_spec.rb +0 -70
data/spec/synvert/core/rewriter/action/delete_action_spec.rb +0 -26
data/spec/synvert/core/rewriter/action/insert_action_spec.rb +0 -70
data/spec/synvert/core/rewriter/action/insert_after_action_spec.rb +0 -26
data/spec/synvert/core/rewriter/action/prepend_action_spec.rb +0 -175
data/spec/synvert/core/rewriter/action/remove_action_spec.rb +0 -26
data/spec/synvert/core/rewriter/action/replace_action_spec.rb +0 -28
data/spec/synvert/core/rewriter/action/replace_with_action_spec.rb +0 -59
data/spec/synvert/core/rewriter/action/wrap_action_spec.rb +0 -31
data/spec/synvert/core/rewriter/action_spec.rb +0 -14

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

@@ -1,382 +0,0 @@
-require 'spec_helper'
-def assert_parser(source)
-  expect(parser.parse(source).to_s).to eq source
-end
-module Synvert::Core::NodeQuery
-  RSpec.describe Parser do
-    let(:parser) { described_class.new }
-    describe '#toString' do
-      it 'parses one selector' do
-        source = '.send[message=:create]'
-        assert_parser(source)
-      end
-      it 'parses two selectors' do
-        source = '.class[name=Synvert] .def[name="foobar"]'
-        assert_parser(source)
-      end
-      it 'parses three selectors' do
-        source = '.class[name=Synvert] .def[name="foobar"] .send[message=create]'
-        assert_parser(source)
-      end
-      it 'parses child selector' do
-        source = '.class[name=Synvert] > .def[name="foobar"]'
-        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)
-      end
-      it 'parses :last-child' do
-        source = '.class .def:last-child'
-        assert_parser(source)
-      end
-      it 'parses :nth-child(n)' do
-        source = '.class .def:nth-child(2)'
-        assert_parser(source)
-      end
-      it 'parses :nth-last-child(n)' do
-        source = '.class .def:nth-last-child(2)'
-        assert_parser(source)
-      end
-      it 'parses :has selector' do
-        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
-      it 'parses multiple attributes' do
-        source = '.send[receiver=nil][message=:create]'
-        assert_parser(source)
-      end
-      it 'parses nested attributes' do
-        source = '.send[receiver.message=:create]'
-        assert_parser(source)
-      end
-      it 'parses selector value' do
-        source = '.send[receiver=.send[message=:create]]'
-        assert_parser(source)
-      end
-      it 'parses start with operator' do
-        source = '.def[name^=synvert]'
-        assert_parser(source)
-      end
-      it 'parses end with operator' do
-        source = '.def[name$=synvert]'
-        assert_parser(source)
-      end
-      it 'parses contain operator' do
-        source = '.def[name*=synvert]'
-        assert_parser(source)
-      end
-      it 'parses not equal operator' do
-        source = '.send[receiver=.send[message!=:create]]'
-        assert_parser(source)
-      end
-      it 'parses greater than operator' do
-        source = '.send[receiver=.send[arguments.size>1]]'
-        assert_parser(source)
-      end
-      it 'parses greater than or equal operator' do
-        source = '.send[receiver=.send[arguments.size>=1]]'
-        assert_parser(source)
-      end
-      it 'parses less than operator' do
-        source = '.send[receiver=.send[arguments.size<1]]'
-        assert_parser(source)
-      end
-      it 'parses less than or equal operator' do
-        source = '.send[receiver=.send[arguments.size<=1]]'
-        assert_parser(source)
-      end
-      it 'parses in operator' do
-        source = '.def[name in (foo bar)]'
-        assert_parser(source)
-      end
-      it 'parses not_in operator' do
-        source = '.def[name not in (foo bar)]'
-        assert_parser(source)
-      end
-      it 'parses includes operator' do
-        source = '.def[arguments includes &block]'
-        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
-    end
-    describe '#query_nodes' do
-      let(:node) {
-        parse(<<~EOS)
-          class Synvert
-            def foo
-              FactoryBot.create(:user, name: 'foo')
-            end
-            def bar
-              FactoryBot.create(:user, name: 'bar')
-            end
-            def foobar(a, b)
-              { a: a, b: b }
-              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]
-      end
-      it 'matches def node' do
-        expression = parser.parse('.def')
-        expect(expression.query_nodes(node)).to eq node.body
-      end
-      it 'matches first def node' do
-        expression = parser.parse('.def:first-child')
-        expect(expression.query_nodes(node)).to eq [node.body.first]
-      end
-      it 'matches nested first node' do
-        expression = parser.parse('.def[arguments.size=0] .send:first-child')
-        expect(expression.query_nodes(node)).to eq [node.body.first.body.first, node.body.second.body.first]
-      end
-      it 'matches last def node' do
-        expression = parser.parse('.def:last-child')
-        expect(expression.query_nodes(node)).to eq [node.body.last]
-      end
-      it 'matches nth-child node' do
-        expression = parser.parse('.def:nth-child(2)')
-        expect(expression.query_nodes(node)).to eq [node.body.second]
-      end
-      it 'matches nth-last-child node' do
-        expression = parser.parse('.def:nth-last-child(2)')
-        expect(expression.query_nodes(node)).to eq [node.body[-2]]
-      end
-      it 'matches start with' do
-        expression = parser.parse('.def[name^=foo]')
-        expect(expression.query_nodes(node)).to eq [node.body.first, node.body.last]
-      end
-      it 'matches end with' do
-        expression = parser.parse('.def[name$=bar]')
-        expect(expression.query_nodes(node)).to eq [node.body.second, node.body.last]
-      end
-      it 'matches contain' do
-        expression = parser.parse('.def[name*=oob]')
-        expect(expression.query_nodes(node)).to eq [node.body.last]
-      end
-      it 'matches not equal' do
-        expression = parser.parse('.def[name!=foobar]')
-        expect(expression.query_nodes(node)).to eq [node.body.first, node.body.second]
-      end
-      it 'matches in' do
-        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)]')
-        expect(expression.query_nodes(node)).to eq [node.body.last]
-      end
-      it 'matches includes' do
-        expression = parser.parse('.def[arguments INCLUDES a]')
-        expect(expression.query_nodes(node)).to eq [node.body.last]
-      end
-      it 'matches equal array' do
-        expression = parser.parse('.def[arguments=(a b)]')
-        expect(expression.query_nodes(node)).to eq [node.body.last]
-        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)]')
-        expect(expression.query_nodes(node)).to eq [node.body.first, node.body.second]
-        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.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.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.body.last, node.body.second.body.last]
-      end
-      it 'matches next sibling node' do
-        expression = parser.parse('.def[name=foo] + .def[name=bar]')
-        expect(expression.query_nodes(node)).to eq [node.body.second]
-      end
-      it 'matches sebsequent sibling node' do
-        expression = parser.parse('.def[name=foo] ~ .def[name=foobar]')
-        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('.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('.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][arguments.first=.sym][arguments.last=.hash]')
-        expect(expression.query_nodes(node)).to eq [node.body.first.body.last, node.body.second.body.last]
-      end
-      it 'matches regexp value' do
-        expression = parser.parse('.def[name=~/foo/]')
-        expect(expression.query_nodes(node)).to eq [node.body.first, node.body.last]
-        expression = parser.parse('.def[name!~/bar/]')
-        expect(expression.query_nodes(node)).to eq [node.body.first]
-      end
-      it 'matches attribute value' do
-        expression = parser.parse('.pair[key={{value}}]')
-        expect(expression.query_nodes(node)).to eq node.body.last.body.first.children
-      end
-      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=:[]=]')
-        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

data/spec/synvert/core/rewriter/action/append_action_spec.rb DELETED Viewed

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-module Synvert::Core
-  describe Rewriter::AppendAction do
-    describe 'class node' do
-      subject do
-        source = "class User\n  has_many :posts\nend"
-        class_node = Parser::CurrentRuby.parse(source)
-        instance = double(current_node: class_node)
-        Rewriter::AppendAction.new(instance, "def as_json\n  super\nend").process
-      end
-      it 'gets begin_pos' do
-        expect(subject.begin_pos).to eq "class User\n  has_many :posts".length
-      end
-      it 'gets end_pos' do
-        expect(subject.end_pos).to eq "class User\n  has_many :posts".length
-      end
-      it 'gets rewritten_code' do
-        expect(subject.rewritten_code).to eq "\n\n  def as_json\n    super\n  end"
-      end
-    end
-    describe 'begin node' do
-      subject do
-        source = "gem 'rails'\ngem 'mysql2'"
-        begin_node = Parser::CurrentRuby.parse(source)
-        instance = double(current_node: begin_node)
-        Rewriter::AppendAction.new(instance, "gem 'twitter'").process
-      end
-      it 'gets begin_pos' do
-        expect(subject.begin_pos).to eq "gem 'rails'\ngem 'mysql2'".length
-      end
-      it 'gets end_pos' do
-        expect(subject.end_pos).to eq "gem 'rails'\ngem 'mysql2'".length
-      end
-      it 'gets rewritten_code' do
-        expect(subject.rewritten_code).to eq "\ngem 'twitter'"
-      end
-    end
-    describe 'def node' do
-      subject do
-        source = "def teardown\n  do_something\nend"
-        class_node = Parser::CurrentRuby.parse(source)
-        instance = double(current_node: class_node)
-        Rewriter::AppendAction.new(instance, 'super').process
-      end
-      it 'gets begin_pos' do
-        expect(subject.begin_pos).to eq "def teardown\n  do_something".length
-      end
-      it 'gets end_pos' do
-        expect(subject.end_pos).to eq "def teardown\n  do_something".length
-      end
-      it 'gets rewritten_code' do
-        expect(subject.rewritten_code).to eq "\n  super"
-      end
-    end
-  end
-end

data/spec/synvert/core/rewriter/action/delete_action_spec.rb DELETED Viewed

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-module Synvert::Core
-  describe Rewriter::DeleteAction do
-    subject {
-      source = 'arr.map {}.flatten'
-      node = Parser::CurrentRuby.parse(source)
-      instance = double(current_node: node, file_source: source)
-      Rewriter::DeleteAction.new(instance, :dot, :message).process
-    }
-    it 'gets begin_pos' do
-      expect(subject.begin_pos).to eq 'arr.map {}'.length
-    end
-    it 'gets end_pos' do
-      expect(subject.end_pos).to eq 'arr.map {}.flatten'.length
-    end
-    it 'gets rewritten_code' do
-      expect(subject.rewritten_code).to eq ''
-    end
-  end
-end

data/spec/synvert/core/rewriter/action/insert_action_spec.rb DELETED Viewed

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-module Synvert::Core
-  describe Rewriter::InsertAction do
-    context 'at end' do
-      subject {
-        source = "  User.where(username: 'Richard')"
-        node = Parser::CurrentRuby.parse(source)
-        instance = double(current_node: node)
-        Rewriter::InsertAction.new(instance, '.first', at: 'end').process
-      }
-      it 'gets begin_pos' do
-        expect(subject.begin_pos).to eq "  User.where(username: 'Richard')".length
-      end
-      it 'gets end_pos' do
-        expect(subject.end_pos).to eq "  User.where(username: 'Richard')".length
-      end
-      it 'gets rewritten_code' do
-        expect(subject.rewritten_code).to eq '.first'
-      end
-    end
-    context 'at beginning' do
-      subject {
-        source = "  open('http://test.com')"
-        node = Parser::CurrentRuby.parse(source)
-        instance = double(current_node: node)
-        Rewriter::InsertAction.new(instance, 'URI.', at: 'beginning').process
-      }
-      it 'gets begin_pos' do
-        expect(subject.begin_pos).to eq 2
-      end
-      it 'gets end_pos' do
-        expect(subject.end_pos).to eq 2
-      end
-      it 'gets rewritten_code' do
-        expect(subject.rewritten_code).to eq 'URI.'
-      end
-    end
-    context 'to receiver' do
-      subject {
-        source = "User.where(username: 'Richard')"
-        node = Parser::CurrentRuby.parse(source)
-        instance = double(current_node: node)
-        Rewriter::InsertAction.new(instance, '.active', to: 'receiver', at: 'end').process
-      }
-      it 'gets begin_pos' do
-        expect(subject.begin_pos).to eq "User".length
-      end
-      it 'gets end_pos' do
-        expect(subject.end_pos).to eq "User".length
-      end
-      it 'gets rewritten_code' do
-        expect(subject.rewritten_code).to eq '.active'
-      end
-    end
-  end
-end

data/spec/synvert/core/rewriter/action/insert_after_action_spec.rb DELETED Viewed

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-module Synvert::Core
-  describe Rewriter::InsertAfterAction do
-    subject {
-      source = '  include Foo'
-      node = Parser::CurrentRuby.parse(source)
-      instance = double(current_node: node)
-      Rewriter::InsertAfterAction.new(instance, 'include Bar').process
-    }
-    it 'gets begin_pos' do
-      expect(subject.begin_pos).to eq '  include Foo'.length
-    end
-    it 'gets end_pos' do
-      expect(subject.end_pos).to eq '  include Foo'.length
-    end
-    it 'gets rewritten_code' do
-      expect(subject.rewritten_code).to eq "\n  include Bar"
-    end
-  end
-end