code_analyzer 0.4.8 → 0.5.0

data/lib/code_analyzer/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module CodeAnalyzer
-  VERSION = "0.4.8"
+  VERSION = '0.5.0'
 end

data/lib/code_analyzer/warning.rb

@@ -6,7 +6,7 @@ module CodeAnalyzer
   class Warning
     attr_reader :filename, :line_number, :message
 
-    def initialize(options={})
+    def initialize(options = {})
       @filename = options[:filename]
       @line_number = options[:line_number].to_s
       @message = options[:message]

data/spec/code_analyzer/checker_spec.rb

@@ -4,55 +4,59 @@ module CodeAnalyzer
   describe Checker do
     let(:checker) { Checker.new }
 
-    context "interesting_nodes" do
-      it "should get empty interesting nodes" do
+    context 'interesting_nodes' do
+      it 'should get empty interesting nodes' do
         expect(checker.interesting_nodes).to eq []
       end
 
-      it "should add interesting nodes" do
+      it 'should add interesting nodes' do
         Checker.interesting_nodes :class, :def
-        expect(checker.interesting_nodes).to eq [:class, :def]
+        expect(checker.interesting_nodes).to eq %i[class def]
       end
     end
 
-    context "interesting_files" do
-      it "should match none of interesting files" do
+    context 'interesting_files' do
+      it 'should match none of interesting files' do
         expect(checker.interesting_files).to eq []
       end
 
-      it "should add interesting files" do
+      it 'should add interesting files' do
         Checker.interesting_files /lib/, /spec/
         expect(checker.interesting_files).to eq [/lib/, /spec/]
       end
     end
 
-    context "#parse_file?" do
-      it "should return true if node_file matches pattern" do
-        allow(checker).to receive(:interesting_files).and_return([/spec\/.*\.rb/, /lib\/.*\.rb/])
-        expect(checker.parse_file?("lib/code_analyzer.rb")).to be true
+    context '#parse_file?' do
+      it 'should return true if node_file matches pattern' do
+        allow(checker).to receive(:interesting_files).and_return(
+          [%r{spec\/.*\.rb}, %r{lib\/.*\.rb}]
+        )
+        expect(checker.parse_file?('lib/code_analyzer.rb')).to be true
       end
 
       it "should return false if node_file doesn't match pattern" do
-        allow(checker).to receive(:interesting_files).and_return([/spec\/.*\.rb/])
-        expect(checker.parse_file?("lib/code_analyzer.rb")).to be false
+        allow(checker).to receive(:interesting_files).and_return(
+          [%r{spec\/.*\.rb}]
+        )
+        expect(checker.parse_file?('lib/code_analyzer.rb')).to be false
       end
     end
 
-    context "callback" do
-      it "should add callback to start_call" do
+    context 'callback' do
+      it 'should add callback to start_call' do
         block = Proc.new {}
         Checker.add_callback(:start_call, &block)
         expect(Checker.get_callbacks(:start_call)).to eq [block]
       end
 
-      it "should add callback to both start_class and end_class" do
+      it 'should add callback to both start_class and end_class' do
         block = Proc.new {}
         Checker.add_callback(:start_class, :end_class, &block)
         expect(Checker.get_callbacks(:start_class)).to eq [block]
         expect(Checker.get_callbacks(:end_class)).to eq [block]
       end
 
-      it "should add multiple callbacks to end_call" do
+      it 'should add multiple callbacks to end_call' do
         block1 = Proc.new {}
         block2 = Proc.new {}
         Checker.add_callback(:end_call, &block1)

data/spec/code_analyzer/checking_visitor/default_spec.rb

@@ -1,14 +1,14 @@
-require "spec_helper"
+require 'spec_helper'
 
 module CodeAnalyzer::CheckingVisitor
   describe Default do
-    let(:checker1) { double(:checker, interesting_nodes: [:class, :def]) }
-    let(:checker2) { double(:checker, interesting_nodes: [:def, :call]) }
+    let(:checker1) { double(:checker, interesting_nodes: %i[class def]) }
+    let(:checker2) { double(:checker, interesting_nodes: %i[def call]) }
     let(:visitor) { Default.new(checkers: [checker1, checker2]) }
 
-    it "should check def node by all checkers" do
-      filename = "filename"
-      content = "def test; end"
+    it 'should check def node by all checkers' do
+      filename = 'filename'
+      content = 'def test; end'
       allow(checker1).to receive(:parse_file?).with(filename).and_return(true)
       allow(checker2).to receive(:parse_file?).with(filename).and_return(true)
       expect(checker1).to receive(:node_start)
@@ -19,9 +19,9 @@ module CodeAnalyzer::CheckingVisitor
       visitor.check(filename, content)
     end
 
-    it "should check class node by only checker1" do
-      filename = "filename"
-      content = "class Test; end"
+    it 'should check class node by only checker1' do
+      filename = 'filename'
+      content = 'class Test; end'
       allow(checker1).to receive(:parse_file?).with(filename).and_return(true)
       expect(checker1).to receive(:node_start)
       expect(checker1).to receive(:node_end)
@@ -29,9 +29,9 @@ module CodeAnalyzer::CheckingVisitor
       visitor.check(filename, content)
     end
 
-    it "should check call node by only checker2" do
-      filename = "filename"
-      content = "obj.message"
+    it 'should check call node by only checker2' do
+      filename = 'filename'
+      content = 'obj.message'
       allow(checker2).to receive(:parse_file?).with(filename).and_return(true)
       expect(checker2).to receive(:node_start)
       expect(checker2).to receive(:node_end)

data/spec/code_analyzer/checking_visitor/plain_spec.rb

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 
 module CodeAnalyzer::CheckingVisitor
   describe Plain do
@@ -6,9 +6,9 @@ module CodeAnalyzer::CheckingVisitor
     let(:checker2) { double(:checker) }
     let(:visitor) { Plain.new(checkers: [checker1, checker2]) }
 
-    it "should check by all checkers" do
-      filename = "filename"
-      content = "content"
+    it 'should check by all checkers' do
+      filename = 'filename'
+      content = 'content'
       expect(checker1).to receive(:parse_file?).and_return(false)
       expect(checker2).to receive(:parse_file?).and_return(true)
       expect(checker1).not_to receive(:check).with(filename, content)

data/spec/code_analyzer/nil_spec.rb

@@ -4,32 +4,32 @@ module CodeAnalyzer
   describe Nil do
     let(:core_nil) { Nil.new }
 
-    context "to_s" do
-      it "should return self" do
+    context 'to_s' do
+      it 'should return self' do
         expect(core_nil.to_s).to eq core_nil
       end
     end
 
-    context "hash_size" do
-      it "should return 0" do
+    context 'hash_size' do
+      it 'should return 0' do
         expect(core_nil.hash_size).to eq 0
       end
     end
 
-    context "method_missing" do
-      it "should return self" do
+    context 'method_missing' do
+      it 'should return self' do
         expect(core_nil.undefined).to eq core_nil
       end
     end
 
-    context "present?" do
-      it "should return false" do
+    context 'present?' do
+      it 'should return false' do
         expect(core_nil).not_to be_present
       end
     end
 
-    context "blank?" do
-      it "should return true" do
+    context 'blank?' do
+      it 'should return true' do
         expect(core_nil).to be_blank
       end
     end

data/spec/code_analyzer/sexp_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Sexp do
-  describe "line" do
+  describe 'line' do
     before :each do
       content = <<-EOF
       class Demo
@@ -27,52 +27,52 @@ describe Sexp do
       @node = parse_content(content)
     end
 
-    it "should return class line" do
+    it 'should return class line' do
       expect(@node.grep_node(sexp_type: :class).line_number).to eq 1
     end
 
-    it "should return def line" do
+    it 'should return def line' do
       expect(@node.grep_node(sexp_type: :def).line_number).to eq 2
     end
 
-    it "should return const line" do
+    it 'should return const line' do
       expect(@node.grep_node(sexp_type: :const_ref).line_number).to eq 1
     end
 
-    it "should return const path line" do
+    it 'should return const path line' do
       expect(@node.grep_node(sexp_type: :const_path_ref).line_number).to eq 3
     end
 
-    it "should return alias line" do
+    it 'should return alias line' do
       expect(@node.grep_node(sexp_type: :alias).line_number).to eq 5
     end
 
-    it "should return hash line" do
+    it 'should return hash line' do
       expect(@node.grep_node(sexp_type: :hash).line_number).to eq 6
     end
 
-    it "should return massign line" do
+    it 'should return massign line' do
       expect(@node.grep_node(sexp_type: :massign).line_number).to eq 8
     end
 
-    it "should return opassign line" do
+    it 'should return opassign line' do
       expect(@node.grep_node(sexp_type: :opassign).line_number).to eq 11
     end
 
-    it "should return if line" do
+    it 'should return if line' do
       expect(@node.grep_node(sexp_type: :if).line_number).to eq 14
     end
 
-    it "should return elsif line" do
+    it 'should return elsif line' do
       expect(@node.grep_node(sexp_type: :elsif).line_number).to eq 16
     end
 
-    it "should return if_mod line" do
+    it 'should return if_mod line' do
       expect(@node.grep_node(sexp_type: :if_mod).line_number).to eq 15
     end
   end
 
-  describe "grep_nodes" do
+  describe 'grep_nodes' do
     before :each do
       content = <<-EOF
       def show
@@ -82,42 +82,100 @@ describe Sexp do
       @node = parse_content(content)
     end
 
-    it "should get the call nodes with receiver current_user" do
+    it 'should get the call nodes with receiver current_user' do
       nodes = []
-      @node.grep_nodes(sexp_type: :call, receiver: "current_user") { |node| nodes << node }
-      if RUBY_VERSION == "1.9.2"
-        expect(nodes).to eq [s(:call, s(:var_ref, s(:@ident, "current_user", s(2, 8))), :".", s(:@ident, "posts", s(2, 21)))]
+      @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(:@ident, "posts", s(2, 21)))]
+        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
     end
 
-    it "should get the call nodes with different messages" do
+    it 'should get the call nodes with different messages' do
       nodes = []
-      @node.grep_nodes(sexp_type: :call, message: ["posts", "find"]) { |node| nodes << node }
-      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(:@ident, "posts", s(2, 21))), :".", s(:@ident, "find", s(2, 27))), s(:call, s(:var_ref, s(:@ident, "current_user", s(2, 8))), :".", s(:@ident, "posts", s(2, 21)))]
+      @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(:@ident, "posts", s(2, 21))), :".", s(:@ident, "find", s(2, 27))), s(:call, s(:vcall, s(:@ident, "current_user", s(2, 8))), :".", s(:@ident, "posts", s(2, 21)))]
+        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))
+             ),
+             s(
+               :call,
+               s(:vcall, s(:@ident, 'current_user', s(2, 8))),
+               s(:@period, ".", s(2, 20)),
+               s(:@ident, 'posts', s(2, 21))
+             )
+           ]
       end
     end
 
-    if RUBY_VERSION == "1.9.2"
-      it "should get the var_ref node with to_s" do
+    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") { |node| nodes << node }
-        expect(nodes).to eq [s(:var_ref, s(:@ident, "current_user", s(2, 8)))]
+        @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
+      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)))]
+        @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
     end
   end
 
-  describe "grep_node" do
+  describe 'grep_node' do
     before :each do
       content = <<-EOF
       def show
@@ -127,17 +185,27 @@ describe Sexp do
       @node = parse_content(content)
     end
 
-    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(:@ident, "posts", s(2, 21)))
+    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(:@ident, "posts", s(2, 21)))
+        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
   end
 
-  describe "grep_nodes_count" do
+  describe 'grep_nodes_count' do
     before :each do
       content = <<-EOF
       def show
@@ -147,597 +215,743 @@ describe Sexp do
       @node = parse_content(content)
     end
 
-    it "should get the count of call nodes" do
+    it 'should get the count of call nodes' do
       expect(@node.grep_nodes_count(sexp_type: :call)).to eq 2
     end
   end
 
-  describe "receiver" do
-    it "should get receiver of assign node" do
-      node = parse_content("user.name = params[:name]").grep_node(sexp_type: :assign)
+  describe 'receiver' do
+    it 'should get receiver of assign node' do
+      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"
-      expect(receiver.message.to_s).to eq "name"
+      expect(receiver.receiver.to_s).to eq 'user'
+      expect(receiver.message.to_s).to eq 'name'
     end
 
-    it "should get receiver of field node" do
-      node = parse_content("user.name = params[:name]").grep_node(sexp_type: :field)
-      expect(node.receiver.to_s).to eq "user"
+    it 'should get receiver of field node' do
+      node =
+        parse_content('user.name = params[:name]').grep_node(sexp_type: :field)
+      expect(node.receiver.to_s).to eq 'user'
     end
 
-    it "should get receiver of call node" do
-      node = parse_content("user.name").grep_node(sexp_type: :call)
-      expect(node.receiver.to_s).to eq "user"
+    it 'should get receiver of call node' do
+      node = parse_content('user.name').grep_node(sexp_type: :call)
+      expect(node.receiver.to_s).to eq 'user'
     end
 
-    it "should get receiver of binary" do
+    it 'should get receiver of binary' do
       node = parse_content("user == 'user_name'").grep_node(sexp_type: :binary)
-      expect(node.receiver.to_s).to eq "user"
+      expect(node.receiver.to_s).to eq 'user'
     end
 
-    it "should get receiver of command_call" do
+    it 'should get receiver of command_call' do
       content = <<-EOF
       map.resources :posts do
       end
       EOF
       node = parse_content(content).grep_node(sexp_type: :command_call)
-      expect(node.receiver.to_s).to eq "map"
+      expect(node.receiver.to_s).to eq 'map'
     end
 
-    it "should get receiver of method_add_arg" do
-      node = parse_content("Post.find(:all)").grep_node(sexp_type: :method_add_arg)
-      expect(node.receiver.to_s).to eq "Post"
+    it 'should get receiver of method_add_arg' do
+      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)
-      expect(node.receiver.to_s).to eq "Post"
+    it 'should get receiver of method_add_block' do
+      node =
+        parse_content('Post.save do; end').grep_node(
+          sexp_type: :method_add_block
+        )
+      expect(node.receiver.to_s).to eq 'Post'
     end
   end
 
-  describe "module_name" do
-    it "should get module name of module node" do
-      node = parse_content("module Admin; end").grep_node(sexp_type: :module)
-      expect(node.module_name.to_s).to eq "Admin"
+  describe 'module_name' do
+    it 'should get module name of module node' do
+      node = parse_content('module Admin; end').grep_node(sexp_type: :module)
+      expect(node.module_name.to_s).to eq 'Admin'
     end
   end
 
-  describe "class_name" do
-    it "should get class name of class node" do
-      node = parse_content("class User; end").grep_node(sexp_type: :class)
-      expect(node.class_name.to_s).to eq "User"
+  describe 'class_name' do
+    it 'should get class name of class node' do
+      node = parse_content('class User; end').grep_node(sexp_type: :class)
+      expect(node.class_name.to_s).to eq 'User'
     end
   end
 
-  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)
-      expect(node.base_class.to_s).to eq "ActiveRecord::Base"
+  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
+        )
+      expect(node.base_class.to_s).to eq 'ActiveRecord::Base'
     end
   end
 
-  describe "left_value" do
-    it "should get the left value of assign" do
-      node = parse_content("user = current_user").grep_node(sexp_type: :assign)
-      expect(node.left_value.to_s).to eq "user"
+  describe 'left_value' do
+    it 'should get the left value of assign' do
+      node = parse_content('user = current_user').grep_node(sexp_type: :assign)
+      expect(node.left_value.to_s).to eq 'user'
     end
   end
 
-  describe "right_value" do
-    it "should get the right value of assign" do
-      node = parse_content("user = current_user").grep_node(sexp_type: :assign)
-      expect(node.right_value.to_s).to eq "current_user"
+  describe 'right_value' do
+    it 'should get the right value of assign' do
+      node = parse_content('user = current_user').grep_node(sexp_type: :assign)
+      expect(node.right_value.to_s).to eq 'current_user'
     end
   end
 
-  describe "message" do
-    it "should get the message of command" do
-      node = parse_content("has_many :projects").grep_node(sexp_type: :command)
-      expect(node.message.to_s).to eq "has_many"
+  describe 'message' do
+    it 'should get the message of command' do
+      node = parse_content('has_many :projects').grep_node(sexp_type: :command)
+      expect(node.message.to_s).to eq 'has_many'
     end
 
-    it "should get the message of command_call" do
-      node = parse_content("map.resources :posts do; end").grep_node(sexp_type: :command_call)
-      expect(node.message.to_s).to eq "resources"
+    it 'should get the message of command_call' do
+      node =
+        parse_content('map.resources :posts do; end').grep_node(
+          sexp_type: :command_call
+        )
+      expect(node.message.to_s).to eq 'resources'
     end
 
-    it "should get the message of field" do
+    it 'should get the message of field' do
       node = parse_content("user.name = 'test'").grep_node(sexp_type: :field)
-      expect(node.message.to_s).to eq "name"
+      expect(node.message.to_s).to eq 'name'
     end
 
-    it "should get the message of call" do
-      node = parse_content("user.name").grep_node(sexp_type: :call)
-      expect(node.message.to_s).to eq "name"
+    it 'should get the message of call' do
+      node = parse_content('user.name').grep_node(sexp_type: :call)
+      expect(node.message.to_s).to eq 'name'
     end
 
-    it "should get the message of binary" do
+    it 'should get the message of binary' do
       node = parse_content("user.name == 'test'").grep_node(sexp_type: :binary)
-      expect(node.message.to_s).to eq "=="
+      expect(node.message.to_s).to eq '=='
     end
 
-    it "should get the message of fcall" do
+    it 'should get the message of fcall' do
       node = parse_content("test?('world')").grep_node(sexp_type: :fcall)
-      expect(node.message.to_s).to eq "test?"
+      expect(node.message.to_s).to eq 'test?'
     end
 
-    it "should get the message of method_add_arg" do
-      node = parse_content("Post.find(:all)").grep_node(sexp_type: :method_add_arg)
-      expect(node.message.to_s).to eq "find"
+    it 'should get the message of method_add_arg' do
+      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)
-      expect(node.message.to_s).to eq "save"
+    it 'should get the message of method_add_block' do
+      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)
+  describe 'arguments' do
+    it 'should get the arguments of command' do
+      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)
+    it 'should get the arguments of command_call' do
+      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)
+    it 'should get the arguments of method_add_arg' do
+      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)
+    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
+        )
       expect(node.arguments.sexp_type).to eq :args_add_block
     end
   end
 
-  describe "argument" do
-    it "should get the argument of binary" do
-      node = parse_content("user == current_user").grep_node(sexp_type: :binary)
-      expect(node.argument.to_s).to eq "current_user"
-    end
-  end
-
-  describe "all" do
-    it "should get all arguments" do
-      node = parse_content("puts 'hello', 'world'").grep_node(sexp_type: :args_add_block)
-      expect(node.all.map(&:to_s)).to eq ["hello", "world"]
-    end
-
-    it "should get all arguments with &:" do
-      node = parse_content("user.posts.map(&:title)").grep_node(sexp_type: :args_add_block)
-      expect(node.all.map(&:to_s)).to eq ["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))]
+  describe 'argument' do
+    it 'should get the argument of binary' do
+      node = parse_content('user == current_user').grep_node(sexp_type: :binary)
+      expect(node.argument.to_s).to eq 'current_user'
+    end
+  end
+
+  describe 'all' do
+    it 'should get all arguments' do
+      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
+        )
+      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(:@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))]
+        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
     end
 
-    it "no error for args_add_star" do
-      node = parse_content("send(:\"\#{route}_url\", *args)").grep_node(sexp_type: :args_add_block)
+    it 'no error for args_add_star' do
+      node =
+        parse_content("send(:\"\#{route}_url\", *args)").grep_node(
+          sexp_type: :args_add_block
+        )
       expect { node.all }.not_to raise_error
     end
   end
 
-  describe "conditional_statement" do
-    it "should get conditional statement of if" do
-      node = parse_content("if true; end").grep_node(sexp_type: :if)
-      expect(node.conditional_statement.to_s).to eq "true"
+  describe 'conditional_statement' do
+    it 'should get conditional statement of if' do
+      node = parse_content('if true; end').grep_node(sexp_type: :if)
+      expect(node.conditional_statement.to_s).to eq 'true'
     end
 
-    it "should get conditional statement of unless" do
-      node = parse_content("unless false; end").grep_node(sexp_type: :unless)
-      expect(node.conditional_statement.to_s).to eq "false"
+    it 'should get conditional statement of unless' do
+      node = parse_content('unless false; end').grep_node(sexp_type: :unless)
+      expect(node.conditional_statement.to_s).to eq 'false'
     end
 
-    it "should get conditional statement of elsif" do
-      node = parse_content("if true; elsif false; end").grep_node(sexp_type: :elsif)
-      expect(node.conditional_statement.to_s).to eq "false"
+    it 'should get conditional statement of elsif' do
+      node =
+        parse_content('if true; elsif false; end').grep_node(sexp_type: :elsif)
+      expect(node.conditional_statement.to_s).to eq 'false'
     end
 
-    it "should get conditional statement of if_mod" do
+    it 'should get conditional statement of if_mod' do
       node = parse_content("'OK' if true").grep_node(sexp_type: :if_mod)
-      expect(node.conditional_statement.to_s).to eq "true"
+      expect(node.conditional_statement.to_s).to eq 'true'
     end
 
-    it "should get conditional statement of unless_mod" do
-      node = parse_content("'OK' unless false").grep_node(sexp_type: :unless_mod)
-      expect(node.conditional_statement.to_s).to eq "false"
+    it 'should get conditional statement of unless_mod' do
+      node =
+        parse_content("'OK' unless false").grep_node(sexp_type: :unless_mod)
+      expect(node.conditional_statement.to_s).to eq 'false'
     end
 
-    it "should get conditional statement of ifop" do
+    it 'should get conditional statement of ifop' do
       node = parse_content("true ? 'OK' : 'NO'").grep_node(sexp_type: :ifop)
-      expect(node.conditional_statement.to_s).to eq "true"
+      expect(node.conditional_statement.to_s).to eq 'true'
     end
   end
 
-  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)
+  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)
       expect(node.all_conditions.size).to eq 3
     end
   end
 
-  describe "method_name" do
-    it "should get the method name of def" do
-      node = parse_content("def show; end").grep_node(sexp_type: :def)
-      expect(node.method_name.to_s).to eq "show"
+  describe 'method_name' do
+    it 'should get the method name of def' do
+      node = parse_content('def show; end').grep_node(sexp_type: :def)
+      expect(node.method_name.to_s).to eq 'show'
     end
 
-    it "should get the method name of defs" do
-      node = parse_content("def self.find; end").grep_node(sexp_type: :defs)
-      expect(node.method_name.to_s).to eq "find"
+    it 'should get the method name of defs' do
+      node = parse_content('def self.find; end').grep_node(sexp_type: :defs)
+      expect(node.method_name.to_s).to eq 'find'
     end
   end
 
-  describe "body" do
-    it "should get body of class" do
-      node = parse_content("class User; end").grep_node(sexp_type: :class)
+  describe 'body' do
+    it 'should get body of class' do
+      node = parse_content('class User; end').grep_node(sexp_type: :class)
       expect(node.body.sexp_type).to eq :bodystmt
     end
 
-    it "should get body of def" do
-      node = parse_content("def login; end").grep_node(sexp_type: :def)
+    it 'should get body of def' do
+      node = parse_content('def login; end').grep_node(sexp_type: :def)
       expect(node.body.sexp_type).to eq :bodystmt
     end
 
-    it "should get body of defs" do
-      node = parse_content("def self.login; end").grep_node(sexp_type: :defs)
+    it 'should get body of defs' do
+      node = parse_content('def self.login; end').grep_node(sexp_type: :defs)
       expect(node.body.sexp_type).to eq :bodystmt
     end
 
-    it "should get body of module" do
-      node = parse_content("module Enumerable; end").grep_node(sexp_type: :module)
+    it 'should get body of module' do
+      node =
+        parse_content('module Enumerable; end').grep_node(sexp_type: :module)
       expect(node.body.sexp_type).to eq :bodystmt
     end
 
-    it "should get body of if" do
+    it 'should get body of if' do
       node = parse_content("if true; 'OK'; end").grep_node(sexp_type: :if)
       expect(node.body.sexp_type).to eq :stmts_add
     end
 
-    it "should get body of elsif" do
-      node = parse_content("if true; elsif true; 'OK'; end").grep_node(sexp_type: :elsif)
+    it 'should get body of elsif' do
+      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)
+    it 'should get body of unless' do
+      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)
+    it 'should get body of else' do
+      node =
+        parse_content("if true; else; 'OK'; end").grep_node(sexp_type: :else)
       expect(node.body.sexp_type).to eq :stmts_add
     end
 
-    it "should get body of if_mod" do
+    it 'should get body of if_mod' do
       node = parse_content("'OK' if true").grep_node(sexp_type: :if_mod)
-      expect(node.body.to_s).to eq "OK"
+      expect(node.body.to_s).to eq 'OK'
     end
 
-    it "should get body of unless_mod" do
-      node = parse_content("'OK' unless false").grep_node(sexp_type: :unless_mod)
-      expect(node.body.to_s).to eq "OK"
+    it 'should get body of unless_mod' do
+      node =
+        parse_content("'OK' unless false").grep_node(sexp_type: :unless_mod)
+      expect(node.body.to_s).to eq 'OK'
     end
 
-    it "should get body of if_op" do
+    it 'should get body of if_op' do
       node = parse_content("true ? 'OK' : 'NO'").grep_node(sexp_type: :ifop)
-      expect(node.body.to_s).to eq "OK"
+      expect(node.body.to_s).to eq 'OK'
     end
   end
 
-  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)
+  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)
       expect(node.block_node.sexp_type).to eq :do_block
     end
   end
 
-  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)
+  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)
       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)
+    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)
       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)
-      expect(node.exception_classes.first.to_s).to eq "CustomException"
+  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
+        )
+      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)
-      expect(node.exception_classes.first.to_s).to eq ""
+    it 'should get empty of empty rescue node' do
+      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)
-      expect(node.exception_classes.first.to_s).to eq "StandardError"
-      expect(node.exception_classes.last.to_s).to eq "CustomException"
+    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)
+      expect(node.exception_classes.first.to_s).to eq 'StandardError'
+      expect(node.exception_classes.last.to_s).to eq 'CustomException'
     end
   end
 
-  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)
-      expect(node.exception_variable.to_s).to eq "e"
+  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
+        )
+      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)
-      expect(node.exception_variable.to_s).to eq ""
+    it 'should get empty of empty rescue node' do
+      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)
-      expect(node.hash_value("first_name").to_s).to eq "Richard"
-      expect(node.hash_value("last_name").to_s).to eq "Huang"
+  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
+        )
+      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'").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"
+    it 'should get value for bare_assoc_hash' do
+      node =
+        parse_content(
+          "add_user :user, first_name: 'Richard', last_name: 'Huang'"
+        )
+          .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
   end
 
-  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)
+  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
+        )
       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'").grep_node(sexp_type: :bare_assoc_hash)
+    it 'should get value for bare_assoc_hash' do
+      node =
+        parse_content(
+          "add_user :user, first_name: 'Richard', last_name: 'Huang'"
+        )
+          .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)
-      expect(node.hash_keys).to eq ["first_name", "last_name"]
+  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
+        )
+      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'").grep_node(sexp_type: :bare_assoc_hash)
-      expect(node.hash_keys).to eq ["first_name", "last_name"]
+    it 'should get hash_keys for bare_assoc_hash' do
+      node =
+        parse_content(
+          "add_user :user, first_name: 'Richard', last_name: 'Huang'"
+        )
+          .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)
-      expect(node.hash_values.map(&:to_s)).to eq ["Richard", "Huang"]
+  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
+        )
+      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'").grep_node(sexp_type: :bare_assoc_hash)
-      expect(node.hash_values.map(&:to_s)).to eq ["Richard", "Huang"]
+    it 'should get hash_values for bare_assoc_hash' do
+      node =
+        parse_content(
+          "add_user :user, first_name: 'Richard', last_name: 'Huang'"
+        )
+          .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
-      node = parse_content("['first_name', 'last_name']").grep_node(sexp_type: :array)
+  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
 
-    it "should get 0" do
-      node = parse_content("[]").grep_node(sexp_type: :array)
+    it 'should get 0' do
+      node = parse_content('[]').grep_node(sexp_type: :array)
       expect(node.array_size).to eq 0
     end
   end
 
-  describe "array_values" do
-    it "should get array values" do
-      node = parse_content("['first_name', 'last_name']").grep_node(sexp_type: :array)
-      expect(node.array_values.map(&:to_s)).to eq ["first_name", "last_name"]
+  describe 'array_values' do
+    it 'should get array values' do
+      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
 
-    it "should get empty array values" do
-      node = parse_content("[]").grep_node(sexp_type: :array)
+    it 'should get empty array values' do
+      node = parse_content('[]').grep_node(sexp_type: :array)
       expect(node.array_values).to eq []
     end
 
-    it "should get array value with array and words_add" do
-      node = parse_content("%W{day week fortnight}").grep_node(sexp_type: :array)
-      expect(node.array_values.map(&:to_s)).to eq ["day", "week", "fortnight"]
+    it 'should get array value with array and words_add' do
+      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
 
-    it "should get empty array values with array and words_add" do
-      node = parse_content("%W{}").grep_node(sexp_type: :array)
+    it 'should get empty array values with array and words_add' do
+      node = parse_content('%W{}').grep_node(sexp_type: :array)
       expect(node.array_values.map(&:to_s)).to eq []
     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)
-      expect(node.array_values.map(&:to_s)).to eq ["first_name", "last_name"]
+    it 'should get array value with array and qwords_add' do
+      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
 
-    it "should get empty array values with array and qwords_add" do
-      node = parse_content("%w()").grep_node(sexp_type: :array)
+    it 'should get empty array values with array and qwords_add' do
+      node = parse_content('%w()').grep_node(sexp_type: :array)
       expect(node.array_values.map(&:to_s)).to eq []
     end
 
     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)
-        expect(node.array_values.map(&:to_s)).to eq ["first_name", "last_name"]
+      it 'should get array value with array and symbols_add' do
+        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
 
-      it "should get empty array value with array and symbols_add" do
-        node = parse_content("%I()").grep_node(sexp_type: :array)
+      it 'should get empty array value with array and symbols_add' do
+        node = parse_content('%I()').grep_node(sexp_type: :array)
         expect(node.array_values.map(&:to_s)).to eq []
       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)
-        expect(node.array_values.map(&:to_s)).to eq ["first_name", "last_name"]
+      it 'should get array value with array and qsymbols_add' do
+        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
 
-      it "should get empty array values with array and qsymbols_new" do
-        node = parse_content("%i()").grep_node(sexp_type: :array)
+      it 'should get empty array values with array and qsymbols_new' do
+        node = parse_content('%i()').grep_node(sexp_type: :array)
         expect(node.array_values.map(&:to_s)).to eq []
       end
     end
   end
 
-  describe "alias" do
-    context "method" do
+  describe 'alias' do
+    context 'method' do
       before do
-        @node = parse_content("alias new old").grep_node(sexp_type: :alias)
+        @node = parse_content('alias new old').grep_node(sexp_type: :alias)
       end
 
-      it "should get old_method" do
-        expect(@node.old_method.to_s).to eq "old"
+      it 'should get old_method' do
+        expect(@node.old_method.to_s).to eq 'old'
       end
 
-      it "should get new_method" do
-        expect(@node.new_method.to_s).to eq "new"
+      it 'should get new_method' do
+        expect(@node.new_method.to_s).to eq 'new'
       end
     end
 
-    context "symbol" do
+    context 'symbol' do
       before do
-        @node = parse_content("alias :new :old").grep_node(sexp_type: :alias)
+        @node = parse_content('alias :new :old').grep_node(sexp_type: :alias)
       end
 
-      it "should get old_method" do
-        expect(@node.old_method.to_s).to eq "old"
+      it 'should get old_method' do
+        expect(@node.old_method.to_s).to eq 'old'
       end
 
-      it "should get new_method" do
-        expect(@node.new_method.to_s).to eq "new"
+      it 'should get new_method' do
+        expect(@node.new_method.to_s).to eq 'new'
       end
     end
   end
 
-  describe "to_object" do
-    it "should to array" do
-      node = parse_content("['first_name', 'last_name']").grep_node(sexp_type: :array)
-      expect(node.to_object).to eq ["first_name", "last_name"]
+  describe 'to_object' do
+    it 'should to array' do
+      node =
+        parse_content("['first_name', 'last_name']").grep_node(
+          sexp_type: :array
+        )
+      expect(node.to_object).to eq %w[first_name last_name]
     end
 
-    it "should to array with %w()" do
-      node = parse_content("%w(new create)").grep_node(sexp_type: :array)
-      expect(node.to_object).to eq ["new", "create"]
+    it 'should to array with %w()' do
+      node = parse_content('%w(new create)').grep_node(sexp_type: :array)
+      expect(node.to_object).to eq %w[new create]
     end
 
-    it "should to array with symbols" do
-      node = parse_content("[:first_name, :last_name]").grep_node(sexp_type: :array)
-      expect(node.to_object).to eq ["first_name", "last_name"]
+    it 'should to array with symbols' do
+      node =
+        parse_content('[:first_name, :last_name]').grep_node(sexp_type: :array)
+      expect(node.to_object).to eq %w[first_name last_name]
     end
 
-    it "should to empty array" do
-      node = parse_content("[]").grep_node(sexp_type: :array)
+    it 'should to empty array' do
+      node = parse_content('[]').grep_node(sexp_type: :array)
       expect(node.to_object).to eq []
     end
 
-    it "should to string" do
+    it 'should to string' do
       node = parse_content("'richard'").grep_node(sexp_type: :string_literal)
-      expect(node.to_object).to eq "richard"
+      expect(node.to_object).to eq 'richard'
     end
   end
 
-  describe "to_s" do
-    it "should get to_s for string" do
+  describe 'to_s' do
+    it 'should get to_s for string' do
       node = parse_content("'user'").grep_node(sexp_type: :string_literal)
-      expect(node.to_s).to eq "user"
+      expect(node.to_s).to eq 'user'
     end
 
-    it "should get to_s for symbol" do
-      node = parse_content(":user").grep_node(sexp_type: :symbol_literal)
-      expect(node.to_s).to eq "user"
+    it 'should get to_s for symbol' do
+      node = parse_content(':user').grep_node(sexp_type: :symbol_literal)
+      expect(node.to_s).to eq 'user'
     end
 
-    it "should get to_s for const" do
-      node = parse_content("User").grep_node(sexp_type: :@const)
-      expect(node.to_s).to eq "User"
+    it 'should get to_s for const' do
+      node = parse_content('User').grep_node(sexp_type: :@const)
+      expect(node.to_s).to eq 'User'
     end
 
-    it "should get to_s for ivar" do
-      node = parse_content("@user").grep_node(sexp_type: :@ivar)
-      expect(node.to_s).to eq "@user"
+    it 'should get to_s for ivar' do
+      node = parse_content('@user').grep_node(sexp_type: :@ivar)
+      expect(node.to_s).to eq '@user'
     end
 
-    it "should get to_s for class with module" do
-      node = parse_content("ActiveRecord::Base").grep_node(sexp_type: :const_path_ref)
-      expect(node.to_s).to eq "ActiveRecord::Base"
+    it 'should get to_s for class with module' do
+      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)
-      expect(node.to_s).to eq "first_name"
+    it 'should get to_s for label' do
+      node =
+        parse_content("{first_name: 'Richard'}").grep_node(sexp_type: :@label)
+      expect(node.to_s).to eq 'first_name'
     end
 
-    it "should get to_s for call" do
-      node = parse_content("current_user.post").grep_node(sexp_type: :call)
-      expect(node.to_s).to eq "current_user.post"
+    it 'should get to_s for call' do
+      node = parse_content('current_user.post').grep_node(sexp_type: :call)
+      expect(node.to_s).to eq 'current_user.post'
     end
 
-    it "should get to_s for top_const_ref" do
-      node = parse_content("::User").grep_node(sexp_type: :top_const_ref)
-      expect(node.to_s).to eq "::User"
+    it 'should get to_s for top_const_ref' do
+      node = parse_content('::User').grep_node(sexp_type: :top_const_ref)
+      expect(node.to_s).to eq '::User'
     end
   end
 
-  describe "const?" do
-    it "should return true for const with var_ref" do
-      node = parse_content("User.find").grep_node(sexp_type: :var_ref)
+  describe 'const?' do
+    it 'should return true for const with var_ref' do
+      node = parse_content('User.find').grep_node(sexp_type: :var_ref)
       expect(node).to be_const
     end
 
-    it "should return true for const with @const" do
-      node = parse_content("User.find").grep_node(sexp_type: :@const)
+    it 'should return true for const with @const' do
+      node = parse_content('User.find').grep_node(sexp_type: :@const)
       expect(node).to be_const
     end
 
-    it "should return false for ivar" do
-      node = parse_content("@user.find").grep_node(sexp_type: :@ivar)
+    it 'should return false for ivar' do
+      node = parse_content('@user.find').grep_node(sexp_type: :@ivar)
       expect(node).not_to be_const
     end
   end
 
-  describe "present?" do
-    it "should return true" do
-      node = parse_content("hello world")
+  describe 'present?' do
+    it 'should return true' do
+      node = parse_content('hello world')
       expect(node).to be_present
     end
   end
 
-  describe "blank?" do
-    it "should return false" do
-      node = parse_content("hello world")
+  describe 'blank?' do
+    it 'should return false' do
+      node = parse_content('hello world')
       expect(node).not_to be_blank
     end
   end
 
-  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")
+  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'
+                                                                    )
     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"))
+    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'))
     end
   end
 end