rails_best_practices 1.19.2 → 1.20.1

data/spec/rails_best_practices/core/methods_spec.rb

@@ -4,9 +4,9 @@ require 'spec_helper'
 
 module RailsBestPractices::Core
   describe Methods do
-    let(:methods) { Methods.new }
+    let(:methods) { described_class.new }
 
-    before :each do
+    before do
       methods.add_method('Post', 'create')
       methods.add_method('Post', 'destroy')
       methods.add_method('Post', 'save_or_update', {}, 'protected')
@@ -14,7 +14,7 @@ module RailsBestPractices::Core
       methods.add_method('Comment', 'create')
     end
 
-    it 'should get_methods' do
+    it 'get_methodses' do
       expect(methods.get_methods('Post').map(&:method_name)).to eq(%w[create destroy save_or_update find_by_sql])
       expect(methods.get_methods('Post', 'public').map(&:method_name)).to eq(%w[create destroy])
       expect(methods.get_methods('Post', 'protected').map(&:method_name)).to eq(['save_or_update'])
@@ -22,7 +22,7 @@ module RailsBestPractices::Core
       expect(methods.get_methods('Comment').map(&:method_name)).to eq(['create'])
     end
 
-    it 'should has_method?' do
+    it 'has_method?s' 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')
@@ -32,12 +32,12 @@ module RailsBestPractices::Core
       expect(methods).not_to be_has_method('Comment', 'destroy')
     end
 
-    it 'should get_method' do
+    it 'get_methods' 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
+    it 'get_all_unused_methodses' do
       methods.get_method('Comment', 'create').mark_used
       expect(methods.get_all_unused_methods('public').map(&:method_name)).to eq(%w[create destroy])
       expect(methods.get_all_unused_methods('protected').map(&:method_name)).to eq(['save_or_update'])

data/spec/rails_best_practices/core/model_associations_spec.rb

@@ -4,20 +4,24 @@ require 'spec_helper'
 
 module RailsBestPractices::Core
   describe ModelAssociations do
-    let(:model_associations) { ModelAssociations.new }
+    let(:model_associations) { described_class.new }
 
-    before :each do
+    before do
       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')
+    it 'gets 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
+    it 'checks 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

data/spec/rails_best_practices/core/model_attributes_spec.rb

@@ -4,20 +4,20 @@ require 'spec_helper'
 
 module RailsBestPractices::Core
   describe ModelAttributes do
-    let(:model_attributes) { ModelAttributes.new }
+    let(:model_attributes) { described_class.new }
 
-    before :each do
+    before do
       model_attributes.add_attribute('Post', 'title', :string)
       model_attributes.add_attribute('Post', 'user_id', :integer)
     end
 
-    it 'should get model attributes' do
+    it 'gets 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
+    it 'checks 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

data/spec/rails_best_practices/core/models_spec.rb

@@ -4,6 +4,6 @@ require 'spec_helper'
 
 module RailsBestPractices::Core
   describe Models do
-    it { should be_a_kind_of Klasses }
+    it { is_expected.to be_a_kind_of Klasses }
   end
 end

data/spec/rails_best_practices/core/modules_spec.rb

@@ -4,25 +4,25 @@ require 'spec_helper'
 
 module RailsBestPractices::Core
   describe Modules do
-    it { should be_a_kind_of Array }
+    it { is_expected.to be_a_kind_of Array }
 
     context 'Modules' do
       before do
         @mod = Mod.new('PostsHelper', [])
       end
-      subject { Modules.new.tap { |modules| modules << @mod } }
-      it 'should add descendant to the corresponding module' do
+      subject { described_class.new.tap { |modules| modules << @mod } }
+      it 'adds 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
-      subject {
+      subject do
         Mod.new('UsersHelper', ['Admin']).tap do |mod|
           mod.add_descendant('Admin::UsersController')
         end
-      }
+      end
       it { expect(subject.to_s).to eq('Admin::UsersHelper') }
       it { expect(subject.descendants).to eq(['Admin::UsersController']) }
     end

data/spec/rails_best_practices/core/routes_spec.rb

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

data/spec/rails_best_practices/core/runner_spec.rb

@@ -6,20 +6,22 @@ module RailsBestPractices::Core
   describe Runner 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
-          runner = Runner.new
-          expect(runner.instance_variable_get('@reviews').map(&:class)).to include(RailsBestPractices::Plugins::Reviews::NotUseRailsRootReview)
+        it 'loads plugins in lib/rails_best_practices/plugins/reviews' do
+          runner = described_class.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
-        before { Runner.base_path = 'spec/fixtures/' }
-        it_should_behave_like 'load_plugin_reviews'
+        before { described_class.base_path = 'spec/fixtures/' }
+        it_behaves_like 'load_plugin_reviews'
       end
 
       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'
+        before { described_class.base_path = 'spec/fixtures' }
+        it_behaves_like 'load_plugin_reviews'
       end
     end
   end

data/spec/rails_best_practices/core_ext/erubis_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 describe Erubis::OnlyRuby do
-  subject {
+  subject do
     content = <<-EOF
     <h1>Title</h1>
     <% if current_user %>
@@ -13,14 +13,14 @@ describe Erubis::OnlyRuby do
       Not logged in
     <% end %>
     EOF
-    Erubis::OnlyRuby.new(content).src
-  }
+    described_class.new(content).src
+  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') }
+  it { is_expected.not_to include('h1') }
+  it { is_expected.not_to include('Title') }
+  it { is_expected.not_to include('Not logged in') }
+  it { is_expected.to include('current_user') }
+  it { is_expected.to include('if') }
+  it { is_expected.to include('else') }
+  it { is_expected.to include('end') }
 end

data/spec/rails_best_practices/lexicals/long_line_check_spec.rb

@@ -5,51 +5,52 @@ require 'spec_helper'
 module RailsBestPractices
   module Lexicals
     describe LongLineCheck do
-      it 'should find long lines' do
-        runner = Core::Runner.new(lexicals: LongLineCheck.new)
-        content = <<-EOF
-class User < ActiveRecord::Base
-# 81 Chars
-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
-# 80 Chars
-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
-end
-EOF
+      it 'finds long lines' do
+        runner = Core::Runner.new(lexicals: described_class.new)
+        content = <<~EOF
+          class User < ActiveRecord::Base
+          # 81 Chars
+          xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+          # 80 Chars
+          xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+          end
+        EOF
         content = 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)')
       end
-      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
-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
-# 90 Chars
-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
-end
-EOF
+      it 'finds long lines with own max size' do
+        runner = Core::Runner.new(lexicals: described_class.new('max_line_length' => 90))
+        content = <<~EOF
+          class User < ActiveRecord::Base
+          # 91 Chars
+          xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+          # 90 Chars
+          xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+          end
+        EOF
         content = 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)')
       end
-      it 'should not check non .rb files' do
-        runner = Core::Runner.new(lexicals: LongLineCheck.new)
-        content = "
+      it 'does not check non .rb files' do
+        runner = Core::Runner.new(lexicals: described_class.new)
+        content =
+          '
 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
-"
+'
         runner.lexical('app/views/users/index.html.erb', content)
         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
+      it 'does not check ignored files' do
+        runner = Core::Runner.new(lexicals: described_class.new(max_line_length: 80, ignored_files: /user/))
+        content = <<~EOF
+          class User < ActiveRecord::Base
+          # 81 Chars
+          xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+          end
         EOF
         content = content.gsub("\n", "\t\n")
         runner.lexical('app/models/user.rb', content)

data/spec/rails_best_practices/lexicals/remove_tab_check_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 module RailsBestPractices
   module Lexicals
     describe RemoveTabCheck do
-      let(:runner) { Core::Runner.new(lexicals: RemoveTabCheck.new) }
+      let(:runner) { Core::Runner.new(lexicals: described_class.new) }
 
-      it 'should remove tab' do
+      it 'removes tab' do
         content = <<-EOF
         class User < ActiveRecord::Base
           has_many :projects
@@ -19,7 +19,7 @@ module RailsBestPractices
         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 'removes tab with third line' do
         content = <<-EOF
         class User < ActiveRecord::Base
           has_many :projects
@@ -31,7 +31,7 @@ module RailsBestPractices
         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 'does not remove trailing whitespace' do
         content = <<-EOF
         class User < ActiveRecord::Base
           has_many :projects
@@ -40,8 +40,8 @@ module RailsBestPractices
         runner.lexical('app/models/user.rb', content)
         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/))
+      it 'does not check ignored files' do
+        runner = Core::Runner.new(lexicals: described_class.new(ignored_files: /user/))
         content = <<-EOF
         class User < ActiveRecord::Base
           has_many :projects

data/spec/rails_best_practices/lexicals/remove_trailing_whitespace_check_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 module RailsBestPractices
   module Lexicals
     describe RemoveTrailingWhitespaceCheck do
-      let(:runner) { Core::Runner.new(lexicals: RemoveTrailingWhitespaceCheck.new) }
+      let(:runner) { Core::Runner.new(lexicals: described_class.new) }
 
-      it 'should remove trailing whitespace' do
+      it 'removes trailing whitespace' do
         content = <<-EOF
         class User < ActiveRecord::Base
           has_many :projects
@@ -19,7 +19,7 @@ module RailsBestPractices
         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 'removes whitespace with third line' do
         content = <<-EOF
         class User < ActiveRecord::Base
           has_many :projects
@@ -31,7 +31,7 @@ module RailsBestPractices
         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 'does not remove trailing whitespace' do
         content = <<-EOF
         class User < ActiveRecord::Base
           has_many :projects
@@ -41,8 +41,8 @@ module RailsBestPractices
         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/))
+      it 'does not check ignored files' do
+        runner = Core::Runner.new(lexicals: described_class.new(ignored_files: /user/))
         content = <<-EOF
         class User < ActiveRecord::Base
           has_many :projects

data/spec/rails_best_practices/prepares/config_prepare_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 module RailsBestPractices
   module Prepares
     describe ConfigPrepare do
-      let(:runner) { Core::Runner.new(prepares: ConfigPrepare.new) }
+      let(:runner) { Core::Runner.new(prepares: described_class.new) }
 
       context 'configs' do
-        it 'should parse configs' do
+        it 'parses configs' do
           content = <<-EOF
           module RailsBestPracticesCom
             class Application < Rails::Application

data/spec/rails_best_practices/prepares/controller_prepare_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 module RailsBestPractices
   module Prepares
     describe ControllerPrepare do
-      let(:runner) { Core::Runner.new(prepares: [ControllerPrepare.new, HelperPrepare.new]) }
+      let(:runner) { Core::Runner.new(prepares: [described_class.new, HelperPrepare.new]) }
 
       context 'methods' do
-        it 'should parse controller methods' do
+        it 'parses controller methods' do
           content = <<-EOF
           class PostsController < ApplicationController
             def index; end
@@ -20,7 +20,7 @@ module RailsBestPractices
           expect(methods.get_methods('PostsController').map(&:method_name)).to eq(%w[index show])
         end
 
-        it 'should parse model methods with access control' do
+        it 'parses model methods with access control' do
           content = <<-EOF
           class PostsController < ApplicationController
             def index; end
@@ -39,7 +39,7 @@ module RailsBestPractices
           expect(methods.get_methods('PostsController', 'private').map(&:method_name)).to eq(['resource'])
         end
 
-        it 'should parse controller methods with module ::' do
+        it 'parses controller methods with module ::' do
           content = <<-EOF
           class Admin::Blog::PostsController < ApplicationController
             def index; end
@@ -51,7 +51,7 @@ module RailsBestPractices
           expect(methods.get_methods('Admin::Blog::PostsController').map(&:method_name)).to eq(%w[index show])
         end
 
-        it 'should parse controller methods with module' do
+        it 'parses controller methods with module' do
           content = <<-EOF
           module Admin
             module Blog
@@ -75,7 +75,9 @@ module RailsBestPractices
             EOF
             runner.prepare('app/controllers/posts_controller.rb', content)
             methods = Prepares.controller_methods
-            expect(methods.get_methods('PostsController').map(&:method_name)).to eq(%w[index show new create edit update destroy])
+            expect(methods.get_methods('PostsController').map(&:method_name)).to eq(
+              %w[index show new create edit update destroy]
+            )
           end
 
           it 'extend inherited_resources with actions' do
@@ -97,7 +99,9 @@ module RailsBestPractices
             EOF
             runner.prepare('app/controllers/posts_controller.rb', content)
             methods = Prepares.controller_methods
-            expect(methods.get_methods('PostsController').map(&:method_name)).to eq(%w[index new create edit update destroy])
+            expect(methods.get_methods('PostsController').map(&:method_name)).to eq(
+              %w[index new create edit update destroy]
+            )
           end
 
           it 'extend inherited_resources with all actions with no arguments' do
@@ -108,7 +112,9 @@ module RailsBestPractices
             EOF
             runner.prepare('app/controllers/posts_controller.rb', content)
             methods = Prepares.controller_methods
-            expect(methods.get_methods('PostsController').map(&:method_name)).to eq(%w[index show new create edit update destroy])
+            expect(methods.get_methods('PostsController').map(&:method_name)).to eq(
+              %w[index show new create edit update destroy]
+            )
           end
 
           it 'DSL inherit_resources' do
@@ -119,13 +125,15 @@ module RailsBestPractices
             EOF
             runner.prepare('app/controllers/posts_controller.rb', content)
             methods = Prepares.controller_methods
-            expect(methods.get_methods('PostsController').map(&:method_name)).to eq(%w[index show new create edit update destroy])
+            expect(methods.get_methods('PostsController').map(&:method_name)).to eq(
+              %w[index show new create edit update destroy]
+            )
           end
         end
       end
 
       context 'helpers' do
-        it 'should add helper descendant' do
+        it 'adds helper descendant' do
           content = <<-EOF
           module PostsHelper
           end