rails_best_practices 1.19.0 → 1.19.1

data/spec/rails_best_practices/core/gems_spec.rb

@@ -6,23 +6,23 @@ module RailsBestPractices::Core
 
     let(:gems) { Gems.new }
     before do
-      gems << Gem.new("rails", "4.0.0")
-      gems << Gem.new("mysql2", "0.2.0")
+      gems << Gem.new('rails', '4.0.0')
+      gems << Gem.new('mysql2', '0.2.0')
     end
 
-    context "#has_gem?" do
-      it "has rails gem" do
-        expect(gems).to be_has_gem "rails"
+    context '#has_gem?' do
+      it 'has rails gem' do
+        expect(gems).to be_has_gem 'rails'
       end
 
       it "hasn't sinatra gem" do
-        expect(gems).not_to be_has_gem "sinatra"
+        expect(gems).not_to be_has_gem 'sinatra'
       end
     end
 
-    context "#gem_version" do
-      it "gets rails version" do
-        expect(gems.gem_version("rails")).to eq "4.0.0"
+    context '#gem_version' do
+      it 'gets rails version' do
+        expect(gems.gem_version('rails')).to eq '4.0.0'
       end
     end
   end

data/spec/rails_best_practices/core/klasses_spec.rb

@@ -4,33 +4,33 @@ module RailsBestPractices::Core
   describe Klasses do
     it { should be_a_kind_of Array }
 
-    context "Klass" do
-      context "#class_name" do
-        it "gets class name without module" do
-          klass = Klass.new("BlogPost", "Post", [])
-          expect(klass.class_name).to eq("BlogPost")
+    context 'Klass' do
+      context '#class_name' do
+        it 'gets class name without module' do
+          klass = Klass.new('BlogPost', 'Post', [])
+          expect(klass.class_name).to eq('BlogPost')
         end
 
-        it "gets class name with moduel" do
-          klass = Klass.new("BlogPost", "Post", ["Admin"])
-          expect(klass.class_name).to eq("Admin::BlogPost")
+        it 'gets class name with moduel' do
+          klass = Klass.new('BlogPost', 'Post', ['Admin'])
+          expect(klass.class_name).to eq('Admin::BlogPost')
         end
       end
 
-      context "#extend_class_name" do
-        it "gets extend class name without module" do
-          klass = Klass.new("BlogPost", "Post", [])
-          expect(klass.extend_class_name).to eq("Post")
+      context '#extend_class_name' do
+        it 'gets extend class name without module' do
+          klass = Klass.new('BlogPost', 'Post', [])
+          expect(klass.extend_class_name).to eq('Post')
         end
 
-        it "gets extend class name with module" do
-          klass = Klass.new("BlogPost", "Post", ["Admin"])
-          expect(klass.extend_class_name).to eq("Admin::Post")
+        it 'gets extend class name with module' do
+          klass = Klass.new('BlogPost', 'Post', ['Admin'])
+          expect(klass.extend_class_name).to eq('Admin::Post')
         end
       end
 
-      it "gets to_s equal to class_name" do
-        klass = Klass.new("BlogPost", "Post", ["Admin"])
+      it 'gets to_s equal to class_name' do
+        klass = Klass.new('BlogPost', 'Post', ['Admin'])
         expect(klass.to_s).to eq(klass.class_name)
       end
     end

data/spec/rails_best_practices/core/methods_spec.rb

@@ -5,42 +5,42 @@ module RailsBestPractices::Core
     let(:methods) { Methods.new }
 
     before :each do
-      methods.add_method("Post", "create")
-      methods.add_method("Post", "destroy")
-      methods.add_method("Post", "save_or_update", {}, "protected")
-      methods.add_method("Post", "find_by_sql", {}, "private")
-      methods.add_method("Comment", "create")
+      methods.add_method('Post', 'create')
+      methods.add_method('Post', 'destroy')
+      methods.add_method('Post', 'save_or_update', {}, 'protected')
+      methods.add_method('Post', 'find_by_sql', {}, 'private')
+      methods.add_method('Comment', 'create')
     end
 
-    it "should get_methods" do
-      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"])
+    it 'should get_methods' do
+      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
-      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")
+    it 'should has_method?' do
+      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
-      expect(methods.get_method("Post", "create", "public")).not_to be_nil
-      expect(methods.get_method("Post", "create", "protected")).to be_nil
+    it 'should get_method' do
+      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
-      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"])
+    it 'should get_all_unused_methods' do
+      methods.get_method('Comment', 'create').mark_used
+      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

@@ -5,20 +5,20 @@ module RailsBestPractices::Core
     let(:model_associations) { 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
-      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
+    it 'should get model associations' do
+      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
-      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
+    it 'should check is model associatiosn' do
+      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

@@ -5,20 +5,20 @@ module RailsBestPractices::Core
     let(:model_attributes) { ModelAttributes.new }
 
     before :each do
-      model_attributes.add_attribute("Post", "title", :string)
-      model_attributes.add_attribute("Post", "user_id", :integer)
+      model_attributes.add_attribute('Post', 'title', :string)
+      model_attributes.add_attribute('Post', 'user_id', :integer)
     end
 
-    it "should get model attributes" do
-      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
+    it 'should get model attributes' do
+      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
-      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
+    it 'should check is model attributes' do
+      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

@@ -4,25 +4,25 @@ module RailsBestPractices::Core
   describe Modules do
     it { should be_a_kind_of Array }
 
-    context "Modules" do
+    context 'Modules' do
       before do
-        @mod = Mod.new("PostsHelper", [])
+        @mod = Mod.new('PostsHelper', [])
       end
       subject { Modules.new.tap { |modules| modules << @mod } }
-      it "should add descendant to the corresponding module" do
-        expect(@mod).to receive(:add_descendant).with("PostsController")
-        subject.add_module_descendant("PostsHelper", "PostsController")
+      it 'should add descendant to the corresponding module' do
+        expect(@mod).to receive(:add_descendant).with('PostsController')
+        subject.add_module_descendant('PostsHelper', 'PostsController')
       end
     end
 
-    context "Mod" do
+    context 'Mod' do
       subject {
-        Mod.new("UsersHelper", ["Admin"]).tap do |mod|
-          mod.add_descendant("Admin::UsersController")
+        Mod.new('UsersHelper', ['Admin']).tap do |mod|
+          mod.add_descendant('Admin::UsersController')
         end
       }
-      it { expect(subject.to_s).to eq("Admin::UsersHelper") }
-      it { expect(subject.descendants).to eq(["Admin::UsersController"]) }
+      it { expect(subject.to_s).to eq('Admin::UsersHelper') }
+      it { expect(subject.descendants).to eq(['Admin::UsersController']) }
     end
   end
 end

data/spec/rails_best_practices/core/routes_spec.rb

@@ -4,25 +4,25 @@ module RailsBestPractices::Core
   describe Routes do
     let(:routes) { Routes.new }
 
-    it "should add route" do
-      routes.add_route(["admin", "test"], "posts", "new")
-      expect(routes.map(&:to_s)).to eq(["Admin::Test::PostsController#new"])
+    it 'should add route' do
+      routes.add_route(['admin', 'test'], 'posts', '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
+    context 'route' do
+      it 'should add namesapces, controller name and action name' do
         route = Route.new(['admin', 'test'], 'posts', 'new')
-        expect(route.to_s).to eq("Admin::Test::PostsController#new")
+        expect(route.to_s).to eq('Admin::Test::PostsController#new')
       end
 
-      it "should add controller name with namespace" do
+      it 'should add controller name with namespace' do
         route = Route.new(['admin'], 'test/posts', 'new')
-        expect(route.to_s).to eq("Admin::Test::PostsController#new")
+        expect(route.to_s).to eq('Admin::Test::PostsController#new')
       end
 
-      it "should add routes without controller" do
+      it 'should add routes without controller' do
         route = Route.new(['posts'], nil, 'new')
-        expect(route.to_s).to eq("PostsController#new")
+        expect(route.to_s).to eq('PostsController#new')
       end
     end
   end

data/spec/rails_best_practices/core/runner_spec.rb

@@ -2,20 +2,20 @@ require 'spec_helper'
 
 module RailsBestPractices::Core
   describe Runner do
-    describe "load_plugin_reviews" do
+    describe 'load_plugin_reviews' do
       shared_examples_for 'load_plugin_reviews' do
-        it "should load plugins in lib/rails_best_practices/plugins/reviews" do
+        it 'should load plugins in lib/rails_best_practices/plugins/reviews' do
           runner = Runner.new
           expect(runner.instance_variable_get('@reviews').map(&:class)).to include(RailsBestPractices::Plugins::Reviews::NotUseRailsRootReview)
         end
       end
 
-      context "given a path that ends with a slash" do
+      context 'given a path that ends with a slash' do
         before { Runner.base_path = 'spec/fixtures/' }
         it_should_behave_like 'load_plugin_reviews'
       end
 
-      context "given a path that does not end with a slash" do
+      context 'given a path that does not end with a slash' do
         before { Runner.base_path = 'spec/fixtures' }
         it_should_behave_like 'load_plugin_reviews'
       end

data/spec/rails_best_practices/core_ext/erubis_spec.rb

@@ -14,11 +14,11 @@ describe Erubis::OnlyRuby do
     Erubis::OnlyRuby.new(content).src
   }
 
-  it { should_not include("h1") }
-  it { should_not include("Title") }
-  it { should_not include("Not logged in") }
-  it { should include("current_user") }
-  it { should include("if") }
-  it { should include("else") }
-  it { should include("end") }
+  it { should_not include('h1') }
+  it { should_not include('Title') }
+  it { should_not include('Not logged in') }
+  it { should include('current_user') }
+  it { should include('if') }
+  it { should include('else') }
+  it { should include('end') }
 end

data/spec/rails_best_practices/lexicals/long_line_check_spec.rb

@@ -4,7 +4,7 @@ module RailsBestPractices
   module Lexicals
     describe LongLineCheck do
 
-      it "should find long lines" do
+      it 'should find long lines' do
         runner = Core::Runner.new(lexicals: LongLineCheck.new)
         content =<<-EOF
 class User < ActiveRecord::Base
@@ -17,10 +17,10 @@ EOF
         content.gsub!("\n", "\t\n")
         runner.lexical('app/models/user.rb', content)
         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)")
+        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))
+      it 'should find long lines with own max size' do
+        runner = Core::Runner.new(lexicals: LongLineCheck.new('max_line_length' => 90))
         content =<<-EOF
 class User < ActiveRecord::Base
 # 91 Chars
@@ -32,9 +32,9 @@ EOF
         content.gsub!("\n", "\t\n")
         runner.lexical('app/models/user.rb', content)
         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)")
+        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
+      it 'should not check non .rb files' do
         runner = Core::Runner.new(lexicals: LongLineCheck.new)
         content = "
 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
@@ -42,7 +42,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
         runner.lexical('app/views/users/index.html.erb', content)
         expect(runner.errors.size).to eq(0)
       end
-      it "should not check ignored files" do
+      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

data/spec/rails_best_practices/lexicals/remove_tab_check_spec.rb

@@ -5,7 +5,7 @@ module RailsBestPractices
     describe RemoveTabCheck do
       let(:runner) { Core::Runner.new(lexicals: RemoveTabCheck.new) }
 
-      it "should remove tab" do
+      it 'should remove tab' do
         content =<<-EOF
         class User < ActiveRecord::Base
           has_many :projects
@@ -14,10 +14,10 @@ module RailsBestPractices
         content.gsub!("\n", "\t\n")
         runner.lexical('app/models/user.rb', content)
         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")
+        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
+      it 'should remove tab with third line' do
         content =<<-EOF
         class User < ActiveRecord::Base
           has_many :projects
@@ -26,10 +26,10 @@ module RailsBestPractices
         EOF
         runner.lexical('app/models/user.rb', content)
         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")
+        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
+      it 'should not remove trailing whitespace' do
         content =<<-EOF
         class User < ActiveRecord::Base
           has_many :projects
@@ -38,7 +38,7 @@ module RailsBestPractices
         runner.lexical('app/models/user.rb', content)
         expect(runner.errors.size).to eq(0)
       end
-      it "should not check ignored files" do
+      it 'should not check ignored files' do
         runner = Core::Runner.new(lexicals: RemoveTabCheck.new(ignored_files: /user/))
         content =<<-EOF
         class User < ActiveRecord::Base

data/spec/rails_best_practices/lexicals/remove_trailing_whitespace_check_spec.rb

@@ -5,7 +5,7 @@ module RailsBestPractices
     describe RemoveTrailingWhitespaceCheck do
       let(:runner) { Core::Runner.new(lexicals: RemoveTrailingWhitespaceCheck.new) }
 
-      it "should remove trailing whitespace" do
+      it 'should remove trailing whitespace' do
         content =<<-EOF
         class User < ActiveRecord::Base
           has_many :projects
@@ -14,10 +14,10 @@ module RailsBestPractices
         content.gsub!("\n", "  \n")
         runner.lexical('app/models/user.rb', content)
         expect(runner.errors.size).to eq(1)
-        expect(runner.errors[0].to_s).to eq("app/models/user.rb:1 - remove trailing whitespace")
+        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
+      it 'should remove whitespace with third line' do
         content =<<-EOF
         class User < ActiveRecord::Base
           has_many :projects
@@ -26,10 +26,10 @@ module RailsBestPractices
         content.gsub!("d\n", "d  \n")
         runner.lexical('app/models/user.rb', content)
         expect(runner.errors.size).to eq(1)
-        expect(runner.errors[0].to_s).to eq("app/models/user.rb:3 - remove trailing whitespace")
+        expect(runner.errors[0].to_s).to eq('app/models/user.rb:3 - remove trailing whitespace')
       end
 
-      it "should not remove trailing whitespace" do
+      it 'should not remove trailing whitespace' do
         content =<<-EOF
         class User < ActiveRecord::Base
           has_many :projects
@@ -39,7 +39,7 @@ module RailsBestPractices
         expect(runner.errors.size).to eq(0)
       end
 
-      it "should not check ignored files" do
+      it 'should not check ignored files' do
         runner = Core::Runner.new(lexicals: RemoveTrailingWhitespaceCheck.new(ignored_files: /user/))
         content =<<-EOF
         class User < ActiveRecord::Base