rails_best_practices 0.10.1 → 1.0.0

data/lib/rails_best_practices/reviews/use_query_attribute_review.rb

@@ -17,14 +17,14 @@ module RailsBestPractices
     #   then you can use query attribute instead.
     class UseQueryAttributeReview < Review
 
-      QUERY_METHODS = [:nil?, :blank?, :present?]
+      QUERY_METHODS = %w(nil? blank? present?)
 
       def url
         "http://rails-bestpractices.com/posts/56-use-query-attribute"
       end
 
       def interesting_nodes
-        [:if]
+        [:if, :unless, :elsif]
       end
 
       # check if node to see whose conditional statement nodes contain nodes that can use query attribute instead.
@@ -40,22 +40,33 @@ module RailsBestPractices
       #
       # then the call node can use query attribute instead.
       def start_if(node)
-        if node = query_attribute_node(node.conditional_statement)
-          subject_node = node.subject
-          add_error "use query attribute (#{subject_node.subject}.#{subject_node.message}?)", node.file, node.line
+        all_conditions = node.conditional_statement == node.conditional_statement.all_conditions ? [node.conditional_statement] : node.conditional_statement.all_conditions
+        all_conditions.each do |condition_node|
+          if query_attribute_node = query_attribute_node(condition_node)
+            subject_node = query_attribute_node.subject
+            add_error "use query attribute (#{subject_node.subject}.#{subject_node.message}?)", node.file, query_attribute_node.line
+          end
         end
       end
 
+      alias_method :start_unless, :start_if
+      alias_method :start_elsif, :start_if
+
       private
         # recursively check conditional statement nodes to see if there is a call node that may be possible query attribute.
         def query_attribute_node(conditional_statement_node)
-          case conditional_statement_node.node_type
+          case conditional_statement_node.sexp_type
           when :and, :or
-            return query_attribute_node(conditional_statement_node[1]) || query_attribute_node(conditional_statement_node[2])
+            node = query_attribute_node(conditional_statement_node[1]) || query_attribute_node(conditional_statement_node[2])
+            node.file = conditional_statement_code.file
+            return node
           when :not
-            return query_attribute_node(conditional_statement_node[1])
+            node = query_attribute_node(conditional_statement_node[1])
+            node.file = conditional_statement_node.file
           when :call
             return conditional_statement_node if possible_query_attribute?(conditional_statement_node)
+          when :binary
+            return conditional_statement_node if possible_query_attribute?(conditional_statement_node)
           end
           nil
         end
@@ -70,50 +81,34 @@ module RailsBestPractices
         # for the second call, the message should be one of nil?, blank? or present? or
         # it is compared with an empty string.
         #
-        # the node that may use query attribute is like
-        #
-        #     s(:call, s(:call, s(:ivar, :@user), :login, s(:arglist)), :nil?, s(:arglist))
-        #
-        #
+        # the node that may use query attribute.
         def possible_query_attribute?(node)
-          return false unless :call == node.subject.node_type
-          subject = node.subject.subject
-          return false unless subject
-          message = node.subject.message
+          return false unless :call == node.subject.sexp_type
+          variable_node = variable(node)
+          message_node = node.grep_node(:subject => variable_node.to_s).message
 
-          [:arglist] == node.subject.arguments && is_model?(subject) && model_attribute?(subject, message) &&
-            (QUERY_METHODS.include?(node.message) || compare_with_empty_string?(node))
+          is_model?(variable_node) && model_attribute?(variable_node, message_node.to_s) &&
+            (QUERY_METHODS.include?(node.message.to_s) || compare_with_empty_string?(node))
         end
 
         # check if the subject is one of the models.
-        #
-        #     subject, subject of call node, like
-        #         s(:ivar, @user)
-        def is_model?(subject)
-          return false if :const == subject.node_type
-          class_name = subject.to_s(:remove_at => true).classify
+        def is_model?(variable_node)
+          return false if variable_node.const?
+          class_name = variable_node.to_s.sub(/^@/, '').classify
           models.include?(class_name)
         end
 
         # check if the subject and message is one of the model's attribute.
         # the subject should match one of the class model name, and the message should match one of attribute name.
-        #
-        #     subject, subject of call node, like
-        #         s(:ivar, @user)
-        #
-        #     message, message of call node, like
-        #         :login
-        def model_attribute?(subject, message)
-          class_name = subject.to_s(:remove_at => true).classify
-          attribute_type = model_attributes.get_attribute_type(class_name, message.to_s)
-          attribute_type && ![:integer, :float].include?(attribute_type)
+        def model_attribute?(variable_node, message)
+          class_name = variable_node.to_s.sub(/^@/, '').classify
+          attribute_type = model_attributes.get_attribute_type(class_name, message)
+          attribute_type && !["integer", "float"].include?(attribute_type)
         end
 
-        # check if the node is with node type :call, node message :== and node arguments {:arglist, (:str, "")}
-        #
-        #     @user.login == "" => true
+        # check if the node is with node type :binary, node message :== and node argument is empty string.
         def compare_with_empty_string?(node)
-          :call == node.node_type && :== == node.message && [:arglist, [:str, ""]] == node.arguments
+          :binary == node.sexp_type && ["==", "!="].include?(node.message.to_s) && s(:string_literal, s(:string_content)) == node.argument
         end
     end
   end

data/lib/rails_best_practices/reviews/use_say_with_time_in_migrations_review.rb

@@ -16,8 +16,7 @@ module RailsBestPractices
     #   then the method call should be wrapped by say or say_with_time.
     class UseSayWithTimeInMigrationsReview < Review
 
-      DEFAULT_MIGRATION_METHODS = [:add_column, :add_index, :add_timestamps, :change_column, :change_column_default, :change_table, :create_table, :drop_table, :remove_column, :remove_index, :remove_timestamps, :rename_column, :rename_index, :rename_table]
-      WITH_SAY_METHODS = [:say, :say_with_time]
+      WITH_SAY_METHODS = %w(say say_with_time)
 
       def url
         "http://rails-bestpractices.com/posts/46-use-say-and-say_with_time-in-migrations-to-make-a-useful-migration-log"
@@ -31,47 +30,24 @@ module RailsBestPractices
         MIGRATION_FILES
       end
 
-      # check a class method define node to see if there are method calls that need to be wrapped by :say or :say_with_time.
+      # check a class method define node to see if there are method calls that need to be wrapped by say or say_with_time.
       #
       # it will check the first block node,
-      # if any method call whose message is not default migration methods in the block node, like
-      #
-      #     s(:defs, s(:self), :up, s(:args),
-      #       s(:scope,
-      #         s(:block,
-      #           s(:iter,
-      #             s(:call, s(:const, :User), :find_each, s(:arglist)),
-      #             s(:lasgn, :user),
-      #             s(:block,
-      #               s(:masgn,
-      #                 s(:array,
-      #                   s(:attrasgn, s(:lvar, :user), :first_name=, s(:arglist)),
-      #                   s(:attrasgn, s(:lvar, :user), :last_name=, s(:arglist))
-      #                 ),
-      #                 s(:to_ary,
-      #                   s(:call,
-      #                     s(:call, s(:lvar, :user), :full_name, s(:arglist)),
-      #                     :split,
-      #                     s(:arglist, s(:str, " "))
-      #                   )
-      #                 )
-      #               ),
-      #               s(:call, s(:lvar, :user), :save, s(:arglist))
-      #             )
-      #           )
-      #         )
-      #       )
-      #     )
-      #
+      # if any method call whose message is not default migration methods in the block node,
       # then such method call should be wrapped by say or say_with_time
       def start_defs(node)
-        block_node = node.grep_node(:node_type => :block)
-        block_node.children.each do |child_node|
-          next if :iter != child_node.node_type || child_node.grep_nodes_count(:node_type => :call, :message => WITH_SAY_METHODS) > 0
+        node.body.statements.each do |child_node|
+          next if child_node.grep_nodes_count(:sexp_type => [:fcall, :command], :message => WITH_SAY_METHODS) > 0
 
-          subject_node = child_node.subject
-          if :call == subject_node.node_type && !DEFAULT_MIGRATION_METHODS.include?(subject_node.message)
-            add_error("use say with time in migrations", subject_node.file, subject_node.line)
+          subject_node = if :method_add_block == child_node.sexp_type
+                           child_node[1]
+                         elsif :method_add_arg == child_node.sexp_type
+                           child_node[1]
+                         else
+                           child_node
+                         end
+          if :call == subject_node.sexp_type
+            add_error("use say with time in migrations", node.file, child_node.line)
           end
         end
       end

data/lib/rails_best_practices/reviews/use_scope_access_review.rb

@@ -21,7 +21,7 @@ module RailsBestPractices
       end
 
       def interesting_nodes
-        [:if]
+        [:if, :unless, :elsif]
       end
 
       def interesting_files
@@ -31,63 +31,32 @@ module RailsBestPractices
       # check if node.
       #
       # if it is a method call compared with current_user or current_user.id,
-      # and there is a redirect_to method call in the block body, like
-      #
-      #     unless @post.user == current_user
-      #       falsh[:error] = "Access Denied"
-      #       redirect_to posts_url
-      #     end
-      #
+      # and there is a redirect_to method call in the block body,
       # then it should be replaced by using scope access.
       def start_if(node)
         add_error "use scope access" if current_user_redirect?(node)
       end
 
+      alias_method :start_unless, :start_if
+      alias_method :start_elsif, :start_if
+
       private
         # check a if node to see
         #
         # if the conditional statement is compared with current_user or current_user.id,
-        # and there is a redirect_to method call in the block body, like
-        #
-        #     s(:if,
-        #       s(:call,
-        #         s(:call, s(:ivar, :@post), :user, s(:arglist)),
-        #         :==,
-        #         s(:arglist, s(:call, nil, :current_user, s(:arglist)))
-        #       ),
-        #       nil,
-        #       s(:block,
-        #         s(:attrasgn,
-        #           s(:call, nil, :flash, s(:arglist)),
-        #           :[]=,
-        #           s(:arglist, s(:lit, :warning), s(:str, "Access Denied"))
-        #         ),
-        #         s(:call, nil, :redirect_to,
-        #           s(:arglist, s(:call, nil, :posts_url, s(:arglist)))
-        #         )
-        #       )
-        #     )
-        #
+        # and there is a redirect_to method call in the block body,
         # then it should be replaced by using scope access.
         def current_user_redirect?(node)
-          condition_node = node.conditional_statement
-
-          condition_node.message == :== &&
-          (current_user?(condition_node.arguments[1]) || current_user?(condition_node.subject)) &&
-          (node.false_node.grep_node(:message => :redirect_to) || node.true_node.grep_node(:message => :redirect_to))
+          all_conditions = node.conditional_statement == node.conditional_statement.all_conditions ? [node.conditional_statement] : node.conditional_statement.all_conditions
+          results = all_conditions.map do |condition_node|
+            ["==", "!="].include?(condition_node.message.to_s) && (current_user?(condition_node.argument) || current_user?(condition_node.subject))
+          end
+          results.any? { |result| result == true } && node.body.grep_node(:message => "redirect_to")
         end
 
         # check a call node to see if it uses current_user, or current_user.id.
-        #
-        # the expected call node may be
-        #
-        #     s(:call, nil, :current_user, s(:arglist))
-        #
-        # or
-        #
-        #     s(:call, s(:call, nil, :current_user, s(:arglist)), :id, s(:arglist))
-        def current_user?(call_node)
-          call_node.message == :current_user || (call_node.subject.message == :current_user && call_node.message == :id)
+        def current_user?(node)
+          "current_user" == node.to_s || ("current_user" == node.subject.to_s && "id" == node.message.to_s)
         end
     end
   end

data/lib/rails_best_practices/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 module RailsBestPractices
-  VERSION = "0.10.1"
+  VERSION = "1.0.0"
 end
 

data/spec/rails_best_practices/core/check_spec.rb

@@ -4,7 +4,7 @@ describe RailsBestPractices::Core::Check do
   let(:check) { RailsBestPractices::Core::Check.new }
 
   it "should get empty interesting nodes" do
-    check.interesting_nodes.should == RailsBestPractices::Core::Check::NODE_TYPES
+    check.interesting_nodes.should == []
   end
 
   it "should match all files of interesting files" do
@@ -13,13 +13,13 @@ describe RailsBestPractices::Core::Check do
 
   context "node_start" do
     it "should call start_if" do
-      node = stub(:node_type => :if)
+      node = stub(:sexp_type => :if)
       check.should_receive(:send).with("start_if", node)
       check.node_start(node)
     end
 
     it "should call start_call" do
-      node = stub(:node_type => :call)
+      node = stub(:sexp_type => :call)
       check.should_receive(:send).with("start_call", node)
       check.node_start(node)
     end
@@ -27,13 +27,13 @@ describe RailsBestPractices::Core::Check do
 
   context "node_end" do
     it "should call end_if" do
-      node = stub(:node_type => :if)
+      node = stub(:sexp_type => :if)
       check.should_receive(:send).with("end_if", node)
       check.node_end(node)
     end
 
     it "should call end_call" do
-      node = stub(:node_type => :call)
+      node = stub(:sexp_type => :call)
       check.should_receive(:send).with("end_call", node)
       check.node_end(node)
     end

data/spec/rails_best_practices/core/checking_visitor_spec.rb

@@ -69,28 +69,28 @@ describe RailsBestPractices::Core::CheckingVisitor do
   end
 
   it "should prepare model associations" do
-    node = stub(:node_type => :call, :children => [], :file => "app/models/user.rb")
+    node = stub(:sexp_type => :call, :children => [], :file => "app/models/user.rb")
     prepare1.should_receive(:node_start).with(node)
     prepare1.should_receive(:node_end).with(node)
     visitor.prepare(node)
   end
 
   it "should prepare mailer names" do
-    node = stub(:node_type => :class, :children => [], :file => "app/mailers/user_mailer.rb")
+    node = stub(:sexp_type => :class, :children => [], :file => "app/mailers/user_mailer.rb")
     prepare2.should_receive(:node_start).with(node)
     prepare2.should_receive(:node_end).with(node)
     visitor.prepare(node)
   end
 
   it "should review controller method definitions" do
-    node = stub(:node_type => :defn, :children => [], :file => "app/controllers/users_controller.rb")
+    node = stub(:sexp_type => :defn, :children => [], :file => "app/controllers/users_controller.rb")
     review1.should_receive(:node_start).with(node)
     review1.should_receive(:node_end).with(node)
     visitor.review(node)
   end
 
   it "should review view calls" do
-    node = stub(:node_type => :call, :children => [], :file => "app/views/users/new.html.erb")
+    node = stub(:sexp_type => :call, :children => [], :file => "app/views/users/new.html.erb")
     review2.should_receive(:node_start).with(node)
     review2.should_receive(:node_end).with(node)
     visitor.review(node)

data/spec/rails_best_practices/core/model_associations_spec.rb

@@ -4,13 +4,13 @@ describe RailsBestPractices::Core::ModelAssociations do
   let(:model_associations) { RailsBestPractices::Core::ModelAssociations.new }
 
   before :each do
-    model_associations.add_association("Project", "project_manager", :belongs_to)
-    model_associations.add_association("Project", "people", :has_many, "Person")
+    model_associations.add_association("Project", "project_manager", "belongs_to")
+    model_associations.add_association("Project", "people", "has_many", "Person")
   end
 
   it "should get model associations" do
-    model_associations.get_association("Project", "project_manager").should == {:meta => :belongs_to, :class_name => "ProjectManager"}
-    model_associations.get_association("Project", "people").should == {:meta => :has_many, :class_name => "Person"}
+    model_associations.get_association("Project", "project_manager").should == {"meta" => "belongs_to", "class_name" => "ProjectManager"}
+    model_associations.get_association("Project", "people").should == {"meta" => "has_many", "class_name" => "Person"}
     model_associations.get_association("Project", "unknown").should be_nil
   end
 

data/spec/rails_best_practices/core/nil_spec.rb

@@ -9,9 +9,15 @@ describe RailsBestPractices::Core::Nil do
     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
-end
+end

data/spec/rails_best_practices/core_ext/sexp_spec.rb

@@ -0,0 +1,430 @@
+require 'spec_helper'
+
+describe Sexp do
+  describe "line" do
+    before :each do
+      content = <<-EOF
+      class Demo
+        def test
+        end
+      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
+  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 subject current_user" do
+      nodes = []
+      @node.grep_nodes(:sexp_type => :call, :subject => "current_user") { |node| nodes << node }
+      nodes.should == [s(:call, s(:var_ref, s(:@ident, "current_user", s(2, 8))), :".", s(:@ident, "posts", s(2, 21)))]
+    end
+
+    it "should get the call nodes with different messages" do
+      nodes = []
+      @node.grep_nodes(:sexp_type => :call, :message => ["posts", "find"]) { |node| nodes << node }
+      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)))]
+    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, :subject => "current_user")
+      node.should == s(:call, s(:var_ref, s(:@ident, "current_user", s(2, 8))), :".", s(:@ident, "posts", s(2, 21)))
+    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 "subject" do
+    it "should get subject of assign node" do
+      node = parse_content("user.name = params[:name]").grep_node(:sexp_type => :assign)
+      subject = node.subject
+      subject.sexp_type.should == :field
+      subject.subject.to_s.should == "user"
+      subject.message.to_s.should == "name"
+    end
+
+    it "should get subject of field node" do
+      node = parse_content("user.name = params[:name]").grep_node(:sexp_type => :field)
+      node.subject.to_s.should == "user"
+    end
+
+    it "should get subject of call node" do
+      node = parse_content("user.name").grep_node(:sexp_type => :call)
+      node.subject.to_s.should == "user"
+    end
+
+    it "should get subject of binary" do
+      node = parse_content("user == 'user_name'").grep_node(:sexp_type => :binary)
+      node.subject.to_s.should == "user"
+    end
+
+    it "should get subject of command_call" do
+      content = <<-EOF
+      map.resources :posts do
+      end
+      EOF
+      node = parse_content(content).grep_node(:sexp_type => :command_call)
+      node.subject.to_s.should == "map"
+    end
+
+    it "should get subject of method_add_arg" do
+      node = parse_content("Post.find(:all)").grep_node(:sexp_type => :method_add_arg)
+      node.subject.to_s.should == "Post"
+    end
+
+    it "should get subject of method_add_block" do
+      node = parse_content("Post.save do; end").grep_node(:sexp_type => :method_add_block)
+      node.subject.to_s.should == "Post"
+    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_args" do
+      node = parse_content("User.find(:all)").grep_node(:sexp_type => :method_add_arg)
+      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
+  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
+  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 defn" do
+      node = parse_content("def show; end").grep_node(:sexp_type => :def)
+      node.method_name.to_s.should == "show"
+    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 value 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 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_keys.should == ["first_name", "last_name"]
+    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
+  end
+
+  describe "to_object" do
+    it "should to_object" do
+      node = parse_content("['first_name', 'last_name']").grep_node(:sexp_type => :array)
+      node.to_object.should == ["first_name", "last_name"]
+    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
+  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 "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