code_analyzer 0.5.1 → 0.5.5

data/spec/code_analyzer/sexp_spec.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Sexp do
-  describe 'line' do
+  describe 'line_number' do
     before :each do
       content = <<-EOF
       class Demo
@@ -18,9 +20,12 @@ describe Sexp do
         end
         def condition
           if success?
-            puts "unknown" if output?
+            puts "unknown" if !output?
           elsif fail?
+            1..2
+            3...4
           end
+          pp ::Rails.application
         end
       end
       EOF
@@ -39,6 +44,10 @@ describe Sexp do
       expect(@node.grep_node(sexp_type: :const_ref).line_number).to eq 1
     end
 
+    it 'should return top const line' do
+      expect(@node.grep_node(sexp_type: :top_const_ref).line_number).to eq 20
+    end
+
     it 'should return const path line' do
       expect(@node.grep_node(sexp_type: :const_path_ref).line_number).to eq 3
     end
@@ -70,6 +79,79 @@ describe Sexp do
     it 'should return if_mod line' do
       expect(@node.grep_node(sexp_type: :if_mod).line_number).to eq 15
     end
+
+    it 'should return unary line' do
+      expect(@node.grep_node(sexp_type: :unary).line_number).to eq 15
+    end
+
+    it 'should return assign line' do
+      expect(@node.grep_node(sexp_type: :assign).line_number).to eq 6
+    end
+
+    it 'should return paren line' do
+      expect(@node.grep_node(sexp_type: :paren).line_number).to eq 10
+    end
+
+    it 'should return dot2 line' do
+      expect(@node.grep_node(sexp_type: :dot2).line_number).to eq 17
+    end
+
+    it 'should return dot3 line' do
+      expect(@node.grep_node(sexp_type: :dot3).line_number).to eq 18
+    end
+
+    it 'should return params line' do
+      expect(@node.grep_node(sexp_type: :params).line_number).to be_nil
+    end
+
+    it 'should return params line if not empty' do
+      @node = parse_content(<<~CODE)
+        # @see Foo
+        def foo(a, b)
+        end
+      CODE
+      expect(@node.grep_node(sexp_type: :params).line_number).to eq 2
+    end
+
+    it 'should return stmts_add line' do
+      expect(@node.grep_node(sexp_type: :stmts_add).line_number).to eq 13
+    end
+
+    context 'when a complex code is given' do
+      before :each do
+        @node = parse_content(<<~CODE)
+          def foo(num)
+            unless (num == 0 ? :zero, :other) || !@opts.right?
+              @bar = {}
+            end
+          end
+        CODE
+      end
+
+      it 'should return unless line' do
+        expect(@node.grep_node(sexp_type: :unless).line_number).to eq 2
+      end
+
+      it 'should return paren line' do
+        expect(@node.grep_node(sexp_type: :paren).line_number).to eq 1
+      end
+
+      it 'should return stmts_add line' do
+        expect(@node.grep_node(sexp_type: :stmts_add).line_number).to eq 2
+      end
+
+      it 'should return binary line' do
+        expect(@node.grep_node(sexp_type: :binary).line_number).to eq 2
+      end
+
+      it 'should return unary line' do
+        expect(@node.grep_node(sexp_type: :unary).line_number).to eq 2
+      end
+
+      it 'should return assign line' do
+        expect(@node.grep_node(sexp_type: :assign).line_number).to eq 3
+      end
+    end
   end
 
   describe 'grep_nodes' do
@@ -84,14 +166,12 @@ describe Sexp do
 
     it 'should get the call nodes with receiver current_user' do
       nodes = []
-      @node.grep_nodes(sexp_type: :call, receiver: 'current_user') do |node|
-        nodes << node
-      end
+      @node.grep_nodes(sexp_type: :call, receiver: 'current_user') { |node| nodes << node }
       expect(nodes).to eq [
            s(
              :call,
              s(:vcall, s(:@ident, 'current_user', s(2, 8))),
-             s(:@period, ".", s(2, 20)),
+             s(:@period, '.', s(2, 20)),
              s(:@ident, 'posts', s(2, 21))
            )
          ]
@@ -99,25 +179,23 @@ describe Sexp do
 
     it 'should get the call nodes with different messages' do
       nodes = []
-      @node.grep_nodes(sexp_type: :call, message: %w[posts find]) do |node|
-        nodes << node
-      end
+      @node.grep_nodes(sexp_type: :call, message: %w[posts find]) { |node| nodes << node }
       expect(nodes).to eq [
            s(
              :call,
              s(
                :call,
                s(:vcall, s(:@ident, 'current_user', s(2, 8))),
-               s(:@period, ".", s(2, 20)),
+               s(:@period, '.', s(2, 20)),
                s(:@ident, 'posts', s(2, 21))
              ),
-             s(:@period, ".", s(2, 26)),
+             s(:@period, '.', s(2, 26)),
              s(:@ident, 'find', s(2, 27))
            ),
            s(
              :call,
              s(:vcall, s(:@ident, 'current_user', s(2, 8))),
-             s(:@period, ".", s(2, 20)),
+             s(:@period, '.', s(2, 20)),
              s(:@ident, 'posts', s(2, 21))
            )
          ]
@@ -125,9 +203,7 @@ describe Sexp do
 
     it 'should get the vcall node with to_s' do
       nodes = []
-      @node.grep_nodes(sexp_type: :vcall, to_s: 'current_user') do |node|
-        nodes << node
-      end
+      @node.grep_nodes(sexp_type: :vcall, to_s: 'current_user') { |node| nodes << node }
       expect(nodes).to eq [s(:vcall, s(:@ident, 'current_user', s(2, 8)))]
     end
   end
@@ -147,7 +223,7 @@ describe Sexp do
       expect(node).to eq s(
            :call,
            s(:vcall, s(:@ident, 'current_user', s(2, 8))),
-           s(:@period, ".", s(2, 20)),
+           s(:@period, '.', s(2, 20)),
            s(:@ident, 'posts', s(2, 21))
          )
     end
@@ -170,8 +246,7 @@ describe Sexp do
 
   describe 'receiver' do
     it 'should get receiver of assign node' do
-      node =
-        parse_content('user.name = params[:name]').grep_node(sexp_type: :assign)
+      node = parse_content('user.name = params[:name]').grep_node(sexp_type: :assign)
       receiver = node.receiver
       expect(receiver.sexp_type).to eq :field
       expect(receiver.receiver.to_s).to eq 'user'
@@ -179,8 +254,7 @@ describe Sexp do
     end
 
     it 'should get receiver of field node' do
-      node =
-        parse_content('user.name = params[:name]').grep_node(sexp_type: :field)
+      node = parse_content('user.name = params[:name]').grep_node(sexp_type: :field)
       expect(node.receiver.to_s).to eq 'user'
     end
 
@@ -204,16 +278,12 @@ describe Sexp do
     end
 
     it 'should get receiver of method_add_arg' do
-      node =
-        parse_content('Post.find(:all)').grep_node(sexp_type: :method_add_arg)
+      node = parse_content('Post.find(:all)').grep_node(sexp_type: :method_add_arg)
       expect(node.receiver.to_s).to eq 'Post'
     end
 
     it 'should get receiver of method_add_block' do
-      node =
-        parse_content('Post.save do; end').grep_node(
-          sexp_type: :method_add_block
-        )
+      node = parse_content('Post.save do; end').grep_node(sexp_type: :method_add_block)
       expect(node.receiver.to_s).to eq 'Post'
     end
   end
@@ -234,10 +304,7 @@ describe Sexp do
 
   describe 'base_class' do
     it 'should get base class of class node' do
-      node =
-        parse_content('class User < ActiveRecord::Base; end').grep_node(
-          sexp_type: :class
-        )
+      node = parse_content('class User < ActiveRecord::Base; end').grep_node(sexp_type: :class)
       expect(node.base_class.to_s).to eq 'ActiveRecord::Base'
     end
   end
@@ -263,10 +330,7 @@ describe Sexp do
     end
 
     it 'should get the message of command_call' do
-      node =
-        parse_content('map.resources :posts do; end').grep_node(
-          sexp_type: :command_call
-        )
+      node = parse_content('map.resources :posts do; end').grep_node(sexp_type: :command_call)
       expect(node.message.to_s).to eq 'resources'
     end
 
@@ -291,46 +355,34 @@ describe Sexp do
     end
 
     it 'should get the message of method_add_arg' do
-      node =
-        parse_content('Post.find(:all)').grep_node(sexp_type: :method_add_arg)
+      node = parse_content('Post.find(:all)').grep_node(sexp_type: :method_add_arg)
       expect(node.message.to_s).to eq 'find'
     end
 
     it 'should get the message of method_add_block' do
-      node =
-        parse_content('Post.save do; end').grep_node(
-          sexp_type: :method_add_block
-        )
+      node = parse_content('Post.save do; end').grep_node(sexp_type: :method_add_block)
       expect(node.message.to_s).to eq 'save'
     end
   end
 
   describe 'arguments' do
     it 'should get the arguments of command' do
-      node =
-        parse_content('resources :posts do; end').grep_node(sexp_type: :command)
+      node = parse_content('resources :posts do; end').grep_node(sexp_type: :command)
       expect(node.arguments.sexp_type).to eq :args_add_block
     end
 
     it 'should get the arguments of command_call' do
-      node =
-        parse_content('map.resources :posts do; end').grep_node(
-          sexp_type: :command_call
-        )
+      node = parse_content('map.resources :posts do; end').grep_node(sexp_type: :command_call)
       expect(node.arguments.sexp_type).to eq :args_add_block
     end
 
     it 'should get the arguments of method_add_arg' do
-      node =
-        parse_content('User.find(:all)').grep_node(sexp_type: :method_add_arg)
+      node = parse_content('User.find(:all)').grep_node(sexp_type: :method_add_arg)
       expect(node.arguments.sexp_type).to eq :args_add_block
     end
 
     it 'should get the arguments of method_add_block' do
-      node =
-        parse_content('Post.save(false) do; end').grep_node(
-          sexp_type: :method_add_block
-        )
+      node = parse_content('Post.save(false) do; end').grep_node(sexp_type: :method_add_block)
       expect(node.arguments.sexp_type).to eq :args_add_block
     end
   end
@@ -344,49 +396,30 @@ describe Sexp do
 
   describe 'all' do
     it 'should get all arguments' do
-      node =
-        parse_content("puts 'hello', 'world'").grep_node(
-          sexp_type: :args_add_block
-        )
+      node = parse_content("puts 'hello', 'world'").grep_node(sexp_type: :args_add_block)
       expect(node.all.map(&:to_s)).to eq %w[hello world]
     end
 
     it 'should get all arguments with &:' do
-      node =
-        parse_content('user.posts.map(&:title)').grep_node(
-          sexp_type: :args_add_block
-        )
+      node = parse_content('user.posts.map(&:title)').grep_node(sexp_type: :args_add_block)
       expect(node.all.map(&:to_s)).to eq %w[title]
     end
 
     it 'should get all arguments with command_call node' do
-      node =
-        parse_content('options_for_select(Account.get_business current_user)')
-          .grep_node(sexp_type: :args_add)
+      node = parse_content('options_for_select(Account.get_business current_user)').grep_node(sexp_type: :args_add)
       expect(node.all).to eq [
            s(
              :command_call,
              s(:var_ref, s(:@const, 'Account', s(1, 19))),
-             s(:@period, ".", s(1, 26)),
+             s(:@period, '.', s(1, 26)),
              s(:@ident, 'get_business', s(1, 27)),
-             s(
-               :args_add_block,
-               s(
-                 :args_add,
-                 s(:args_new),
-                 s(:vcall, s(:@ident, 'current_user', s(1, 40)))
-               ),
-               false
-             )
+             s(:args_add_block, s(:args_add, s(:args_new), s(:vcall, s(:@ident, 'current_user', s(1, 40)))), false)
            )
          ]
     end
 
     it 'no error for args_add_star' do
-      node =
-        parse_content("send(:\"\#{route}_url\", *args)").grep_node(
-          sexp_type: :args_add_block
-        )
+      node = parse_content("send(:\"\#{route}_url\", *args)").grep_node(sexp_type: :args_add_block)
       expect { node.all }.not_to raise_error
     end
   end
@@ -403,8 +436,7 @@ describe Sexp do
     end
 
     it 'should get conditional statement of elsif' do
-      node =
-        parse_content('if true; elsif false; end').grep_node(sexp_type: :elsif)
+      node = parse_content('if true; elsif false; end').grep_node(sexp_type: :elsif)
       expect(node.conditional_statement.to_s).to eq 'false'
     end
 
@@ -414,8 +446,7 @@ describe Sexp do
     end
 
     it 'should get conditional statement of unless_mod' do
-      node =
-        parse_content("'OK' unless false").grep_node(sexp_type: :unless_mod)
+      node = parse_content("'OK' unless false").grep_node(sexp_type: :unless_mod)
       expect(node.conditional_statement.to_s).to eq 'false'
     end
 
@@ -427,9 +458,7 @@ describe Sexp do
 
   describe 'all_conditions' do
     it 'should get all conditions' do
-      node =
-        parse_content('user == current_user && user.valid? || user.admin?')
-          .grep_node(sexp_type: :binary)
+      node = parse_content('user == current_user && user.valid? || user.admin?').grep_node(sexp_type: :binary)
       expect(node.all_conditions.size).to eq 3
     end
   end
@@ -463,8 +492,7 @@ describe Sexp do
     end
 
     it 'should get body of module' do
-      node =
-        parse_content('module Enumerable; end').grep_node(sexp_type: :module)
+      node = parse_content('module Enumerable; end').grep_node(sexp_type: :module)
       expect(node.body.sexp_type).to eq :bodystmt
     end
 
@@ -474,22 +502,17 @@ describe Sexp do
     end
 
     it 'should get body of elsif' do
-      node =
-        parse_content("if true; elsif true; 'OK'; end").grep_node(
-          sexp_type: :elsif
-        )
+      node = parse_content("if true; elsif true; 'OK'; end").grep_node(sexp_type: :elsif)
       expect(node.body.sexp_type).to eq :stmts_add
     end
 
     it 'should get body of unless' do
-      node =
-        parse_content("unless true; 'OK'; end").grep_node(sexp_type: :unless)
+      node = parse_content("unless true; 'OK'; end").grep_node(sexp_type: :unless)
       expect(node.body.sexp_type).to eq :stmts_add
     end
 
     it 'should get body of else' do
-      node =
-        parse_content("if true; else; 'OK'; end").grep_node(sexp_type: :else)
+      node = parse_content("if true; else; 'OK'; end").grep_node(sexp_type: :else)
       expect(node.body.sexp_type).to eq :stmts_add
     end
 
@@ -499,8 +522,7 @@ describe Sexp do
     end
 
     it 'should get body of unless_mod' do
-      node =
-        parse_content("'OK' unless false").grep_node(sexp_type: :unless_mod)
+      node = parse_content("'OK' unless false").grep_node(sexp_type: :unless_mod)
       expect(node.body.to_s).to eq 'OK'
     end
 
@@ -512,9 +534,7 @@ describe Sexp do
 
   describe 'block' do
     it 'sould get block of method_add_block node' do
-      node =
-        parse_content('resources :posts do; resources :comments; end')
-          .grep_node(sexp_type: :method_add_block)
+      node = parse_content('resources :posts do; resources :comments; end').grep_node(sexp_type: :method_add_block)
       expect(node.block_node.sexp_type).to eq :do_block
     end
   end
@@ -522,40 +542,29 @@ describe Sexp do
   describe 'statements' do
     it 'should get statements of do_block node' do
       node =
-        parse_content(
-          'resources :posts do; resources :comments; resources :like; end'
-        )
-          .grep_node(sexp_type: :do_block)
+        parse_content('resources :posts do; resources :comments; resources :like; end').grep_node(sexp_type: :do_block)
       expect(node.statements.size).to eq 2
     end
 
     it 'should get statements of bodystmt node' do
-      node =
-        parse_content('class User; def login?; end; def admin?; end; end')
-          .grep_node(sexp_type: :bodystmt)
+      node = parse_content('class User; def login?; end; def admin?; end; end').grep_node(sexp_type: :bodystmt)
       expect(node.statements.size).to eq 2
     end
   end
 
   describe 'exception_classes' do
     it 'should get exception classes of rescue node' do
-      node =
-        parse_content('def test; rescue CustomException; end').grep_node(
-          sexp_type: :rescue
-        )
+      node = parse_content('def test; rescue CustomException; end').grep_node(sexp_type: :rescue)
       expect(node.exception_classes.first.to_s).to eq 'CustomException'
     end
 
     it 'should get empty of empty rescue node' do
-      node =
-        parse_content('def test; rescue; end').grep_node(sexp_type: :rescue)
+      node = parse_content('def test; rescue; end').grep_node(sexp_type: :rescue)
       expect(node.exception_classes.first.to_s).to eq ''
     end
 
     it 'should get exception classes of rescue node for multiple exceptions' do
-      node =
-        parse_content('def test; rescue StandardError, CustomException; end')
-          .grep_node(sexp_type: :rescue)
+      node = parse_content('def test; rescue StandardError, CustomException; end').grep_node(sexp_type: :rescue)
       expect(node.exception_classes.first.to_s).to eq 'StandardError'
       expect(node.exception_classes.last.to_s).to eq 'CustomException'
     end
@@ -563,36 +572,28 @@ describe Sexp do
 
   describe 'exception_variable' do
     it 'should get exception varible of rescue node' do
-      node =
-        parse_content('def test; rescue => e; end').grep_node(
-          sexp_type: :rescue
-        )
+      node = parse_content('def test; rescue => e; end').grep_node(sexp_type: :rescue)
       expect(node.exception_variable.to_s).to eq 'e'
     end
 
     it 'should get empty of empty rescue node' do
-      node =
-        parse_content('def test; rescue; end').grep_node(sexp_type: :rescue)
+      node = parse_content('def test; rescue; end').grep_node(sexp_type: :rescue)
       expect(node.exception_variable.to_s).to eq ''
     end
   end
 
   describe 'hash_value' do
     it 'should get value for hash node' do
-      node =
-        parse_content("{first_name: 'Richard', last_name: 'Huang'}").grep_node(
-          sexp_type: :hash
-        )
+      node = parse_content("{first_name: 'Richard', last_name: 'Huang'}").grep_node(sexp_type: :hash)
       expect(node.hash_value('first_name').to_s).to eq 'Richard'
       expect(node.hash_value('last_name').to_s).to eq 'Huang'
     end
 
     it 'should get value for bare_assoc_hash' do
       node =
-        parse_content(
-          "add_user :user, first_name: 'Richard', last_name: 'Huang'"
+        parse_content("add_user :user, first_name: 'Richard', last_name: 'Huang'").grep_node(
+          sexp_type: :bare_assoc_hash
         )
-          .grep_node(sexp_type: :bare_assoc_hash)
       expect(node.hash_value('first_name').to_s).to eq 'Richard'
       expect(node.hash_value('last_name').to_s).to eq 'Huang'
     end
@@ -600,67 +601,88 @@ describe Sexp do
 
   describe 'hash_size' do
     it 'should get value for hash node' do
-      node =
-        parse_content("{first_name: 'Richard', last_name: 'Huang'}").grep_node(
-          sexp_type: :hash
-        )
+      node = parse_content("{first_name: 'Richard', last_name: 'Huang'}").grep_node(sexp_type: :hash)
       expect(node.hash_size).to eq 2
     end
 
     it 'should get value for bare_assoc_hash' do
       node =
-        parse_content(
-          "add_user :user, first_name: 'Richard', last_name: 'Huang'"
+        parse_content("add_user :user, first_name: 'Richard', last_name: 'Huang'").grep_node(
+          sexp_type: :bare_assoc_hash
         )
-          .grep_node(sexp_type: :bare_assoc_hash)
       expect(node.hash_size).to eq 2
     end
   end
 
   describe 'hash_keys' do
     it 'should get hash_keys for hash node' do
-      node =
-        parse_content("{first_name: 'Richard', last_name: 'Huang'}").grep_node(
-          sexp_type: :hash
-        )
+      node = parse_content("{first_name: 'Richard', last_name: 'Huang'}").grep_node(sexp_type: :hash)
       expect(node.hash_keys).to eq %w[first_name last_name]
     end
 
     it 'should get hash_keys for bare_assoc_hash' do
       node =
-        parse_content(
-          "add_user :user, first_name: 'Richard', last_name: 'Huang'"
+        parse_content("add_user :user, first_name: 'Richard', last_name: 'Huang'").grep_node(
+          sexp_type: :bare_assoc_hash
         )
-          .grep_node(sexp_type: :bare_assoc_hash)
       expect(node.hash_keys).to eq %w[first_name last_name]
     end
   end
 
   describe 'hash_values' do
     it 'should get hash_values for hash node' do
-      node =
-        parse_content("{first_name: 'Richard', last_name: 'Huang'}").grep_node(
-          sexp_type: :hash
-        )
+      node = parse_content("{first_name: 'Richard', last_name: 'Huang'}").grep_node(sexp_type: :hash)
       expect(node.hash_values.map(&:to_s)).to eq %w[Richard Huang]
     end
 
     it 'should get hash_values for bare_assoc_hash' do
       node =
-        parse_content(
-          "add_user :user, first_name: 'Richard', last_name: 'Huang'"
+        parse_content("add_user :user, first_name: 'Richard', last_name: 'Huang'").grep_node(
+          sexp_type: :bare_assoc_hash
         )
-          .grep_node(sexp_type: :bare_assoc_hash)
       expect(node.hash_values.map(&:to_s)).to eq %w[Richard Huang]
     end
   end
 
-  describe 'array_size' do
-    it 'should get array size' do
+  describe 'key' do
+    it 'should get key for assoc_new' do
+      node =
+        parse_content("add_user :user, first_name: 'Richard'").grep_node(
+          sexp_type: :assoc_new
+        )
+      expect(node.key).to eq 'first_name'
+    end
+  end
+
+  describe 'value' do
+    it 'should get value for assoc_new' do
+      node =
+        parse_content("add_user :user, first_name: 'Richard'").grep_node(
+          sexp_type: :assoc_new
+        )
+      expect(node.value).to eq 'Richard'
+    end
+
+    it 'should get value for assoc_new' do
+      node =
+        parse_content("add_user :user, first_name:").grep_node(
+          sexp_type: :assoc_new
+        )
+      expect(node.value).to be_nil
+    end
+
+    it 'should get array value for assoc_new' do
       node =
-        parse_content("['first_name', 'last_name']").grep_node(
-          sexp_type: :array
+        parse_content("add_user :user, name: %w[Richard Huang]").grep_node(
+          sexp_type: :assoc_new
         )
+      expect(node.value.array_values.map(&:to_s)).to eq ['Richard', 'Huang']
+    end
+  end
+
+  describe 'array_size' do
+    it 'should get array size' do
+      node = parse_content("['first_name', 'last_name']").grep_node(sexp_type: :array)
       expect(node.array_size).to eq 2
     end
 
@@ -672,10 +694,7 @@ describe Sexp do
 
   describe 'array_values' do
     it 'should get array values' do
-      node =
-        parse_content("['first_name', 'last_name']").grep_node(
-          sexp_type: :array
-        )
+      node = parse_content("['first_name', 'last_name']").grep_node(sexp_type: :array)
       expect(node.array_values.map(&:to_s)).to eq %w[first_name last_name]
     end
 
@@ -685,8 +704,7 @@ describe Sexp do
     end
 
     it 'should get array value with array and words_add' do
-      node =
-        parse_content('%W{day week fortnight}').grep_node(sexp_type: :array)
+      node = parse_content('%W{day week fortnight}').grep_node(sexp_type: :array)
       expect(node.array_values.map(&:to_s)).to eq %w[day week fortnight]
     end
 
@@ -696,8 +714,7 @@ describe Sexp do
     end
 
     it 'should get array value with array and qwords_add' do
-      node =
-        parse_content('%w(first_name last_name)').grep_node(sexp_type: :array)
+      node = parse_content('%w(first_name last_name)').grep_node(sexp_type: :array)
       expect(node.array_values.map(&:to_s)).to eq %w[first_name last_name]
     end
 
@@ -708,8 +725,7 @@ describe Sexp do
 
     if RUBY_VERSION.to_i > 1
       it 'should get array value with array and symbols_add' do
-        node =
-          parse_content('%I(first_name last_name)').grep_node(sexp_type: :array)
+        node = parse_content('%I(first_name last_name)').grep_node(sexp_type: :array)
         expect(node.array_values.map(&:to_s)).to eq %w[first_name last_name]
       end
 
@@ -719,8 +735,7 @@ describe Sexp do
       end
 
       it 'should get array value with array and qsymbols_add' do
-        node =
-          parse_content('%i(first_name last_name)').grep_node(sexp_type: :array)
+        node = parse_content('%i(first_name last_name)').grep_node(sexp_type: :array)
         expect(node.array_values.map(&:to_s)).to eq %w[first_name last_name]
       end
 
@@ -733,9 +748,7 @@ describe Sexp do
 
   describe 'alias' do
     context 'method' do
-      before do
-        @node = parse_content('alias new old').grep_node(sexp_type: :alias)
-      end
+      before { @node = parse_content('alias new old').grep_node(sexp_type: :alias) }
 
       it 'should get old_method' do
         expect(@node.old_method.to_s).to eq 'old'
@@ -747,9 +760,7 @@ describe Sexp do
     end
 
     context 'symbol' do
-      before do
-        @node = parse_content('alias :new :old').grep_node(sexp_type: :alias)
-      end
+      before { @node = parse_content('alias :new :old').grep_node(sexp_type: :alias) }
 
       it 'should get old_method' do
         expect(@node.old_method.to_s).to eq 'old'
@@ -763,10 +774,7 @@ describe Sexp do
 
   describe 'to_object' do
     it 'should to array' do
-      node =
-        parse_content("['first_name', 'last_name']").grep_node(
-          sexp_type: :array
-        )
+      node = parse_content("['first_name', 'last_name']").grep_node(sexp_type: :array)
       expect(node.to_object).to eq %w[first_name last_name]
     end
 
@@ -776,8 +784,7 @@ describe Sexp do
     end
 
     it 'should to array with symbols' do
-      node =
-        parse_content('[:first_name, :last_name]').grep_node(sexp_type: :array)
+      node = parse_content('[:first_name, :last_name]').grep_node(sexp_type: :array)
       expect(node.to_object).to eq %w[first_name last_name]
     end
 
@@ -819,16 +826,12 @@ describe Sexp do
     end
 
     it 'should get to_s for class with module' do
-      node =
-        parse_content('ActiveRecord::Base').grep_node(
-          sexp_type: :const_path_ref
-        )
+      node = parse_content('ActiveRecord::Base').grep_node(sexp_type: :const_path_ref)
       expect(node.to_s).to eq 'ActiveRecord::Base'
     end
 
     it 'should get to_s for label' do
-      node =
-        parse_content("{first_name: 'Richard'}").grep_node(sexp_type: :@label)
+      node = parse_content("{first_name: 'Richard'}").grep_node(sexp_type: :@label)
       expect(node.to_s).to eq 'first_name'
     end
 
@@ -876,15 +879,11 @@ describe Sexp do
 
   describe 'remove_line_and_column' do
     it 'should remove' do
-      s(:@ident, 'test', s(2, 12)).remove_line_and_column.should_equal s(
-                                                                      :@ident,
-                                                                      'test'
-                                                                    )
+      s(:@ident, 'test', s(2, 12)).remove_line_and_column.should_equal s(:@ident, 'test')
     end
 
     it 'should remove child nodes' do
-      s(:const_ref, s(:@const, 'Demo', s(1, 12)))
-        .remove_line_and_column.should_equal s(:const_def, s(:@const, 'Demo'))
+      s(:const_ref, s(:@const, 'Demo', s(1, 12))).remove_line_and_column.should_equal s(:const_def, s(:@const, 'Demo'))
     end
   end
 end