code_analyzer 0.1.0

data/lib/code_analyzer/version.rb

@@ -0,0 +1,3 @@
+module CodeAnalyzer
+  VERSION = "0.1.0"
+end

data/lib/code_analyzer/warning.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+module CodeAnalyzer
+  # Warning is the violation.
+  #
+  # it indicates the filenname, line number and error message for the violation.
+  class Warning
+    attr_reader :filename, :line_number, :message
+
+    def initialize(options={})
+      @filename = options[:filename]
+      @line_number = options[:line_number].to_s
+      @message = options[:message]
+    end
+
+    def to_s
+      "#{@filename}:#{@line_number} - #{@message}"
+    end
+  end
+end

data/spec/code_analyzer/checker_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+module CodeAnalyzer
+  describe Checker do
+    let(:checker) { Checker.new }
+
+    context "interesting_nodes" do
+      it "should get empty interesting nodes" do
+        checker.interesting_nodes.should == []
+      end
+
+      it "should add interesting nodes" do
+        Checker.interesting_nodes :class, :def
+        checker.interesting_nodes.should == [:class, :def]
+      end
+    end
+
+    context "interesting_files" do
+      it "should match none of interesting files" do
+        checker.interesting_files.should == []
+      end
+
+      it "should add interesting files" do
+        Checker.interesting_files /lib/, /spec/
+        checker.interesting_files.should == [/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
+      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
+      end
+    end
+
+    context "callback" do
+      it "should add callback to start_call" do
+        block = Proc.new {}
+        Checker.add_callback(:start_call, &block)
+        Checker.get_callbacks(:start_call).should == [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]
+      end
+
+      it "should add multiple callbacks to end_call" do
+        block1 = Proc.new {}
+        block2 = Proc.new {}
+        Checker.add_callback(:end_call, &block1)
+        Checker.add_callback(:end_call, &block2)
+        Checker.get_callbacks(:end_call).should == [block1, block2]
+      end
+    end
+  end
+end

data/spec/code_analyzer/checking_visitor/default_spec.rb

@@ -0,0 +1,42 @@
+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(: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)
+
+      visitor.check(filename, content)
+    end
+
+    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)
+
+      visitor.check(filename, content)
+    end
+
+    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)
+
+      visitor.check(filename, content)
+    end
+  end
+end

data/spec/code_analyzer/checking_visitor/plain_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+module CodeAnalyzer::CheckingVisitor
+  describe Plain do
+    let(:checker1) { mock(:checker) }
+    let(:checker2) { mock(:checker) }
+    let(:visitor) { Plain.new(checkers: [checker1, checker2]) }
+
+    it "should check by all checkers" do
+      filename = "filename"
+      content = "content"
+      checker1.should_receive(:check).with(filename, content)
+      checker2.should_receive(:check).with(filename, content)
+
+      visitor.check(filename, content)
+    end
+  end
+end

data/spec/code_analyzer/nil_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+module CodeAnalyzer
+  describe Nil do
+    let(:core_nil) { Nil.new }
+
+    context "to_s" do
+      it "should return self" do
+        core_nil.to_s.should == core_nil
+      end
+    end
+
+    context "hash_size" do
+      it "should return 0" do
+        core_nil.hash_size.should == 0
+      end
+    end
+
+    context "method_missing" do
+      it "should return self" do
+        core_nil.undefined.should == core_nil
+      end
+    end
+
+    context "present?" do
+      it "should return false" do
+        core_nil.should_not be_present
+      end
+    end
+
+    context "blank?" do
+      it "should return true" do
+        core_nil.should be_blank
+      end
+    end
+  end
+end

data/spec/code_analyzer/sexp_spec.rb

@@ -0,0 +1,622 @@
+require 'spec_helper'
+
+describe Sexp do
+  describe "line" do
+    before :each do
+      content = <<-EOF
+      class Demo
+        def test
+          ActiveRecord::Base.connection
+        end
+        alias :test_new :test
+        CONST = { foo: :bar }
+      end
+      EOF
+      @node = parse_content(content)
+    end
+
+    it "should return class line" do
+      @node.grep_node(sexp_type: :class).line.should == 1
+    end
+
+    it "should return def line" do
+      @node.grep_node(sexp_type: :def).line.should == 2
+    end
+
+    it "should return const line" do
+      @node.grep_node(sexp_type: :const_ref).line.should == 1
+    end
+
+    it "should return const path line" do
+      @node.grep_node(sexp_type: :const_path_ref).line.should == 3
+    end
+
+    it "should return alias line" do
+      @node.grep_node(sexp_type: :alias).line.should == 5
+    end
+
+    it "should return hash line" do
+      @node.grep_node(sexp_type: :hash).line.should == 6
+    end
+  end
+
+  describe "grep_nodes" do
+    before :each do
+      content = <<-EOF
+      def show
+        current_user.posts.find(params[:id])
+      end
+      EOF
+      @node = parse_content(content)
+    end
+
+    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"
+        nodes.should == [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)))]
+      end
+    end
+
+    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"
+        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)))]
+      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)))]
+      end
+    end
+
+    if RUBY_VERSION == "1.9.2"
+      it "should get the var_ref node with to_s" do
+        nodes = []
+        @node.grep_nodes(sexp_type: :var_ref, to_s: "current_user") { |node| nodes << node }
+        nodes.should == [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)))]
+      end
+    end
+  end
+
+  describe "grep_node" do
+    before :each do
+      content = <<-EOF
+      def show
+        current_user.posts.find(params[:id])
+      end
+      EOF
+      @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"
+        node.should == 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)))
+      end
+    end
+  end
+
+  describe "grep_nodes_count" do
+    before :each do
+      content = <<-EOF
+      def show
+        current_user.posts.find(params[:id])
+      end
+      EOF
+      @node = parse_content(content)
+    end
+
+    it "should get the count of call nodes" do
+      @node.grep_nodes_count(sexp_type: :call).should == 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)
+      receiver = node.receiver
+      receiver.sexp_type.should == :field
+      receiver.receiver.to_s.should == "user"
+      receiver.message.to_s.should == "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"
+    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"
+    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"
+    end
+
+    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)
+      node.receiver.to_s.should == "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"
+    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"
+    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"
+    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"
+    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"
+    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"
+    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"
+    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"
+    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"
+    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"
+    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"
+    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 == "=="
+    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?"
+    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"
+    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"
+    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
+    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
+    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
+    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
+    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"
+    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"]
+    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"]
+    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))]
+      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))]
+      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
+    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)
+      node.conditional_statement.to_s.should == "true"
+    end
+
+    it "should get conditional statement of unless" do
+      node = parse_content("unless true; end").grep_node(sexp_type: :unless)
+      node.conditional_statement.to_s.should == "true"
+    end
+
+    it "should get conditional statement of elsif" do
+      content =<<-EOF
+      if true
+      elsif false
+      end
+      EOF
+      node = parse_content(content).grep_node(sexp_type: :elsif)
+      node.conditional_statement.to_s.should == "false"
+    end
+
+    it "should get conditional statement of ifop" do
+      content =<<-EOF
+      user ? user.name : nil
+      EOF
+      node = parse_content(content).grep_node(sexp_type: :ifop)
+      node.conditional_statement.to_s.should == "user"
+    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)
+      node.all_conditions.size.should == 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"
+    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"
+    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
+    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
+    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
+    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
+    end
+
+    it "should get body of if" do
+      node = parse_content("if true; puts 'hello world'; end").grep_node(sexp_type: :if)
+      node.body.sexp_type.should == :stmts_add
+    end
+
+    it "should get body of elsif" do
+      node = parse_content("if true; elsif true; puts 'hello world'; end").grep_node(sexp_type: :elsif)
+      node.body.sexp_type.should == :stmts_add
+    end
+
+    it "should get body of unless" do
+      node = parse_content("unless true; puts 'hello world'; end").grep_node(sexp_type: :unless)
+      node.body.sexp_type.should == :stmts_add
+    end
+
+    it "should get body of else" do
+      node = parse_content("if true; else; puts 'hello world'; end").grep_node(sexp_type: :else)
+      node.body.sexp_type.should == :stmts_add
+    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)
+      node.block.sexp_type.should == :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
+    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
+    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"
+    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"
+    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
+    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
+    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"]
+    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"]
+    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"]
+    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"]
+    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
+    end
+
+    it "should get 0" do
+      node = parse_content("[]").grep_node(sexp_type: :array)
+      node.array_size.should == 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"]
+    end
+
+    it "should get empty array values" do
+      node = parse_content("[]").grep_node(sexp_type: :array)
+      node.array_values.should == []
+    end
+
+    it "should get array value with qwords" do
+      node = parse_content("%w(first_name last_name)").grep_node(sexp_type: :qwords_add)
+      node.array_values.map(&:to_s).should == ["first_name", "last_name"]
+    end
+  end
+
+  describe "alias" do
+    context "method" do
+      before do
+        @node = parse_content("alias new old").grep_node(sexp_type: :alias)
+      end
+
+      it "should get old_method" do
+        @node.old_method.to_s.should == "old"
+      end
+
+      it "should get new_method" do
+        @node.new_method.to_s.should == "new"
+      end
+    end
+
+    context "symbol" do
+      before do
+        @node = parse_content("alias :new :old").grep_node(sexp_type: :alias)
+      end
+
+      it "should get old_method" do
+        @node.old_method.to_s.should == "old"
+      end
+
+      it "should get new_method" do
+        @node.new_method.to_s.should == "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)
+      node.to_object.should == ["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"]
+    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"]
+    end
+
+    it "should to empty array" do
+      node = parse_content("[]").grep_node(sexp_type: :array)
+      node.to_object.should == []
+    end
+
+    it "should to string" do
+      node = parse_content("'richard'").grep_node(sexp_type: :string_literal)
+      node.to_object.should == "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"
+    end
+
+    it "should get to_s for symbol" do
+      node = parse_content(":user").grep_node(sexp_type: :symbol_literal)
+      node.to_s.should == "user"
+    end
+
+    it "should get to_s for const" do
+      node = parse_content("User").grep_node(sexp_type: :@const)
+      node.to_s.should == "User"
+    end
+
+    it "should get to_s for ivar" do
+      node = parse_content("@user").grep_node(sexp_type: :@ivar)
+      node.to_s.should == "@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"
+    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"
+    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"
+    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
+    end
+
+    it "should return true for const with @const" do
+      node = parse_content("User.find").grep_node(sexp_type: :@const)
+      node.should 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
+    end
+  end
+
+  describe "present?" do
+    it "should return true" do
+      node = parse_content("hello world")
+      node.should be_present
+    end
+  end
+
+  describe "blank?" do
+    it "should return false" do
+      node = parse_content("hello world")
+      node.should_not 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")
+    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"))
+    end
+  end
+end