code_analyzer 0.4.4 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1313a9c7eebbf19bc331a99a0f809d7d3045b0d2
-  data.tar.gz: b681f810a0971fb916cde01d97d80fbf78b1af0c
+  metadata.gz: 2853b6068c4e2ed70d3968b12fdd7cd7e012d1a1
+  data.tar.gz: 8baf7c2d33f0d38229171c111d5e6b78e3f1c457
 SHA512:
-  metadata.gz: c32a12cedaa8586b3aa1398bc1e2da6226b426838c6a13b2bc95b9fc9f7a641d747d4cbdfb114d416d70e4f4f747f5496fad891ccd0f2a75248672e215f069ad
-  data.tar.gz: 12bd4b30529bdbc137463836a9ccc813676ec128b2760685eef02e452d41ff279963c9853047f5135235ff2e825a4647fe31be0ccc6b685ffd6a748ba4873d6c
+  metadata.gz: 341df6c7d531dc8f208c8bb6930a1a0e63f1c6d9f5f654c15c7ff0a237c85eea200c4225140c1fd651eba2b42bde2720b8ce7318f8a9fa25d8694e0133d1111a
+  data.tar.gz: 68e901019d4d3a0d0b68120d5c6df966e6fe6540fdb335f1b0c5c1b254dced6853c7dda6174e1a784827c539a62f08f293c59f9011a2e8aac81005505f4bf56d

data/lib/code_analyzer/sexp.rb

@@ -836,6 +836,8 @@ class Sexp
       "#{self[1]}[#{self[2]}]"
     when :call, :field
       "#{self.receiver}.#{self.message}"
+    when :top_const_ref
+      "::#{self[1]}"
     else
       ""
     end

data/lib/code_analyzer/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module CodeAnalyzer
-  VERSION = "0.4.4"
+  VERSION = "0.4.5"
 end

data/spec/code_analyzer/checker_spec.rb

@@ -6,35 +6,35 @@ module CodeAnalyzer
 
     context "interesting_nodes" do
       it "should get empty interesting nodes" do
-        checker.interesting_nodes.should == []
+        expect(checker.interesting_nodes).to eq []
       end
 
       it "should add interesting nodes" do
         Checker.interesting_nodes :class, :def
-        checker.interesting_nodes.should == [:class, :def]
+        expect(checker.interesting_nodes).to eq [:class, :def]
       end
     end
 
     context "interesting_files" do
       it "should match none of interesting files" do
-        checker.interesting_files.should == []
+        expect(checker.interesting_files).to eq []
       end
 
       it "should add interesting files" do
         Checker.interesting_files /lib/, /spec/
-        checker.interesting_files.should == [/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
-        checker.stub(:interesting_files).and_return([/spec\/.*\.rb/, /lib\/.*\.rb/])
-        checker.parse_file?("lib/code_analyzer.rb").should be_true
+        allow(checker).to receive(:interesting_files).and_return([/spec\/.*\.rb/, /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
-        checker.stub(:interesting_files).and_return([/spec\/.*\.rb/])
-        checker.parse_file?("lib/code_analyzer.rb").should be_false
+        allow(checker).to receive(:interesting_files).and_return([/spec\/.*\.rb/])
+        expect(checker.parse_file?("lib/code_analyzer.rb")).to be_false
       end
     end
 
@@ -42,14 +42,14 @@ module CodeAnalyzer
       it "should add callback to start_call" do
         block = Proc.new {}
         Checker.add_callback(:start_call, &block)
-        Checker.get_callbacks(:start_call).should == [block]
+        expect(Checker.get_callbacks(:start_call)).to eq [block]
       end
 
       it "should add callback to both start_class and end_class" do
         block = Proc.new {}
         Checker.add_callback(:start_class, :end_class, &block)
-        Checker.get_callbacks(:start_class).should == [block]
-        Checker.get_callbacks(:end_class).should == [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
@@ -57,7 +57,7 @@ module CodeAnalyzer
         block2 = Proc.new {}
         Checker.add_callback(:end_call, &block1)
         Checker.add_callback(:end_call, &block2)
-        Checker.get_callbacks(:end_call).should == [block1, block2]
+        expect(Checker.get_callbacks(:end_call)).to eq [block1, block2]
       end
     end
   end

data/spec/code_analyzer/checking_visitor/base_spec.rb

@@ -5,11 +5,11 @@ module CodeAnalyzer
     describe Base do
       it "should return all checkers' warnings" do
         warning1 = Warning.new
-        checker1 = mock(:checker, warnings: [warning1])
+        checker1 = double(:checker, warnings: [warning1])
         warning2 = Warning.new
-        checker2 = mock(:checker, warnings: [warning2])
+        checker2 = double(:checker, warnings: [warning2])
         visitor = Base.new(checkers: [checker1, checker2])
-        visitor.warnings.should == [warning1, warning2]
+        expect(visitor.warnings).to eq [warning1, warning2]
       end
     end
   end

data/spec/code_analyzer/checking_visitor/default_spec.rb

@@ -2,19 +2,19 @@ require "spec_helper"
 
 module CodeAnalyzer::CheckingVisitor
   describe Default do
-    let(:checker1) { mock(:checker, interesting_nodes: [:class, :def]) }
-    let(:checker2) { mock(:checker, interesting_nodes: [:def, :call]) }
+    let(:checker1) { double(:checker, interesting_nodes: [:class, :def]) }
+    let(:checker2) { double(:checker, interesting_nodes: [:def, :call]) }
     let(:visitor) { Default.new(checkers: [checker1, checker2]) }
 
     it "should check def node by all checkers" do
       filename = "filename"
       content = "def test; end"
-      checker1.stub(:parse_file?).with(filename).and_return(true)
-      checker2.stub(:parse_file?).with(filename).and_return(true)
-      checker1.should_receive(:node_start)
-      checker1.should_receive(:node_end)
-      checker2.should_receive(:node_start)
-      checker2.should_receive(:node_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)
+      expect(checker1).to receive(:node_end)
+      expect(checker2).to receive(:node_start)
+      expect(checker2).to receive(:node_end)
 
       visitor.check(filename, content)
     end
@@ -22,9 +22,9 @@ module CodeAnalyzer::CheckingVisitor
     it "should check class node by only checker1" do
       filename = "filename"
       content = "class Test; end"
-      checker1.stub(:parse_file?).with(filename).and_return(true)
-      checker1.should_receive(:node_start)
-      checker1.should_receive(:node_end)
+      allow(checker1).to receive(:parse_file?).with(filename).and_return(true)
+      expect(checker1).to receive(:node_start)
+      expect(checker1).to receive(:node_end)
 
       visitor.check(filename, content)
     end
@@ -32,9 +32,9 @@ module CodeAnalyzer::CheckingVisitor
     it "should check call node by only checker2" do
       filename = "filename"
       content = "obj.message"
-      checker2.stub(:parse_file?).with(filename).and_return(true)
-      checker2.should_receive(:node_start)
-      checker2.should_receive(:node_end)
+      allow(checker2).to receive(:parse_file?).with(filename).and_return(true)
+      expect(checker2).to receive(:node_start)
+      expect(checker2).to receive(:node_end)
 
       visitor.check(filename, content)
     end

data/spec/code_analyzer/checking_visitor/plain_spec.rb

@@ -2,17 +2,17 @@ require "spec_helper"
 
 module CodeAnalyzer::CheckingVisitor
   describe Plain do
-    let(:checker1) { mock(:checker) }
-    let(:checker2) { mock(:checker) }
+    let(:checker1) { double(:checker) }
+    let(:checker2) { double(:checker) }
     let(:visitor) { Plain.new(checkers: [checker1, checker2]) }
 
     it "should check by all checkers" do
       filename = "filename"
       content = "content"
-      checker1.should_receive(:parse_file?).and_return(false)
-      checker2.should_receive(:parse_file?).and_return(true)
+      expect(checker1).to receive(:parse_file?).and_return(false)
+      expect(checker2).to receive(:parse_file?).and_return(true)
       checker1.should_not_receive(:check).with(filename, content)
-      checker2.should_receive(:check).with(filename, content)
+      expect(checker2).to receive(:check).with(filename, content)
 
       visitor.check(filename, content)
     end

data/spec/code_analyzer/nil_spec.rb

@@ -6,31 +6,31 @@ module CodeAnalyzer
 
     context "to_s" do
       it "should return self" do
-        core_nil.to_s.should == core_nil
+        expect(core_nil.to_s).to eq core_nil
       end
     end
 
     context "hash_size" do
       it "should return 0" do
-        core_nil.hash_size.should == 0
+        expect(core_nil.hash_size).to eq 0
       end
     end
 
     context "method_missing" do
       it "should return self" do
-        core_nil.undefined.should == core_nil
+        expect(core_nil.undefined).to eq core_nil
       end
     end
 
     context "present?" do
       it "should return false" do
-        core_nil.should_not be_present
+        expect(core_nil).not_to be_present
       end
     end
 
     context "blank?" do
       it "should return true" do
-        core_nil.should be_blank
+        expect(core_nil).to be_blank
       end
     end
   end

data/spec/code_analyzer/sexp_spec.rb

@@ -28,35 +28,35 @@ describe Sexp do
     end
 
     it "should return class line" do
-      @node.grep_node(sexp_type: :class).line_number.should == 1
+      expect(@node.grep_node(sexp_type: :class).line_number).to eq 1
     end
 
     it "should return def line" do
-      @node.grep_node(sexp_type: :def).line_number.should == 2
+      expect(@node.grep_node(sexp_type: :def).line_number).to eq 2
     end
 
     it "should return const line" do
-      @node.grep_node(sexp_type: :const_ref).line_number.should == 1
+      expect(@node.grep_node(sexp_type: :const_ref).line_number).to eq 1
     end
 
     it "should return const path line" do
-      @node.grep_node(sexp_type: :const_path_ref).line_number.should == 3
+      expect(@node.grep_node(sexp_type: :const_path_ref).line_number).to eq 3
     end
 
     it "should return alias line" do
-      @node.grep_node(sexp_type: :alias).line_number.should == 5
+      expect(@node.grep_node(sexp_type: :alias).line_number).to eq 5
     end
 
     it "should return hash line" do
-      @node.grep_node(sexp_type: :hash).line_number.should == 6
+      expect(@node.grep_node(sexp_type: :hash).line_number).to eq 6
     end
 
     it "should return massign line" do
-      @node.grep_node(sexp_type: :massign).line_number.should == 8
+      expect(@node.grep_node(sexp_type: :massign).line_number).to eq 8
     end
 
     it "should return opassign line" do
-      @node.grep_node(sexp_type: :opassign).line_number.should == 11
+      expect(@node.grep_node(sexp_type: :opassign).line_number).to eq 11
     end
 
     it "should return if line" do
@@ -86,9 +86,9 @@ describe Sexp do
       nodes = []
       @node.grep_nodes(sexp_type: :call, receiver: "current_user") { |node| nodes << node }
       if RUBY_VERSION == "1.9.2"
-        nodes.should == [s(:call, s(:var_ref, s(:@ident, "current_user", s(2, 8))), :".", s(:@ident, "posts", s(2, 21)))]
+        expect(nodes).to eq [s(:call, s(:var_ref, s(:@ident, "current_user", s(2, 8))), :".", s(:@ident, "posts", s(2, 21)))]
       else
-        nodes.should == [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(:@ident, "posts", s(2, 21)))]
       end
     end
 
@@ -96,9 +96,9 @@ describe Sexp do
       nodes = []
       @node.grep_nodes(sexp_type: :call, message: ["posts", "find"]) { |node| nodes << node }
       if RUBY_VERSION == "1.9.2"
-        nodes.should == [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)))]
+        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)))]
       else
-        nodes.should == [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(:@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)))]
       end
     end
 
@@ -106,13 +106,13 @@ describe Sexp do
       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 }
-        nodes.should == [s(:var_ref, s(:@ident, "current_user", s(2, 8)))]
+        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") { |node| nodes << node }
-        nodes.should == [s(:vcall, s(:@ident, "current_user", s(2, 8)))]
+        expect(nodes).to eq [s(:vcall, s(:@ident, "current_user", s(2, 8)))]
       end
     end
   end
@@ -130,9 +130,9 @@ 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"
-        node.should == s(:call, s(:var_ref, s(:@ident, "current_user", s(2, 8))), :".", s(:@ident, "posts", s(2, 21)))
+        expect(node).to eq s(:call, s(:var_ref, s(:@ident, "current_user", s(2, 8))), :".", s(:@ident, "posts", s(2, 21)))
       else
-        node.should == 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(:@ident, "posts", s(2, 21)))
       end
     end
   end
@@ -148,7 +148,7 @@ describe Sexp do
     end
 
     it "should get the count of call nodes" do
-      @node.grep_nodes_count(sexp_type: :call).should == 2
+      expect(@node.grep_nodes_count(sexp_type: :call)).to eq 2
     end
   end
 
@@ -156,24 +156,24 @@ describe Sexp do
     it "should get receiver of assign node" do
       node = parse_content("user.name = params[:name]").grep_node(sexp_type: :assign)
       receiver = node.receiver
-      receiver.sexp_type.should == :field
-      receiver.receiver.to_s.should == "user"
-      receiver.message.to_s.should == "name"
+      expect(receiver.sexp_type).to eq :field
+      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)
-      node.receiver.to_s.should == "user"
+      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)
-      node.receiver.to_s.should == "user"
+      expect(node.receiver.to_s).to eq "user"
     end
 
     it "should get receiver of binary" do
       node = parse_content("user == 'user_name'").grep_node(sexp_type: :binary)
-      node.receiver.to_s.should == "user"
+      expect(node.receiver.to_s).to eq "user"
     end
 
     it "should get receiver of command_call" do
@@ -182,149 +182,149 @@ describe Sexp do
       end
       EOF
       node = parse_content(content).grep_node(sexp_type: :command_call)
-      node.receiver.to_s.should == "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)
-      node.receiver.to_s.should == "Post"
+      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.receiver.to_s.should == "Post"
+      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)
-      node.module_name.to_s.should == "Admin"
+      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)
-      node.class_name.to_s.should == "User"
+      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)
-      node.base_class.to_s.should == "ActiveRecord::Base"
+      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)
-      node.left_value.to_s.should == "user"
+      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)
-      node.right_value.to_s.should == "current_user"
+      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)
-      node.message.to_s.should == "has_many"
+      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)
-      node.message.to_s.should == "resources"
+      expect(node.message.to_s).to eq "resources"
     end
 
     it "should get the message of field" do
       node = parse_content("user.name = 'test'").grep_node(sexp_type: :field)
-      node.message.to_s.should == "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)
-      node.message.to_s.should == "name"
+      expect(node.message.to_s).to eq "name"
     end
 
     it "should get the message of binary" do
       node = parse_content("user.name == 'test'").grep_node(sexp_type: :binary)
-      node.message.to_s.should == "=="
+      expect(node.message.to_s).to eq "=="
     end
 
     it "should get the message of fcall" do
       node = parse_content("test?('world')").grep_node(sexp_type: :fcall)
-      node.message.to_s.should == "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)
-      node.message.to_s.should == "find"
+      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.message.to_s.should == "save"
+      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.arguments.sexp_type.should == :args_add_block
+      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.arguments.sexp_type.should == :args_add_block
+      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.arguments.sexp_type.should == :args_add_block
+      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.arguments.sexp_type.should == :args_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)
-      node.argument.to_s.should == "current_user"
+      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)
-      node.all.map(&:to_s).should == ["hello", "world"]
+      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)
-      node.all.map(&:to_s).should == ["title"]
+      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"
-        node.all.should == [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))]
+        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
-        node.all.should == [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(:@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)
-      lambda { node.all }.should_not raise_error
+      expect { node.all }.not_to raise_error
     end
   end
 
@@ -363,41 +363,41 @@ 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.all_conditions.size.should == 3
+      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)
-      node.method_name.to_s.should == "show"
+      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)
-      node.method_name.to_s.should == "find"
+      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)
-      node.body.sexp_type.should == :bodystmt
+      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)
-      node.body.sexp_type.should == :bodystmt
+      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)
-      node.body.sexp_type.should == :bodystmt
+      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)
-      node.body.sexp_type.should == :bodystmt
+      expect(node.body.sexp_type).to eq :bodystmt
     end
 
     it "should get body of if" do
@@ -439,139 +439,139 @@ 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.block_node.sexp_type.should == :do_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)
-      node.statements.size.should == 2
+      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.statements.size.should == 2
+      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.exception_classes.first.to_s.should == "CustomException"
+      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.exception_classes.first.to_s.should == ""
+      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.exception_classes.first.to_s.should == "StandardError"
-      node.exception_classes.last.to_s.should == "CustomException"
+      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)
-      node.exception_variable.to_s.should == "e"
+      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.exception_variable.to_s.should == ""
+      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.hash_value("first_name").to_s.should == "Richard"
-      node.hash_value("last_name").to_s.should == "Huang"
+      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)
-      node.hash_value("first_name").to_s.should == "Richard"
-      node.hash_value("last_name").to_s.should == "Huang"
+      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)
-      node.hash_size.should == 2
+      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)
-      node.hash_size.should == 2
+      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.hash_keys.should == ["first_name", "last_name"]
+      expect(node.hash_keys).to eq ["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)
-      node.hash_keys.should == ["first_name", "last_name"]
+      expect(node.hash_keys).to eq ["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.hash_values.map(&:to_s).should == ["Richard", "Huang"]
+      expect(node.hash_values.map(&:to_s)).to eq ["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)
-      node.hash_values.map(&:to_s).should == ["Richard", "Huang"]
+      expect(node.hash_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)
-      node.array_size.should == 2
+      expect(node.array_size).to eq 2
     end
 
     it "should get 0" do
       node = parse_content("[]").grep_node(sexp_type: :array)
-      node.array_size.should == 0
+      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)
-      node.array_values.map(&:to_s).should == ["first_name", "last_name"]
+      expect(node.array_values.map(&:to_s)).to eq ["first_name", "last_name"]
     end
 
     it "should get empty array values" do
       node = parse_content("[]").grep_node(sexp_type: :array)
-      node.array_values.should == []
+      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)
-      node.array_values.map(&:to_s).should == ["day", "week", "fortnight"]
+      expect(node.array_values.map(&:to_s)).to eq ["day", "week", "fortnight"]
     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.array_values.map(&:to_s).should == ["first_name", "last_name"]
+      expect(node.array_values.map(&:to_s)).to eq ["first_name", "last_name"]
     end
 
     if RUBY_VERSION.to_i > 1
       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.array_values.map(&:to_s).should == ["first_name", "last_name"]
+        expect(node.array_values.map(&:to_s)).to eq ["first_name", "last_name"]
       end
     end
   end
@@ -583,11 +583,11 @@ describe Sexp do
       end
 
       it "should get old_method" do
-        @node.old_method.to_s.should == "old"
+        expect(@node.old_method.to_s).to eq "old"
       end
 
       it "should get new_method" do
-        @node.new_method.to_s.should == "new"
+        expect(@node.new_method.to_s).to eq "new"
       end
     end
 
@@ -597,11 +597,11 @@ describe Sexp do
       end
 
       it "should get old_method" do
-        @node.old_method.to_s.should == "old"
+        expect(@node.old_method.to_s).to eq "old"
       end
 
       it "should get new_method" do
-        @node.new_method.to_s.should == "new"
+        expect(@node.new_method.to_s).to eq "new"
       end
     end
   end
@@ -609,95 +609,100 @@ 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.to_object.should == ["first_name", "last_name"]
+      expect(node.to_object).to eq ["first_name", "last_name"]
     end
 
     it "should to array with %w()" do
       node = parse_content("%w(new create)").grep_node(sexp_type: :array)
-      node.to_object.should == ["new", "create"]
+      expect(node.to_object).to eq ["new", "create"]
     end
 
     it "should to array with symbols" do
       node = parse_content("[:first_name, :last_name]").grep_node(sexp_type: :array)
-      node.to_object.should == ["first_name", "last_name"]
+      expect(node.to_object).to eq ["first_name", "last_name"]
     end
 
     it "should to empty array" do
       node = parse_content("[]").grep_node(sexp_type: :array)
-      node.to_object.should == []
+      expect(node.to_object).to eq []
     end
 
     it "should to string" do
       node = parse_content("'richard'").grep_node(sexp_type: :string_literal)
-      node.to_object.should == "richard"
+      expect(node.to_object).to eq "richard"
     end
   end
 
   describe "to_s" do
     it "should get to_s for string" do
       node = parse_content("'user'").grep_node(sexp_type: :string_literal)
-      node.to_s.should == "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)
-      node.to_s.should == "user"
+      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)
-      node.to_s.should == "User"
+      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)
-      node.to_s.should == "@user"
+      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)
-      node.to_s.should == "ActiveRecord::Base"
+      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.to_s.should == "first_name"
+      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)
-      node.to_s.should == "current_user.post"
+      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"
     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)
-      node.should be_const
+      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)
-      node.should be_const
+      expect(node).to be_const
     end
 
     it "should return false for ivar" do
       node = parse_content("@user.find").grep_node(sexp_type: :@ivar)
-      node.should_not be_const
+      expect(node).not_to be_const
     end
   end
 
   describe "present?" do
     it "should return true" do
       node = parse_content("hello world")
-      node.should be_present
+      expect(node).to be_present
     end
   end
 
   describe "blank?" do
     it "should return false" do
       node = parse_content("hello world")
-      node.should_not be_blank
+      expect(node).not_to be_blank
     end
   end
 

data/spec/code_analyzer/warning_spec.rb

@@ -3,10 +3,11 @@ require 'spec_helper'
 module CodeAnalyzer
   describe Warning do
     it "should return error with filename, line number and message" do
-      Warning.new(
-        filename: "app/models/user.rb",
-        line_number: "100",
-        message: "not good").to_s.should == "app/models/user.rb:100 - not good"
+
+      expect(Warning.new(
+              filename: "app/models/user.rb",
+              line_number: "100",
+              message: "not good").to_s).to eq "app/models/user.rb:100 - not good"
     end
   end
 end

metadata

@@ -1,55 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: code_analyzer
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.4.5
 platform: ruby
 authors:
 - Richard Huang
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-06 00:00:00.000000000 Z
+date: 2014-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sexp_processor
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: a code analyzer tool which extracted from rails_best_practices, it helps
@@ -60,11 +60,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .ruby-gemset
-- .ruby-version
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE
 - README.md
@@ -99,17 +97,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.2.0.rc.1
 signing_key: 
 specification_version: 4
 summary: a code analyzer helps you build your own code analyzer tool.

data/.ruby-gemset

@@ -1 +0,0 @@
-code_analyzer

data/.ruby-version

@@ -1 +0,0 @@
-ruby-2.0.0