code_analyzer 0.5.0 → 0.5.4

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,94 +166,45 @@ 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
-      if RUBY_VERSION == '1.9.2'
-        expect(nodes).to eq [
-             s(
-               :call,
-               s(:var_ref, s(:@ident, 'current_user', s(2, 8))),
-               s(:@period, ".", s(2, 20)),
-               s(:@ident, 'posts', s(2, 21))
-             )
-           ]
-      else
-        expect(nodes).to eq [
-             s(
-               :call,
-               s(:vcall, s(:@ident, 'current_user', s(2, 8))),
-               s(:@period, ".", s(2, 20)),
-               s(:@ident, 'posts', s(2, 21))
-             )
-           ]
-      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(:@ident, 'posts', s(2, 21))
+           )
+         ]
     end
 
     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
-      if RUBY_VERSION == '1.9.2'
-        expect(nodes).to eq [
-             s(
-               :call,
-               s(
-                 :call,
-                 s(:var_ref, s(:@ident, 'current_user', s(2, 8))),
-                 s(:@period, ".", s(2, 20)),
-                 s(:@ident, 'posts', s(2, 21))
-               ),
-               s(:@period, ".", s(2, 26)),
-               s(:@ident, 'find', s(2, 27))
-             ),
-             s(
-               :call,
-               s(:var_ref, s(:@ident, 'current_user', s(2, 8))),
-               s(:@period, ".", s(2, 20)),
-               s(:@ident, 'posts', s(2, 21))
-             )
-           ]
-      else
-        expect(nodes).to eq [
-             s(
-               :call,
-               s(
-                 :call,
-                 s(:vcall, s(:@ident, 'current_user', s(2, 8))),
-                 s(:@period, ".", s(2, 20)),
-                 s(:@ident, 'posts', s(2, 21))
-               ),
-               s(:@period, ".", s(2, 26)),
-               s(:@ident, 'find', s(2, 27))
-             ),
+      @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))
-             )
-           ]
-      end
+             ),
+             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(:@ident, 'posts', s(2, 21))
+           )
+         ]
     end
 
-    if RUBY_VERSION == '1.9.2'
-      it 'should get the var_ref node with to_s' do
-        nodes = []
-        @node.grep_nodes(sexp_type: :var_ref, to_s: 'current_user') do |node|
-          nodes << node
-        end
-        expect(nodes).to eq [s(:var_ref, s(:@ident, 'current_user', s(2, 8)))]
-      end
-    else
-      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
-        expect(nodes).to eq [s(:vcall, s(:@ident, 'current_user', s(2, 8)))]
-      end
+    it 'should get the vcall node with to_s' do
+      nodes = []
+      @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
 
@@ -187,21 +220,12 @@ describe Sexp do
 
     it 'should get first node with empty argument' do
       node = @node.grep_node(sexp_type: :call, receiver: 'current_user')
-      if RUBY_VERSION == '1.9.2'
-        expect(node).to eq s(
-             :call,
-             s(:var_ref, s(:@ident, 'current_user', s(2, 8))),
-             s(:@period, ".", s(2, 20)),
-             s(:@ident, 'posts', s(2, 21))
-           )
-      else
-        expect(node).to eq s(
-             :call,
-             s(:vcall, s(:@ident, 'current_user', s(2, 8))),
-             s(:@period, ".", s(2, 20)),
-             s(:@ident, 'posts', s(2, 21))
-           )
-      end
+      expect(node).to eq s(
+           :call,
+           s(:vcall, s(:@ident, 'current_user', s(2, 8))),
+           s(:@period, '.', s(2, 20)),
+           s(:@ident, 'posts', s(2, 21))
+         )
     end
   end
 
@@ -222,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'
@@ -231,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
 
@@ -256,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
@@ -286,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
@@ -315,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
 
@@ -343,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
@@ -396,69 +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)
-      if RUBY_VERSION == '1.9.2'
-        expect(node.all).to eq [
-             s(
-               :command_call,
-               s(:var_ref, s(:@const, 'Account', s(1, 19))),
-               :".",
-               s(:@ident, 'get_business', s(1, 27)),
-               s(
-                 :args_add_block,
-                 s(
-                   :args_add,
-                   s(:args_new),
-                   s(:var_ref, s(:@ident, 'current_user', s(1, 40)))
-                 ),
-                 false
-               )
-             )
-           ]
-      else
-        expect(node.all).to eq [
-             s(
-               :command_call,
-               s(:var_ref, s(:@const, 'Account', s(1, 19))),
-               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
-               )
-             )
-           ]
-      end
+      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(:@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)
+           )
+         ]
     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
@@ -475,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
 
@@ -486,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
 
@@ -499,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
@@ -535,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
 
@@ -546,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
 
@@ -571,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
 
@@ -584,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
@@ -594,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
@@ -635,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
@@ -672,67 +601,80 @@ 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("['first_name', 'last_name']").grep_node(
-          sexp_type: :array
+        parse_content("add_user :user, first_name: 'Richard'").grep_node(
+          sexp_type: :assoc_new
         )
+      expect(node.value).to eq 'Richard'
+    end
+
+    it 'should get array value for assoc_new' do
+      node =
+        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
 
@@ -744,10 +686,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
 
@@ -757,8 +696,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
 
@@ -768,8 +706,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
 
@@ -780,8 +717,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
 
@@ -791,8 +727,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
 
@@ -805,9 +740,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'
@@ -819,9 +752,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'
@@ -835,10 +766,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
 
@@ -848,8 +776,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
 
@@ -885,17 +812,18 @@ describe Sexp do
       expect(node.to_s).to eq '@user'
     end
 
+    it 'should get to_s for period' do
+      node = parse_content('@user.name').grep_node(sexp_type: :@period)
+      expect(node.to_s).to eq '.'
+    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
 
@@ -943,15 +871,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