rails_best_practices 0.6.6 → 0.6.7

data/rake_rubies.sh

@@ -4,6 +4,7 @@ gemset="rails_best_practices"
 
 for x in ${rubies[*]}
 do
-  rvm use --create $x@$gemset && bundle install || exit $?
+  rvm use --create $x@$gemset
+  bundle install
+  rake spec:progress
 done
-rvm ree@$gemset,1.8.7@$gemset,1.9.2@$gemset rake spec:progress

data/spec/rails_best_practices/core/check_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe RailsBestPractices::Core::Check do
+  let(:check) { RailsBestPractices::Core::Check.new }
+
+  it "should get empty interesting nodes" do
+    check.interesting_nodes.should == []
+  end
+
+  it "should match all files of interesting files" do
+    check.interesting_files.should == /.*/
+  end
+
+  context "node_start" do
+    it "should call start_if" do
+      node = stub(:node_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)
+      check.should_receive(:send).with("start_call", node)
+      check.node_start(node)
+    end
+  end
+
+  context "node_end" do
+    it "should call end_if" do
+      node = stub(:node_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)
+      check.should_receive(:send).with("end_call", node)
+      check.node_end(node)
+    end
+  end
+end

data/spec/rails_best_practices/core/checking_visitor_spec.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+require 'spec_helper'
+
+class TestPrepare1
+  def interesting_nodes
+    [:call]
+  end
+
+  def interesting_files
+    RailsBestPractices::Core::Check::MODEL_FILES
+  end
+end
+
+class TestPrepare2
+  def interesting_nodes
+    [:class]
+  end
+
+  def interesting_files
+    RailsBestPractices::Core::Check::MAILER_FILES
+  end
+end
+
+class TestReview1
+  def interesting_nodes
+    [:defn]
+  end
+
+  def interesting_files
+    RailsBestPractices::Core::Check::CONTROLLER_FILES
+  end
+end
+
+class TestReview2
+  def interesting_nodes
+    [:call]
+  end
+
+  def interesting_files
+    RailsBestPractices::Core::Check::VIEW_FILES
+  end
+end
+
+describe RailsBestPractices::Core::CheckingVisitor do
+  let(:prepare1) { TestPrepare1.new }
+  let(:prepare2) { TestPrepare2.new }
+  let(:review1) { TestReview1.new }
+  let(:review2) { TestReview2.new }
+  let(:visitor) { RailsBestPractices::Core::CheckingVisitor.new([prepare1, prepare2], [review1, review2]) }
+
+  it "should prepare model associations" do
+    node = stub(:node_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")
+    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")
+    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")
+    review2.should_receive(:node_start).with(node)
+    review2.should_receive(:node_end).with(node)
+    visitor.review(node)
+  end
+end

data/spec/rails_best_practices/core/visitable_sexp_spec.rb

@@ -1,20 +1,18 @@
 require 'spec_helper'
 
 describe Sexp do
-  before :each do
-    @parser = RubyParser.new
-  end
+  let(:parser) { RubyParser.new }
 
   describe "children" do
     it "should get all child nodes" do
-      node = @parser.parse("puts 'hello ', 'world'")
+      node = parser.parse("puts 'hello ', 'world'")
       node.children.should == [s(:arglist, s(:str, "hello "), s(:str, "world"))]
     end
   end
 
   describe "recursive_children" do
     it "should get all recursive child nodes" do
-      node = @parser.parse("puts 'hello', dynamic_output")
+      node = parser.parse("puts 'hello', dynamic_output")
       children = []
       node.recursive_children { |child| children << child }
       children.should == [s(:arglist, s(:str, "hello"), s(:call, nil, :dynamic_output, s(:arglist))), s(:str, "hello"), s(:call, nil, :dynamic_output, s(:arglist)), s(:arglist)]
@@ -28,7 +26,7 @@ describe Sexp do
         current_user.posts.find(params[:id])
       end
       EOF
-      @node = @parser.parse(content)
+      @node = parser.parse(content)
     end
 
     it "should get the call nodes with empty arguments" do
@@ -51,7 +49,7 @@ describe Sexp do
         current_user.posts.find(params[:id])
       end
       EOF
-      @node = @parser.parse(content)
+      @node = parser.parse(content)
     end
 
     it "should get first node with empty argument" do
@@ -67,7 +65,7 @@ describe Sexp do
         current_user.posts.find(params[:id])
       end
       EOF
-      @node = @parser.parse(content)
+      @node = parser.parse(content)
     end
 
     it "should get the count of call nodes" do
@@ -77,86 +75,86 @@ describe Sexp do
 
   describe "subject" do
     it "should get subject of attrasgn node" do
-      node = @parser.parse("user.name = params[:name]")
+      node = parser.parse("user.name = params[:name]")
       node.subject.should == s(:call, nil, :user, s(:arglist))
     end
 
     it "should get subject of call node" do
-      node = @parser.parse("user.name")
+      node = parser.parse("user.name")
       node.subject.should == s(:call, nil, :user, s(:arglist))
     end
 
     it "should get subject of iter node" do
-      node = @parser.parse("@users.each { |user| p user }")
+      node = parser.parse("@users.each { |user| p user }")
       node.subject.should == s(:call, s(:ivar, :@users), :each, s(:arglist))
     end
   end
 
   describe "class_name" do
     it "should get class name of class node" do
-      node = @parser.parse("class User; end")
+      node = parser.parse("class User; end")
       node.class_name.should == :User
     end
   end
 
   describe "base_class" do
     it "should get base class of class node" do
-      node = @parser.parse("class User < ActiveRecord::Base; end")
+      node = parser.parse("class User < ActiveRecord::Base; end")
       node.base_class.should == s(:colon2, s(:const, :ActiveRecord), :Base)
     end
   end
 
   describe "left_value" do
     it "should get the left value of lasgn" do
-      node = @parser.parse("user = params[:user]")
+      node = parser.parse("user = params[:user]")
       node.left_value.should == :user
     end
 
     it "should get the left value of iasgn" do
-      node = @parser.parse("@user = params[:user]")
+      node = parser.parse("@user = params[:user]")
       node.left_value.should == :@user
     end
   end
 
   describe "right_value" do
     it "should get the right value of lasgn" do
-      node = @parser.parse("user = current_user")
+      node = parser.parse("user = current_user")
       node.right_value.should == s(:call, nil, :current_user, s(:arglist))
     end
 
     it "should get the right value of iasgn" do
-      node = @parser.parse("@user = current_user")
+      node = parser.parse("@user = current_user")
       node.right_value.should == s(:call, nil, :current_user, s(:arglist))
     end
   end
 
   describe "message" do
     it "should get the message of attrasgn" do
-      node = @parser.parse("user.name = params[:name]")
+      node = parser.parse("user.name = params[:name]")
       node.message.should == :name=
     end
 
     it "should get the message of call" do
-      node = @parser.parse("has_many :projects")
+      node = parser.parse("has_many :projects")
       node.message.should == :has_many
     end
   end
 
   describe "arguments" do
     it "should get the arguments of attrasgn" do
-      node = @parser.parse("post.user = current_user")
+      node = parser.parse("post.user = current_user")
       node.arguments.should == s(:arglist, s(:call, nil, :current_user, s(:arglist)))
     end
 
     it "should get the arguments of call" do
-      node = @parser.parse("username == ''")
+      node = parser.parse("username == ''")
       node.arguments.should == s(:arglist, s(:str, ""))
     end
   end
 
   describe "conditional_statement" do
     it "should get conditional statement of if" do
-      node = @parser.parse("if current_user.present?; puts current_user.login; end")
+      node = parser.parse("if current_user.present?; puts current_user.login; end")
       node.conditional_statement.should == s(:call, s(:call, nil, :current_user, s(:arglist)), :present?, s(:arglist))
     end
   end
@@ -170,7 +168,7 @@ describe Sexp do
         current_user.email
       end
       EOF
-      node = @parser.parse(content)
+      node = parser.parse(content)
       node.true_node.should == s(:call, s(:call, nil, :current_user, s(:arglist)), :login, s(:arglist))
     end
   end
@@ -184,75 +182,80 @@ describe Sexp do
         current_user.email
       end
       EOF
-      node = @parser.parse(content)
+      node = parser.parse(content)
       node.false_node.should == s(:call, s(:call, nil, :current_user, s(:arglist)), :email, s(:arglist))
     end
   end
 
   describe "method_name" do
     it "should get the method name of defn" do
-      node = @parser.parse("def show; end")
+      node = parser.parse("def show; end")
       node.method_name.should == :show
     end
   end
 
   describe "body" do
     it "should get body of iter" do
-      node = @parser.parse("resources :posts do; resources :comments; end")
+      node = parser.parse("resources :posts do; resources :comments; end")
       node.body.should == s(:call, nil, :resources, s(:arglist, s(:lit, :comments)))
     end
 
     it "should get body of class" do
-      node = @parser.parse("class User; def login; end; def email; end; end")
+      node = parser.parse("class User; def login; end; def email; end; end")
       node.body.should == s(:block, s(:defn, :login, s(:args), s(:scope, s(:block, s(:nil)))),  s(:defn, :email, s(:args), s(:scope, s(:block, s(:nil)))))
     end
 
     it "should get body of defn" do
-      node = @parser.parse("def fullname; first_name + last+name; end")
+      node = parser.parse("def fullname; first_name + last+name; end")
       node.body.should == s(:block, s(:call, s(:call, s(:call, nil, :first_name, s(:arglist)), :+, s(:arglist, s(:call, nil, :last, s(:arglist)))), :+, s(:arglist, s(:call, nil, :name, s(:arglist)))))
     end
   end
 
   describe "to_s" do
     it "should get to_s for lvar" do
-      node = @parser.parse("user = current_user; user")
+      node = parser.parse("user = current_user; user")
       node.children[1].node_type.should == :lvar
       node.children[1].to_s.should == "user"
     end
 
     it "should get to_s for ivar" do
-      node = @parser.parse("@user")
+      node = parser.parse("@user")
       node.to_s.should == "@user"
     end
 
+    it "should get to_s for ivar with remove_at" do
+      node = parser.parse("@user")
+      node.to_s(:remove_at => true).should == "user"
+    end
+
     it "should get to_s for str" do
-      node = @parser.parse("'user'")
+      node = parser.parse("'user'")
       node.to_s.should == "user"
     end
 
     it "should get to_s for lit" do
-      node = @parser.parse("{:user => 'Richard'}")
+      node = parser.parse("{:user => 'Richard'}")
       node[1].to_s.should == "user"
     end
 
 
     it "should get to_s for const" do
-      node = @parser.parse("User")
+      node = parser.parse("User")
       node.to_s.should == "User"
     end
 
     it "should get to_s for array" do
-      node = @parser.parse("[@user1, @user2]")
+      node = parser.parse("[@user1, @user2]")
       node.to_s.should == '["@user1", "@user2"]'
     end
 
     it "should get to_s for hash" do
-      node = @parser.parse("{:first_name => 'Richard', :last_name => 'Huang'}")
+      node = parser.parse("{:first_name => 'Richard', :last_name => 'Huang'}")
       node.to_s.should == '{"first_name" => "Richard", "last_name" => "Huang"}'
     end
 
     it "should get to_s for colon2" do
-      node = @parser.parse("RailsBestPractices::Core")
+      node = parser.parse("RailsBestPractices::Core")
       node.to_s.should == "RailsBestPractices::Core"
     end
   end

data/spec/rails_best_practices/prepares/mailer_prepare_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe RailsBestPractices::Prepares::MailerPrepare do
+  let(:runner) { RailsBestPractices::Core::Runner.new(:prepares => RailsBestPractices::Prepares::MailerPrepare.new) }
+
+  it "should parse mailer names" do
+    content =<<-EOF
+    class ProjectMailer < ActionMailer::Base
+    end
+    EOF
+    runner.prepare('app/mailers/project_mailer.rb', content)
+    RailsBestPractices::Prepares.mailer_names.should == [:ProjectMailer]
+  end
+end

data/spec/rails_best_practices/prepares/model_prepare_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe RailsBestPractices::Prepares::ModelPrepare do
+  let(:runner) { RailsBestPractices::Core::Runner.new(:prepares => RailsBestPractices::Prepares::ModelPrepare.new) }
+
+  it "should parse model associations" do
+    content =<<-EOF
+    class Project < ActiveRecord::Base
+      belongs_to              :portfolio
+      has_one                 :project_manager
+      has_many                :milestones
+      has_and_belongs_to_many :categories
+    end
+    EOF
+    runner.prepare('app/models/project.rb', content)
+    model_associations = RailsBestPractices::Prepares.model_associations
+    model_associations["Project"]["portfolio"].should == :belongs_to
+    model_associations["Project"]["project_manager"].should == :has_one
+    model_associations["Project"]["milestones"].should == :has_many
+    model_associations["Project"]["categories"].should == :has_and_belongs_to_many
+  end
+end

data/spec/rails_best_practices/{checks/add_model_virtual_attribute_check_spec.rb → reviews/add_model_virtual_attribute_review_spec.rb}

@@ -1,9 +1,7 @@
 require 'spec_helper'
 
-describe RailsBestPractices::Checks::AddModelVirtualAttributeCheck do
-  before(:each) do
-    @runner = RailsBestPractices::Core::Runner.new(RailsBestPractices::Checks::AddModelVirtualAttributeCheck.new)
-  end
+describe RailsBestPractices::Reviews::AddModelVirtualAttributeReview do
+  let(:runner) { RailsBestPractices::Core::Runner.new(:reviews => RailsBestPractices::Reviews::AddModelVirtualAttributeReview.new) }
 
   it "should add model virtual attribute" do
     content = <<-EOF
@@ -17,10 +15,9 @@ describe RailsBestPractices::Checks::AddModelVirtualAttributeCheck do
       end
     end
     EOF
-    @runner.review('app/controllers/users_controller.rb', content)
-    errors = @runner.errors
-    errors.should_not be_empty
-    errors[0].to_s.should == "app/controllers/users_controller.rb:3 - add model virtual attribute (for @user)"
+    runner.review('app/controllers/users_controller.rb', content)
+    runner.should have(1).errors
+    runner.errors[0].to_s.should == "app/controllers/users_controller.rb:3 - add model virtual attribute (for @user)"
   end
 
   it "should add model virtual attribute with local assignment" do
@@ -35,10 +32,9 @@ describe RailsBestPractices::Checks::AddModelVirtualAttributeCheck do
       end
     end
     EOF
-    @runner.review('app/controllers/users_controller.rb', content)
-    errors = @runner.errors
-    errors.should_not be_empty
-    errors[0].to_s.should == "app/controllers/users_controller.rb:3 - add model virtual attribute (for user)"
+    runner.review('app/controllers/users_controller.rb', content)
+    runner.should have(1).errors
+    runner.errors[0].to_s.should == "app/controllers/users_controller.rb:3 - add model virtual attribute (for user)"
   end
 
   it "should not add model virtual attribute with differen param" do
@@ -53,9 +49,8 @@ describe RailsBestPractices::Checks::AddModelVirtualAttributeCheck do
       end
     end
     EOF
-    @runner.review('app/controllers/users_controller.rb', content)
-    errors = @runner.errors
-    errors.should be_empty
+    runner.review('app/controllers/users_controller.rb', content)
+    runner.should have(0).errors
   end
 
   it "should not add model virtual attribute with read" do
@@ -71,9 +66,8 @@ describe RailsBestPractices::Checks::AddModelVirtualAttributeCheck do
       end
     end
     EOF
-    @runner.review('app/controllers/users_controller.rb', content)
-    errors = @runner.errors
-    errors.should be_empty
+    runner.review('app/controllers/users_controller.rb', content)
+    runner.should have(0).errors
   end
 
   it "should add model virtual attribute with two dimension params" do
@@ -88,10 +82,9 @@ describe RailsBestPractices::Checks::AddModelVirtualAttributeCheck do
       end
     end
     EOF
-    @runner.review('app/controllers/users_controller.rb', content)
-    errors = @runner.errors
-    errors.should_not be_empty
-    errors[0].to_s.should == "app/controllers/users_controller.rb:3 - add model virtual attribute (for @user)"
+    runner.review('app/controllers/users_controller.rb', content)
+    runner.should have(1).errors
+    runner.errors[0].to_s.should == "app/controllers/users_controller.rb:3 - add model virtual attribute (for @user)"
   end
 
   it "should no add model virtual attribute with two dimension params" do
@@ -106,8 +99,7 @@ describe RailsBestPractices::Checks::AddModelVirtualAttributeCheck do
       end
     end
     EOF
-    @runner.review('app/controllers/users_controller.rb', content)
-    errors = @runner.errors
-    errors.should be_empty
+    runner.review('app/controllers/users_controller.rb', content)
+    runner.should have(0).errors
   end
 end