synvert-core 1.4.0 → 1.5.0

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

@@ -1,337 +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 :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 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

@@ -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

@@ -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

@@ -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

@@ -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

data/spec/synvert/core/rewriter/action/prepend_action_spec.rb

@@ -1,175 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Synvert::Core
-  describe Rewriter::PrependAction do
-    describe 'block node without args' do
-      subject {
-        source = "Synvert::Application.configure do\nend"
-        block_node = Parser::CurrentRuby.parse(source)
-        instance = double(current_node: block_node)
-        Rewriter::PrependAction.new(instance, 'config.eager_load = true').process
-      }
-
-      it 'gets begin_pos' do
-        expect(subject.begin_pos).to eq 'Synvert::Application.configure do'.length
-      end
-
-      it 'gets end_pos' do
-        expect(subject.end_pos).to eq 'Synvert::Application.configure do'.length
-      end
-
-      it 'gets rewritten_code' do
-        expect(subject.rewritten_code).to eq "\n  config.eager_load = true"
-      end
-    end
-
-    describe 'block node with args' do
-      subject {
-        source = "RSpec.configure do |config|\nend"
-        block_node = Parser::CurrentRuby.parse(source)
-        instance = double(current_node: block_node)
-        Rewriter::PrependAction.new(instance, '{{arguments.first}}.include FactoryGirl::Syntax::Methods').process
-      }
-
-      it 'gets begin_pos' do
-        expect(subject.begin_pos).to eq 'RSpec.configure do |config|'.length
-      end
-
-      it 'gets end_pos' do
-        expect(subject.end_pos).to eq 'RSpec.configure do |config|'.length
-      end
-
-      it 'gets rewritten_code' do
-        expect(subject.rewritten_code).to eq "\n  config.include FactoryGirl::Syntax::Methods"
-      end
-    end
-
-    describe 'class node without superclass' do
-      subject {
-        source = "class User\n  has_many :posts\nend"
-        class_node = Parser::CurrentRuby.parse(source)
-        instance = double(current_node: class_node)
-        Rewriter::PrependAction.new(instance, 'include Deletable').process
-      }
-
-      it 'gets begin_pos' do
-        expect(subject.begin_pos).to eq 'class User'.length
-      end
-
-      it 'gets end_pos' do
-        expect(subject.end_pos).to eq 'class User'.length
-      end
-
-      it 'gets rewritten_code' do
-        expect(subject.rewritten_code).to eq "\n  include Deletable"
-      end
-    end
-
-    describe 'class node with superclass' do
-      subject {
-        source = "class User < ActiveRecord::Base\n  has_many :posts\nend"
-        class_node = Parser::CurrentRuby.parse(source)
-        instance = double(current_node: class_node)
-        Rewriter::PrependAction.new(instance, 'include Deletable').process
-      }
-
-      it 'gets begin_pos' do
-        expect(subject.begin_pos).to eq 'class User < ActionRecord::Base'.length
-      end
-
-      it 'gets end_pos' do
-        expect(subject.end_pos).to eq 'class User < ActionRecord::Base'.length
-      end
-
-      it 'gets rewritten_code' do
-        expect(subject.rewritten_code).to eq "\n  include Deletable"
-      end
-    end
-
-    describe 'def node without args' do
-      subject do
-        source = "def setup\n  do_something\nend"
-        def_node = Parser::CurrentRuby.parse(source)
-        instance = double(current_node: def_node)
-        Rewriter::PrependAction.new(instance, 'super').process
-      end
-
-      it 'gets begin_pos' do
-        expect(subject.begin_pos).to eq 'def setup'.length
-      end
-
-      it 'gets end_pos' do
-        expect(subject.end_pos).to eq 'def setup'.length
-      end
-
-      it 'gets rewritten_code' do
-        expect(subject.rewritten_code).to eq "\n  super"
-      end
-    end
-
-    describe 'def node with args' do
-      subject do
-        source = "def setup(foobar)\n  do_something\nend"
-        def_node = Parser::CurrentRuby.parse(source)
-        instance = double(current_node: def_node)
-        Rewriter::PrependAction.new(instance, 'super').process
-      end
-
-      it 'gets begin_pos' do
-        expect(subject.begin_pos).to eq 'def setup(foobar)'.length
-      end
-
-      it 'gets end_pos' do
-        expect(subject.end_pos).to eq 'def setup(foobar)'.length
-      end
-
-      it 'gets rewritten_code' do
-        expect(subject.rewritten_code).to eq "\n  super"
-      end
-    end
-
-    describe 'defs node without args' do
-      subject do
-        source = "def self.foo\n  do_something\nend"
-        def_node = Parser::CurrentRuby.parse(source)
-        instance = double(current_node: def_node)
-        Rewriter::PrependAction.new(instance, 'do_something_first').process
-      end
-
-      it 'gets begin_pos' do
-        expect(subject.begin_pos).to eq 'def self.foo'.length
-      end
-
-      it 'gets end_pos' do
-        expect(subject.end_pos).to eq 'def self.foo'.length
-      end
-
-      it 'gets rewritten_code' do
-        expect(subject.rewritten_code).to eq "\n  do_something_first"
-      end
-    end
-
-    describe 'defs node with args' do
-      subject do
-        source = "def self.foo(bar)\n  do_something\nend"
-        def_node = Parser::CurrentRuby.parse(source)
-        instance = double(current_node: def_node)
-        Rewriter::PrependAction.new(instance, 'do_something_first').process
-      end
-
-      it 'gets begin_pos' do
-        expect(subject.begin_pos).to eq 'def self.foo(bar)'.length
-      end
-
-      it 'gets end_pos' do
-        expect(subject.end_pos).to eq 'def self.foo(bar)'.length
-      end
-
-      it 'gets rewritten_code' do
-        expect(subject.rewritten_code).to eq "\n  do_something_first"
-      end
-    end
-  end
-end