rails_best_practices 1.9.1 → 1.10.0

data/lib/rails_best_practices/reviews/use_say_with_time_in_migrations_review.rb

@@ -3,17 +3,19 @@ require 'rails_best_practices/reviews/review'
 
 module RailsBestPractices
   module Reviews
-    # Review a migration file to make sure to use say or say_with_time for customized data changes to produce a more readable output.
+    # Review a migration file to make sure to use say or say_with_time for customized data changes 
+    # to produce a more readable output.
     #
-    # See the best practice detials here http://rails-bestpractices.com/posts/46-use-say-and-say_with_time-in-migrations-to-make-a-useful-migration-log.
+    # See the best practice detials here 
+    # http://rails-bestpractices.com/posts/46-use-say-and-say_with_time-in-migrations-to-make-a-useful-migration-log.
     #
     # Implementation:
     #
     # Review process:
     #   check class method define nodes (self.up or self.down).
     #   if there is a method call in the class method definition,
-    #   and the message of method call is not say, say_with_time and default migration methods (such as add_column and create_table),
-    #   then the method call should be wrapped by say or say_with_time.
+    #   and the message of method call is not say, say_with_time and default migration methods
+    #   (such as add_column and create_table), then the method call should be wrapped by say or say_with_time.
     class UseSayWithTimeInMigrationsReview < Review
       interesting_nodes :defs
       interesting_files MIGRATION_FILES
@@ -24,14 +26,15 @@ module RailsBestPractices
         "http://rails-bestpractices.com/posts/46-use-say-and-say_with_time-in-migrations-to-make-a-useful-migration-log"
       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,
       # then such method call should be wrapped by say or say_with_time
       def start_defs(node)
         node.body.statements.each do |child_node|
-          next if child_node.grep_nodes_count(:sexp_type => [:fcall, :command], :message => WITH_SAY_METHODS) > 0
+          next if child_node.grep_nodes_count(sexp_type: [:fcall, :command], message: WITH_SAY_METHODS) > 0
 
           subject_node = if :method_add_block == child_node.sexp_type
                            child_node[1]

data/lib/rails_best_practices/reviews/use_scope_access_review.rb

@@ -42,11 +42,16 @@ module RailsBestPractices
         # 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)
-          all_conditions = node.conditional_statement == node.conditional_statement.all_conditions ? [node.conditional_statement] : node.conditional_statement.all_conditions
+          all_conditions = if node.conditional_statement == node.conditional_statement.all_conditions
+            [node.conditional_statement]
+          else
+            node.conditional_statement.all_conditions
+          end
           results = all_conditions.map do |condition_node|
-            ["==", "!="].include?(condition_node.message.to_s) && (current_user?(condition_node.argument) || current_user?(condition_node.subject))
+            ["==", "!="].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")
+          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.

data/lib/rails_best_practices/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module RailsBestPractices
-  VERSION = "1.9.1"
+  VERSION = "1.10.0"
 end

data/rails_best_practices.yml

@@ -1,34 +1,37 @@
-MoveFinderToNamedScopeCheck: { }
-UseModelAssociationCheck: { }
-UseScopeAccessCheck: { }
 AddModelVirtualAttributeCheck: { }
-ReplaceComplexCreationWithFactoryMethodCheck: { attribute_assignment_count: 2 }
-MoveModelLogicIntoModelCheck: { use_count: 4 }
-OveruseRouteCustomizationsCheck: { customize_count: 3 }
-NeedlessDeepNestingCheck: { nested_count: 2 }
-NotUseDefaultRouteCheck: { }
+AlwaysAddDbIndexCheck: { }
+DryBundlerInCapistranoCheck: { }
+HashSyntaxCheck: { only_symbol: false, only_string: false }
+IsolateSeedDataCheck: { }
 KeepFindersOnTheirOwnModelCheck: { }
 LawOfDemeterCheck: { }
-UseObserverCheck: { }
-IsolateSeedDataCheck: { }
-AlwaysAddDbIndexCheck: { }
-UseBeforeFilterCheck: { customize_count: 2 }
+LongLineCheck: { max_line_length: 80 }
 MoveCodeIntoControllerCheck: { }
-MoveCodeIntoModelCheck: { use_count: 2 }
 MoveCodeIntoHelperCheck: { array_count: 3 }
-ReplaceInstanceVariableWithLocalVariableCheck: { }
-DryBundlerInCapistranoCheck: { }
-UseSayWithTimeInMigrationsCheck: { }
-UseQueryAttributeCheck: { }
-RemoveTrailingWhitespaceCheck: { }
-UseMultipartAlternativeAsContentTypeOfEmailCheck: { }
-SimplifyRenderInViewsCheck: { }
-SimplifyRenderInControllersCheck: { }
+MoveCodeIntoModelCheck: { use_count: 2 }
+MoveFinderToNamedScopeCheck: { }
+MoveModelLogicIntoModelCheck: { use_count: 4 }
+NeedlessDeepNestingCheck: { nested_count: 2 }
+NotUseDefaultRouteCheck: { }
+NotUseTimeAgoInWordsCheck: { }
+OveruseRouteCustomizationsCheck: { customize_count: 3 }
+ProtectMassAssignmentCheck: { }
 RemoveEmptyHelpersCheck: { }
 RemoveTabCheck: { }
-RestrictAutoGeneratedRoutesCheck: { }
-RemoveUnusedMethodsInModelsCheck: { except_methods: [] }
+RemoveTrailingWhitespaceCheck: { }
 RemoveUnusedMethodsInControllersCheck: { except_methods: [] }
 RemoveUnusedMethodsInHelpersCheck: { except_methods: [] }
-NotUseTimeAgoInWordsCheck: { }
-ProtectMassAssignmentCheck: { }
+RemoveUnusedMethodsInModelsCheck: { except_methods: [] }
+ReplaceComplexCreationWithFactoryMethodCheck: { attribute_assignment_count: 2 }
+ReplaceInstanceVariableWithLocalVariableCheck: { }
+RestrictAutoGeneratedRoutesCheck: { }
+SimplifyRenderInControllersCheck: { }
+SimplifyRenderInViewsCheck: { }
+UseBeforeFilterCheck: { customize_count: 2 }
+UseModelAssociationCheck: { }
+UseMultipartAlternativeAsContentTypeOfEmailCheck: { }
+UseParenthesesInMethodDefCheck: { }
+UseObserverCheck: { }
+UseQueryAttributeCheck: { }
+UseSayWithTimeInMigrationsCheck: { }
+UseScopeAccessCheck: { }

data/rake_rubies.sh

@@ -1,5 +1,5 @@
 #!/bin/bash
-rubies=( 1.9.2-p290 1.9.3-p125 )
+rubies=( 1.9.2-p320 1.9.3-p194 )
 gemset="rails_best_practices"
 
 for x in ${rubies[*]}

data/spec/rails_best_practices/analyzer_spec.rb

@@ -29,7 +29,7 @@ module RailsBestPractices
       it "should output errors in terminal" do
         check1 = Reviews::LawOfDemeterReview.new
         check2 = Reviews::UseQueryAttributeReview.new
-        runner = Core::Runner.new(:reviews => [check1, check2])
+        runner = Core::Runner.new(reviews: [check1, check2])
         check1.add_error "law of demeter", "app/models/user.rb", 10
         check2.add_error "use query attribute", "app/models/post.rb", 100
         subject.runner = runner

data/spec/rails_best_practices/core/check_spec.rb

@@ -14,19 +14,19 @@ module RailsBestPractices::Core
 
     context "node_start" do
       it "should call start_if" do
-        node = stub(:sexp_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(:sexp_type => :call)
+        node = stub(sexp_type: :call)
         check.should_receive(:send).with("start_call", node)
         check.node_start(node)
       end
 
       it "should print node if debug mode" do
-        node = stub(:sexp_type => :call)
+        node = stub(sexp_type: :call)
         Check.class_eval { debug }
         check.should_receive(:send).with("start_call", node)
         check.should_receive(:ap).with(node)
@@ -37,13 +37,13 @@ module RailsBestPractices::Core
 
     context "node_end" do
       it "should call end_if" do
-        node = stub(:sexp_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(:sexp_type => :call)
+        node = stub(sexp_type: :call)
         check.should_receive(:send).with("end_call", node)
         check.node_end(node)
       end
@@ -55,7 +55,7 @@ module RailsBestPractices::Core
         check.class.add_callback "start_call" do
           execute = true
         end
-        node = stub(:sexp_type => :call)
+        node = stub(sexp_type: :call)
         check.node_start(node)
         execute.should be_true
       end
@@ -65,7 +65,7 @@ module RailsBestPractices::Core
         check.class.add_callback "end_call" do
           execute = true
         end
-        node = stub(:sexp_type => :call)
+        node = stub(sexp_type: :call)
         check.node_end(node)
         execute.should be_true
       end

data/spec/rails_best_practices/core/checking_visitor_spec.rb

@@ -34,9 +34,9 @@ module RailsBestPractices::Core
     let(:review2) { TestReview2.new }
     let(:visitor) {
       CheckingVisitor.new(
-        :lexicals => [lexical1, lexical2],
-        :prepares => [prepare1, prepare2],
-        :reviews => [review1, review2]
+        lexicals: [lexical1, lexical2],
+        prepares: [prepare1, prepare2],
+        reviews: [review1, review2]
       )
     }
 
@@ -49,28 +49,28 @@ module RailsBestPractices::Core
     end
 
     it "should prepare model associations" do
-      node = stub(:sexp_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(:sexp_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(:sexp_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(:sexp_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/error_spec.rb

@@ -8,27 +8,27 @@ module RailsBestPractices::Core
 
     it "should return error with filename, line number and message" do
       Error.new(
-        :filename => "app/models/user.rb",
-        :line_number => "100",
-        :message => "not good",
-        :type => "BogusReview").to_s.should == "app/models/user.rb:100 - not good"
+        filename: "app/models/user.rb",
+        line_number: "100",
+        message: "not good",
+        type: "BogusReview").to_s.should == "app/models/user.rb:100 - not good"
     end
 
     it "should return short filename" do
       Runner.base_path = "../rails-bestpractices.com"
       Error.new(
-        :filename => "../rails-bestpractices.com/app/models/user.rb",
-        :line_number => "100",
-        :message => "not good",
-        :type => "BogusReview").short_filename.should == "app/models/user.rb"
+        filename: "../rails-bestpractices.com/app/models/user.rb",
+        line_number: "100",
+        message: "not good",
+        type: "BogusReview").short_filename.should == "app/models/user.rb"
     end
 
     it "should return first line number" do
       Error.new(
-        :filename => "app/models/user.rb",
-        :line_number => "50,70,100",
-        :message => "not good",
-        :type => "BogusReview").first_line_number.should == "50"
+        filename: "app/models/user.rb",
+        line_number: "50,70,100",
+        message: "not good",
+        type: "BogusReview").first_line_number.should == "50"
     end
   end
 end

data/spec/rails_best_practices/core_ext/sexp_spec.rb

@@ -9,29 +9,34 @@ describe Sexp do
           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
+      @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
+      @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
+      @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
+      @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
+      @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
 
@@ -47,7 +52,7 @@ describe Sexp do
 
     it "should get the call nodes with subject current_user" do
       nodes = []
-      @node.grep_nodes(:sexp_type => :call, :subject => "current_user") { |node| nodes << node }
+      @node.grep_nodes(sexp_type: :call, subject: "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
@@ -57,7 +62,7 @@ describe Sexp do
 
     it "should get the call nodes with different messages" do
       nodes = []
-      @node.grep_nodes(:sexp_type => :call, :message => ["posts", "find"]) { |node| nodes << node }
+      @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
@@ -68,13 +73,13 @@ describe Sexp do
     if RUBY_VERSION == "1.9.2"
       it "should get the var_ref node with to_s" do
         nodes = []
-        @node.grep_nodes(:sexp_type => :var_ref, :to_s => "current_user") { |node| nodes << node }
+        @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 }
+        @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
@@ -91,7 +96,7 @@ describe Sexp do
     end
 
     it "should get first node with empty argument" do
-      node = @node.grep_node(:sexp_type => :call, :subject => "current_user")
+      node = @node.grep_node(sexp_type: :call, subject: "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
@@ -111,13 +116,13 @@ describe Sexp do
     end
 
     it "should get the count of call nodes" do
-      @node.grep_nodes_count(:sexp_type => :call).should == 2
+      @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)
+      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"
@@ -125,17 +130,17 @@ describe Sexp do
     end
 
     it "should get subject of field node" do
-      node = parse_content("user.name = params[:name]").grep_node(:sexp_type => :field)
+      node = parse_content("user.name = params[:name]").grep_node(sexp_type: :field)
       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 = 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 = parse_content("user == 'user_name'").grep_node(sexp_type: :binary)
       node.subject.to_s.should == "user"
     end
 
@@ -144,152 +149,152 @@ describe Sexp do
       map.resources :posts do
       end
       EOF
-      node = parse_content(content).grep_node(:sexp_type => :command_call)
+      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 = 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 = parse_content("Post.save do; end").grep_node(sexp_type: :method_add_block)
       node.subject.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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = parse_content("user.posts.map(&:title)").grep_node(sexp_type: :args_add_block)
       node.all.map(&:to_s).should == ["title"]
     end
 
     it "no error for args_add_star" do
-      node = parse_content("send(:\"\#{route}_url\", *args)").grep_node(:sexp_type => :args_add_block)
+      node = parse_content("send(:\"\#{route}_url\", *args)").grep_node(sexp_type: :args_add_block)
       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 = 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 = parse_content("unless true; end").grep_node(sexp_type: :unless)
       node.conditional_statement.to_s.should == "true"
     end
 
@@ -299,100 +304,108 @@ describe Sexp do
       elsif false
       end
       EOF
-      node = parse_content(content).grep_node(:sexp_type => :elsif)
+      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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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
@@ -400,65 +413,65 @@ describe Sexp do
 
   describe "hash_size" do
     it "should get value for hash node" do
-      node = parse_content("{first_name: 'Richard', last_name: 'Huang'}").grep_node(:sexp_type => :hash)
+      node = parse_content("{first_name: 'Richard', last_name: 'Huang'}").grep_node(sexp_type: :hash)
       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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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
@@ -466,7 +479,7 @@ describe Sexp do
   describe "alias" do
     context "method" do
       before do
-        @node = parse_content("alias new old").grep_node(:sexp_type => :alias)
+        @node = parse_content("alias new old").grep_node(sexp_type: :alias)
       end
 
       it "should get old_method" do
@@ -480,7 +493,7 @@ describe Sexp do
 
     context "symbol" do
       before do
-        @node = parse_content("alias :new :old").grep_node(:sexp_type => :alias)
+        @node = parse_content("alias :new :old").grep_node(sexp_type: :alias)
       end
 
       it "should get old_method" do
@@ -495,76 +508,81 @@ describe Sexp do
 
   describe "to_object" do
     it "should to array" do
-      node = parse_content("['first_name', 'last_name']").grep_node(:sexp_type => :array)
+      node = parse_content("['first_name', 'last_name']").grep_node(sexp_type: :array)
       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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = parse_content("@user.find").grep_node(sexp_type: :@ivar)
       node.should_not be_const
     end
   end