rails_best_practices 1.14.4 → 1.15.1

data/spec/rails_best_practices/core/methods_spec.rb

@@ -13,34 +13,34 @@ module RailsBestPractices::Core
     end
 
     it "should get_methods" do
-      methods.get_methods("Post").map(&:method_name).should == ["create", "destroy", "save_or_update", "find_by_sql"]
-      methods.get_methods("Post", "public").map(&:method_name).should == ["create", "destroy"]
-      methods.get_methods("Post", "protected").map(&:method_name).should == ["save_or_update"]
-      methods.get_methods("Post", "private").map(&:method_name).should == ["find_by_sql"]
-      methods.get_methods("Comment").map(&:method_name).should == ["create"]
+      expect(methods.get_methods("Post").map(&:method_name)).to eq(["create", "destroy", "save_or_update", "find_by_sql"])
+      expect(methods.get_methods("Post", "public").map(&:method_name)).to eq(["create", "destroy"])
+      expect(methods.get_methods("Post", "protected").map(&:method_name)).to eq(["save_or_update"])
+      expect(methods.get_methods("Post", "private").map(&:method_name)).to eq(["find_by_sql"])
+      expect(methods.get_methods("Comment").map(&:method_name)).to eq(["create"])
     end
 
     it "should has_method?" do
-      methods.should be_has_method("Post", "create", "public")
-      methods.should be_has_method("Post", "destroy", "public")
-      methods.should_not be_has_method("Post", "save_or_update", "public")
-      methods.should be_has_method("Post", "save_or_update", "protected")
-      methods.should_not be_has_method("Post", "find_by_sql", "public")
-      methods.should be_has_method("Post", "find_by_sql", "private")
-      methods.should_not be_has_method("Comment", "destroy")
+      expect(methods).to be_has_method("Post", "create", "public")
+      expect(methods).to be_has_method("Post", "destroy", "public")
+      expect(methods).not_to be_has_method("Post", "save_or_update", "public")
+      expect(methods).to be_has_method("Post", "save_or_update", "protected")
+      expect(methods).not_to be_has_method("Post", "find_by_sql", "public")
+      expect(methods).to be_has_method("Post", "find_by_sql", "private")
+      expect(methods).not_to be_has_method("Comment", "destroy")
     end
 
     it "should get_method" do
-      methods.get_method("Post", "create", "public").should_not be_nil
-      methods.get_method("Post", "create", "protected").should be_nil
+      expect(methods.get_method("Post", "create", "public")).not_to be_nil
+      expect(methods.get_method("Post", "create", "protected")).to be_nil
     end
 
     it "should get_all_unused_methods" do
       methods.get_method("Comment", "create").mark_used
-      methods.get_all_unused_methods("public").map(&:method_name).should == ["create", "destroy"]
-      methods.get_all_unused_methods("protected").map(&:method_name).should == ["save_or_update"]
-      methods.get_all_unused_methods("private").map(&:method_name).should == ["find_by_sql"]
-      methods.get_all_unused_methods.map(&:method_name).should == ["create", "destroy", "save_or_update", "find_by_sql"]
+      expect(methods.get_all_unused_methods("public").map(&:method_name)).to eq(["create", "destroy"])
+      expect(methods.get_all_unused_methods("protected").map(&:method_name)).to eq(["save_or_update"])
+      expect(methods.get_all_unused_methods("private").map(&:method_name)).to eq(["find_by_sql"])
+      expect(methods.get_all_unused_methods.map(&:method_name)).to eq(["create", "destroy", "save_or_update", "find_by_sql"])
     end
   end
 end

data/spec/rails_best_practices/core/model_associations_spec.rb

@@ -10,15 +10,15 @@ module RailsBestPractices::Core
     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", "unknown").should be_nil
+      expect(model_associations.get_association("Project", "project_manager")).to eq({"meta" => "belongs_to", "class_name" => "ProjectManager"})
+      expect(model_associations.get_association("Project", "people")).to eq({"meta" => "has_many", "class_name" => "Person"})
+      expect(model_associations.get_association("Project", "unknown")).to be_nil
     end
 
     it "should check is model associatiosn" do
-      model_associations.is_association?("Project", "project_manager").should be_true
-      model_associations.is_association?("Project", "people").should be_true
-      model_associations.is_association?("Project", "unknown").should be_false
+      expect(model_associations.is_association?("Project", "project_manager")).to eq true
+      expect(model_associations.is_association?("Project", "people")).to eq true
+      expect(model_associations.is_association?("Project", "unknown")).to eq false
     end
   end
 end

data/spec/rails_best_practices/core/model_attributes_spec.rb

@@ -10,15 +10,15 @@ module RailsBestPractices::Core
     end
 
     it "should get model attributes" do
-      model_attributes.get_attribute_type("Post", "title").should == :string
-      model_attributes.get_attribute_type("Post", "user_id").should == :integer
-      model_attributes.get_attribute_type("Post", "unknonw").should be_nil
+      expect(model_attributes.get_attribute_type("Post", "title")).to eq(:string)
+      expect(model_attributes.get_attribute_type("Post", "user_id")).to eq(:integer)
+      expect(model_attributes.get_attribute_type("Post", "unknonw")).to be_nil
     end
 
     it "should check is model attributes" do
-      model_attributes.is_attribute?("Post", "title").should be_true
-      model_attributes.is_attribute?("Post", "user_id").should be_true
-      model_attributes.is_attribute?("Post", "unknonw").should be_false
+      expect(model_attributes.is_attribute?("Post", "title")).to be true
+      expect(model_attributes.is_attribute?("Post", "user_id")).to be true
+      expect(model_attributes.is_attribute?("Post", "unknonw")).to be false
     end
   end
 end

data/spec/rails_best_practices/core/modules_spec.rb

@@ -10,7 +10,7 @@ module RailsBestPractices::Core
       end
       subject { Modules.new.tap { |modules| modules << @mod } }
       it "should add decendant to the corresponding module" do
-        @mod.should_receive(:add_decendant).with("PostsController")
+        expect(@mod).to receive(:add_decendant).with("PostsController")
         subject.add_module_decendant("PostsHelper", "PostsController")
       end
     end
@@ -21,8 +21,8 @@ module RailsBestPractices::Core
           mod.add_decendant("Admin::UsersController")
         end
       }
-      its(:to_s) { should == "Admin::UsersHelper" }
-      its(:decendants) { should == ["Admin::UsersController"] }
+      it { expect(subject.to_s).to eq("Admin::UsersHelper") }
+      it { expect(subject.decendants).to eq(["Admin::UsersController"]) }
     end
   end
 end

data/spec/rails_best_practices/core/routes_spec.rb

@@ -6,23 +6,23 @@ module RailsBestPractices::Core
 
     it "should add route" do
       routes.add_route(["admin", "test"], "posts", "new")
-      routes.map(&:to_s).should == ["Admin::Test::PostsController#new"]
+      expect(routes.map(&:to_s)).to eq(["Admin::Test::PostsController#new"])
     end
 
     context "route" do
       it "should add namesapces, controller name and action name" do
         route = Route.new(['admin', 'test'], 'posts', 'new')
-        route.to_s.should == "Admin::Test::PostsController#new"
+        expect(route.to_s).to eq("Admin::Test::PostsController#new")
       end
 
       it "should add controller name with namespace" do
         route = Route.new(['admin'], 'test/posts', 'new')
-        route.to_s.should == "Admin::Test::PostsController#new"
+        expect(route.to_s).to eq("Admin::Test::PostsController#new")
       end
 
       it "should add routes without controller" do
         route = Route.new(['posts'], nil, 'new')
-        route.to_s.should == "PostsController#new"
+        expect(route.to_s).to eq("PostsController#new")
       end
     end
   end

data/spec/rails_best_practices/core/runner_spec.rb

@@ -6,7 +6,7 @@ module RailsBestPractices::Core
       shared_examples_for 'load_plugin_reviews' do
         it "should load plugins in lib/rails_best_practices/plugins/reviews" do
           runner = Runner.new
-          runner.instance_variable_get('@reviews').map(&:class).should include(RailsBestPractices::Plugins::Reviews::NotUseRailsRootReview)
+          expect(runner.instance_variable_get('@reviews').map(&:class)).to include(RailsBestPractices::Plugins::Reviews::NotUseRailsRootReview)
         end
       end
 

data/spec/rails_best_practices/lexicals/long_line_check_spec.rb

@@ -16,11 +16,11 @@ end
 EOF
         content.gsub!("\n", "\t\n")
         runner.lexical('app/models/user.rb', content)
-        runner.should have(1).errors
-        runner.errors[0].to_s.should == "app/models/user.rb:3 - line is longer than 80 characters (81 characters)"
+        expect(runner.errors.size).to eq(1)
+        expect(runner.errors[0].to_s).to eq("app/models/user.rb:3 - line is longer than 80 characters (81 characters)")
       end
       it "should find long lines with own max size" do
-        runner = Core::Runner.new(lexicals: LongLineCheck.new('max_line_length' => 90))
+        runner = Core::Runner.new(lexicals: LongLineCheck.new("max_line_length" => 90))
         content =<<-EOF
 class User < ActiveRecord::Base
 # 91 Chars
@@ -31,8 +31,8 @@ end
 EOF
         content.gsub!("\n", "\t\n")
         runner.lexical('app/models/user.rb', content)
-        runner.should have(1).errors
-        runner.errors[0].to_s.should == "app/models/user.rb:3 - line is longer than 90 characters (91 characters)"
+        expect(runner.errors.size).to eq(1)
+        expect(runner.errors[0].to_s).to eq("app/models/user.rb:3 - line is longer than 90 characters (91 characters)")
       end
       it "should not check non .rb files" do
         runner = Core::Runner.new(lexicals: LongLineCheck.new)
@@ -40,7 +40,19 @@ EOF
 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
 "
         runner.lexical('app/views/users/index.html.erb', content)
-        runner.should have(0).errors
+        expect(runner.errors.size).to eq(0)
+      end
+      it "should not check ignored files" do
+        runner = Core::Runner.new(lexicals: LongLineCheck.new(max_line_length: 80, ignored_files: /user/))
+        content =<<-EOF
+class User < ActiveRecord::Base
+# 81 Chars
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+end
+        EOF
+        content.gsub!("\n", "\t\n")
+        runner.lexical('app/models/user.rb', content)
+        expect(runner.errors.size).to eq(0)
       end
     end
   end

data/spec/rails_best_practices/lexicals/remove_tab_check_spec.rb

@@ -13,8 +13,8 @@ module RailsBestPractices
         EOF
         content.gsub!("\n", "\t\n")
         runner.lexical('app/models/user.rb', content)
-        runner.should have(1).errors
-        runner.errors[0].to_s.should == "app/models/user.rb:1 - remove tab, use spaces instead"
+        expect(runner.errors.size).to eq(1)
+        expect(runner.errors[0].to_s).to eq("app/models/user.rb:1 - remove tab, use spaces instead")
       end
 
       it "should remove tab with third line" do
@@ -25,8 +25,8 @@ module RailsBestPractices
         end
         EOF
         runner.lexical('app/models/user.rb', content)
-        runner.should have(1).errors
-        runner.errors[0].to_s.should == "app/models/user.rb:3 - remove tab, use spaces instead"
+        expect(runner.errors.size).to eq(1)
+        expect(runner.errors[0].to_s).to eq("app/models/user.rb:3 - remove tab, use spaces instead")
       end
 
       it "should not remove trailing whitespace" do
@@ -36,7 +36,20 @@ module RailsBestPractices
         end
         EOF
         runner.lexical('app/models/user.rb', content)
-        runner.should have(0).errors
+        expect(runner.errors.size).to eq(0)
+      end
+      it "should not check ignored files" do
+        runner = Core::Runner.new(lexicals: RemoveTabCheck.new(ignored_files: /user/))
+        content =<<-EOF
+        class User < ActiveRecord::Base
+          has_many :projects
+
+  \t
+        end
+        EOF
+        content.gsub!("\n", "\t\n")
+        runner.lexical('app/models/user.rb', content)
+        expect(runner.errors.size).to eq(0)
       end
     end
   end

data/spec/rails_best_practices/lexicals/remove_trailing_whitespace_check_spec.rb

@@ -13,8 +13,8 @@ module RailsBestPractices
         EOF
         content.gsub!("\n", "  \n")
         runner.lexical('app/models/user.rb', content)
-        runner.should have(1).errors
-        runner.errors[0].to_s.should == "app/models/user.rb:1 - remove trailing whitespace"
+        expect(runner.errors.size).to eq(1)
+        expect(runner.errors[0].to_s).to eq("app/models/user.rb:1 - remove trailing whitespace")
       end
 
       it "should remove whitespace with third line" do
@@ -25,8 +25,8 @@ module RailsBestPractices
         EOF
         content.gsub!("d\n", "d  \n")
         runner.lexical('app/models/user.rb', content)
-        runner.should have(1).errors
-        runner.errors[0].to_s.should == "app/models/user.rb:3 - remove trailing whitespace"
+        expect(runner.errors.size).to eq(1)
+        expect(runner.errors[0].to_s).to eq("app/models/user.rb:3 - remove trailing whitespace")
       end
 
       it "should not remove trailing whitespace" do
@@ -36,7 +36,19 @@ module RailsBestPractices
         end
         EOF
         runner.lexical('app/models/user.rb', content)
-        runner.should have(0).errors
+        expect(runner.errors.size).to eq(0)
+      end
+
+      it "should not check ignored files" do
+        runner = Core::Runner.new(lexicals: RemoveTrailingWhitespaceCheck.new(ignored_files: /user/))
+        content =<<-EOF
+        class User < ActiveRecord::Base
+          has_many :projects
+        end
+        EOF
+        content.gsub!("\n", "  \n")
+        runner.lexical('app/models/user.rb', content)
+        expect(runner.errors.size).to eq(0)
       end
     end
   end

data/spec/rails_best_practices/prepares/config_prepare_spec.rb

@@ -16,7 +16,7 @@ module RailsBestPractices
           EOF
           runner.prepare('config/application.rb', content)
           configs = Prepares.configs
-          configs["config.active_record.whitelist_attributes"].should == "true"
+          expect(configs["config.active_record.whitelist_attributes"]).to eq("true")
         end
       end
     end

data/spec/rails_best_practices/prepares/controller_prepare_spec.rb

@@ -15,7 +15,7 @@ module RailsBestPractices
           EOF
           runner.prepare('app/controllers/posts_controller.rb', content)
           methods = Prepares.controller_methods
-          methods.get_methods("PostsController").map(&:method_name).should == ["index", "show"]
+          expect(methods.get_methods("PostsController").map(&:method_name)).to eq(["index", "show"])
         end
 
         it "should parse model methods with access control" do
@@ -31,10 +31,10 @@ module RailsBestPractices
           EOF
           runner.prepare('app/controllers/posts_controller.rb', content)
           methods = Prepares.controller_methods
-          methods.get_methods("PostsController").map(&:method_name).should == ["index", "show", "resources", "resource"]
-          methods.get_methods("PostsController", "public").map(&:method_name).should == ["index", "show"]
-          methods.get_methods("PostsController", "protected").map(&:method_name).should == ["resources"]
-          methods.get_methods("PostsController", "private").map(&:method_name).should == ["resource"]
+          expect(methods.get_methods("PostsController").map(&:method_name)).to eq(["index", "show", "resources", "resource"])
+          expect(methods.get_methods("PostsController", "public").map(&:method_name)).to eq(["index", "show"])
+          expect(methods.get_methods("PostsController", "protected").map(&:method_name)).to eq(["resources"])
+          expect(methods.get_methods("PostsController", "private").map(&:method_name)).to eq(["resource"])
         end
 
         it "should parse controller methods with module ::" do
@@ -46,7 +46,7 @@ module RailsBestPractices
           EOF
           runner.prepare('app/controllers/admin/posts_controller.rb', content)
           methods = Prepares.controller_methods
-          methods.get_methods("Admin::Blog::PostsController").map(&:method_name).should == ["index", "show"]
+          expect(methods.get_methods("Admin::Blog::PostsController").map(&:method_name)).to eq(["index", "show"])
         end
 
         it "should parse controller methods with module" do
@@ -62,7 +62,7 @@ module RailsBestPractices
           EOF
           runner.prepare('app/controllers/admin/posts_controller.rb', content)
           methods = Prepares.controller_methods
-          methods.get_methods("Admin::Blog::PostsController").map(&:method_name).should == ["index", "show"]
+          expect(methods.get_methods("Admin::Blog::PostsController").map(&:method_name)).to eq(["index", "show"])
         end
 
         context "inherited_resources" do
@@ -73,7 +73,7 @@ module RailsBestPractices
             EOF
             runner.prepare('app/controllers/posts_controller.rb', content)
             methods = Prepares.controller_methods
-            methods.get_methods("PostsController").map(&:method_name).should == ["index", "show", "new", "create", "edit", "update", "destroy"]
+            expect(methods.get_methods("PostsController").map(&:method_name)).to eq(["index", "show", "new", "create", "edit", "update", "destroy"])
           end
 
           it "extend inherited_resources with actions" do
@@ -84,7 +84,7 @@ module RailsBestPractices
             EOF
             runner.prepare('app/controllers/posts_controller.rb', content)
             methods = Prepares.controller_methods
-            methods.get_methods("PostsController").map(&:method_name).should == ["index", "show"]
+            expect(methods.get_methods("PostsController").map(&:method_name)).to eq(["index", "show"])
           end
 
           it "extend inherited_resources with all actions" do
@@ -95,7 +95,7 @@ module RailsBestPractices
             EOF
             runner.prepare('app/controllers/posts_controller.rb', content)
             methods = Prepares.controller_methods
-            methods.get_methods("PostsController").map(&:method_name).should == ["index", "new", "create", "edit", "update", "destroy"]
+            expect(methods.get_methods("PostsController").map(&:method_name)).to eq(["index", "new", "create", "edit", "update", "destroy"])
           end
 
           it "extend inherited_resources with all actions with no arguments" do
@@ -106,7 +106,7 @@ module RailsBestPractices
             EOF
             runner.prepare('app/controllers/posts_controller.rb', content)
             methods = Prepares.controller_methods
-            methods.get_methods("PostsController").map(&:method_name).should == ["index", "show", "new", "create", "edit", "update", "destroy"]
+            expect(methods.get_methods("PostsController").map(&:method_name)).to eq(["index", "show", "new", "create", "edit", "update", "destroy"])
           end
 
           it "DSL inherit_resources" do
@@ -117,7 +117,7 @@ module RailsBestPractices
             EOF
             runner.prepare('app/controllers/posts_controller.rb', content)
             methods = Prepares.controller_methods
-            methods.get_methods("PostsController").map(&:method_name).should == ["index", "show", "new", "create", "edit", "update", "destroy"]
+            expect(methods.get_methods("PostsController").map(&:method_name)).to eq(["index", "show", "new", "create", "edit", "update", "destroy"])
           end
         end
       end
@@ -136,7 +136,7 @@ module RailsBestPractices
           EOF
           runner.prepare('app/controllers/posts_controller.rb', content)
           helpers = Prepares.helpers
-          helpers.first.decendants.should == ["PostsController"]
+          expect(helpers.first.decendants).to eq(["PostsController"])
         end
       end
     end

data/spec/rails_best_practices/prepares/gemfile_prepare_spec.rb

@@ -26,7 +26,7 @@ PLATFORMS
           EOF
           runner.prepare('Gemfile.lock', content)
           gems = Prepares.gems
-          gems.map(&:to_s).should == ["rails (3.2.13)", "mysql2 (0.3.12b6)"]
+          expect(gems.map(&:to_s)).to eq(["rails (3.2.13)", "mysql2 (0.3.12b6)"])
         end
       end
     end

data/spec/rails_best_practices/prepares/helper_prepare_spec.rb

@@ -15,7 +15,7 @@ module RailsBestPractices
           EOF
           runner.prepare('app/helpers/posts_helper.rb', content)
           methods = Prepares.helper_methods
-          methods.get_methods("PostsHelper").map(&:method_name).should == ["used", "unused"]
+          expect(methods.get_methods("PostsHelper").map(&:method_name)).to eq(["used", "unused"])
         end
 
         it "should parse helpers" do
@@ -37,7 +37,7 @@ module RailsBestPractices
           EOF
           runner.prepare("app/helpers/base_helper.rb", content)
           helpers = Prepares.helpers
-          helpers.map(&:to_s).should == ["PostsHelper", "Admin::UsersHelper", "Admin", "Admin::BaseHelper"]
+          expect(helpers.map(&:to_s)).to eq(["PostsHelper", "Admin::UsersHelper", "Admin", "Admin::BaseHelper"])
         end
       end
     end

data/spec/rails_best_practices/prepares/initializer_prepare_spec.rb

@@ -14,7 +14,7 @@ module RailsBestPractices
           EOF
           runner.prepare('config/initializers/ar.rb', content)
           configs = Prepares.configs
-          configs["railsbp.include_forbidden_attributes_protection"].should == "true"
+          expect(configs["railsbp.include_forbidden_attributes_protection"]).to eq("true")
         end
 
         it "should not set include_forbidden_attributes_protection config" do
@@ -24,7 +24,7 @@ module RailsBestPractices
           EOF
           runner.prepare('config/initializers/ar.rb', content)
           configs = Prepares.configs
-          configs["railsbp.include_forbidden_attributes_protection"].should be_nil
+          expect(configs["railsbp.include_forbidden_attributes_protection"]).to be_nil
         end
       end
     end

data/spec/rails_best_practices/prepares/mailer_prepare_spec.rb

@@ -11,7 +11,7 @@ module RailsBestPractices
         end
         EOF
         runner.prepare('app/mailers/project_mailer.rb', content)
-        Prepares.mailers.map(&:to_s).should == ["ProjectMailer"]
+        expect(Prepares.mailers.map(&:to_s)).to eq(["ProjectMailer"])
       end
     end
   end