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

synvert-core 1.3.0 → 1.5.0

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