rails_best_practices 1.19.0 → 1.19.1

data/spec/rails_best_practices/prepares/config_prepare_spec.rb

@@ -5,8 +5,8 @@ module RailsBestPractices
     describe ConfigPrepare do
       let(:runner) { Core::Runner.new(prepares: ConfigPrepare.new) }
 
-      context "configs" do
-        it "should parse configs" do
+      context 'configs' do
+        it 'should parse configs' do
           content =<<-EOF
           module RailsBestPracticesCom
             class Application < Rails::Application
@@ -16,7 +16,7 @@ module RailsBestPractices
           EOF
           runner.prepare('config/application.rb', content)
           configs = Prepares.configs
-          expect(configs["config.active_record.whitelist_attributes"]).to eq("true")
+          expect(configs['config.active_record.whitelist_attributes']).to eq('true')
         end
       end
     end

data/spec/rails_best_practices/prepares/controller_prepare_spec.rb

@@ -5,8 +5,8 @@ module RailsBestPractices
     describe ControllerPrepare do
       let(:runner) { Core::Runner.new(prepares: [ControllerPrepare.new, HelperPrepare.new]) }
 
-      context "methods" do
-        it "should parse controller methods" do
+      context 'methods' do
+        it 'should parse controller methods' do
           content =<<-EOF
           class PostsController < ApplicationController
             def index; end
@@ -15,10 +15,10 @@ 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(["index", "show"])
+          expect(methods.get_methods('PostsController').map(&:method_name)).to eq(['index', 'show'])
         end
 
-        it "should parse model methods with access control" do
+        it 'should parse model methods with access control' do
           content =<<-EOF
           class PostsController < ApplicationController
             def index; end
@@ -31,13 +31,13 @@ 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(["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"])
+          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
+        it 'should parse controller methods with module ::' do
           content =<<-EOF
           class Admin::Blog::PostsController < ApplicationController
             def index; end
@@ -46,10 +46,10 @@ module RailsBestPractices
           EOF
           runner.prepare('app/controllers/admin/posts_controller.rb', content)
           methods = Prepares.controller_methods
-          expect(methods.get_methods("Admin::Blog::PostsController").map(&:method_name)).to eq(["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
+        it 'should parse controller methods with module' do
           content =<<-EOF
           module Admin
             module Blog
@@ -62,21 +62,21 @@ module RailsBestPractices
           EOF
           runner.prepare('app/controllers/admin/posts_controller.rb', content)
           methods = Prepares.controller_methods
-          expect(methods.get_methods("Admin::Blog::PostsController").map(&:method_name)).to eq(["index", "show"])
+          expect(methods.get_methods('Admin::Blog::PostsController').map(&:method_name)).to eq(['index', 'show'])
         end
 
-        context "inherited_resources" do
-          it "extend inherited_resources" do
+        context 'inherited_resources' do
+          it 'extend inherited_resources' do
             content =<<-EOF
             class PostsController < InheritedResources::Base
             end
             EOF
             runner.prepare('app/controllers/posts_controller.rb', content)
             methods = Prepares.controller_methods
-            expect(methods.get_methods("PostsController").map(&:method_name)).to eq(["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
+          it 'extend inherited_resources with actions' do
             content =<<-EOF
             class PostsController < InheritedResources::Base
               actions :index, :show
@@ -84,10 +84,10 @@ 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(["index", "show"])
+            expect(methods.get_methods('PostsController').map(&:method_name)).to eq(['index', 'show'])
           end
 
-          it "extend inherited_resources with all actions" do
+          it 'extend inherited_resources with all actions' do
             content =<<-EOF
             class PostsController < InheritedResources::Base
               actions :all, except: [:show]
@@ -95,10 +95,10 @@ 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(["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
+          it 'extend inherited_resources with all actions with no arguments' do
             content =<<-EOF
             class PostsController < InheritedResources::Base
               actions :all
@@ -106,10 +106,10 @@ 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(["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
+          it 'DSL inherit_resources' do
             content =<<-EOF
             class PostsController
               inherit_resources
@@ -117,13 +117,13 @@ 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(["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
 
-      context "helpers" do
-        it "should add helper descendant" do
+      context 'helpers' do
+        it 'should add helper descendant' do
           content =<<-EOF
           module PostsHelper
           end
@@ -136,7 +136,7 @@ module RailsBestPractices
           EOF
           runner.prepare('app/controllers/posts_controller.rb', content)
           helpers = Prepares.helpers
-          expect(helpers.first.descendants).to eq(["PostsController"])
+          expect(helpers.first.descendants).to eq(['PostsController'])
         end
       end
     end

data/spec/rails_best_practices/prepares/gemfile_prepare_spec.rb

@@ -5,8 +5,8 @@ module RailsBestPractices
     describe GemfilePrepare do
       let(:runner) { Core::Runner.new(prepares: GemfilePrepare.new) }
 
-      context "gemfile" do
-        it "should parse gems" do
+      context 'gemfile' do
+        it 'should parse gems' do
           content =<<-EOF
 GEM
   remote: https://rubygems.org/
@@ -26,7 +26,7 @@ PLATFORMS
           EOF
           runner.prepare('Gemfile.lock', content)
           gems = Prepares.gems
-          expect(gems.map(&:to_s)).to eq(["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

@@ -5,8 +5,8 @@ module RailsBestPractices
     describe HelperPrepare do
       let(:runner) { Core::Runner.new(prepares: HelperPrepare.new) }
 
-      context "methods" do
-        it "should parse helper methods" do
+      context 'methods' do
+        it 'should parse helper methods' do
           content =<<-EOF
           module PostsHelper
             def used; end
@@ -15,10 +15,10 @@ module RailsBestPractices
           EOF
           runner.prepare('app/helpers/posts_helper.rb', content)
           methods = Prepares.helper_methods
-          expect(methods.get_methods("PostsHelper").map(&:method_name)).to eq(["used", "unused"])
+          expect(methods.get_methods('PostsHelper').map(&:method_name)).to eq(['used', 'unused'])
         end
 
-        it "should parse helpers" do
+        it 'should parse helpers' do
           content =<<-EOF
           module PostsHelper
           end
@@ -35,9 +35,9 @@ module RailsBestPractices
             end
           end
           EOF
-          runner.prepare("app/helpers/base_helper.rb", content)
+          runner.prepare('app/helpers/base_helper.rb', content)
           helpers = Prepares.helpers
-          expect(helpers.map(&:to_s)).to eq(["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

@@ -5,8 +5,8 @@ module RailsBestPractices
     describe InitializerPrepare do
       let(:runner) { Core::Runner.new(prepares: InitializerPrepare.new) }
 
-      context "initializers" do
-        it "should set include_forbidden_attributes_protection config" do
+      context 'initializers' do
+        it 'should set include_forbidden_attributes_protection config' do
           content =<<-EOF
           class AR
             ActiveRecord::Base.send(:include, ActiveModel::ForbiddenAttributesProtection)
@@ -14,17 +14,17 @@ module RailsBestPractices
           EOF
           runner.prepare('config/initializers/ar.rb', content)
           configs = Prepares.configs
-          expect(configs["railsbp.include_forbidden_attributes_protection"]).to eq("true")
+          expect(configs['railsbp.include_forbidden_attributes_protection']).to eq('true')
         end
 
-        it "should not set include_forbidden_attributes_protection config" do
+        it 'should not set include_forbidden_attributes_protection config' do
           content =<<-EOF
           class AR
           end
           EOF
           runner.prepare('config/initializers/ar.rb', content)
           configs = Prepares.configs
-          expect(configs["railsbp.include_forbidden_attributes_protection"]).to 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

@@ -5,13 +5,13 @@ module RailsBestPractices
     describe MailerPrepare do
       let(:runner) { Core::Runner.new(prepares: MailerPrepare.new) }
 
-      it "should parse mailer names" do
+      it 'should parse mailer names' do
         content =<<-EOF
         class ProjectMailer < ActionMailer::Base
         end
         EOF
         runner.prepare('app/mailers/project_mailer.rb', content)
-        expect(Prepares.mailers.map(&:to_s)).to eq(["ProjectMailer"])
+        expect(Prepares.mailers.map(&:to_s)).to eq(['ProjectMailer'])
       end
     end
   end

data/spec/rails_best_practices/prepares/model_prepare_spec.rb

@@ -5,32 +5,32 @@ module RailsBestPractices
     describe ModelPrepare do
       let(:runner) { Core::Runner.new(prepares: ModelPrepare.new) }
 
-      context "models" do
-        it "class_name with modules ::" do
+      context 'models' do
+        it 'class_name with modules ::' do
           content =<<-EOF
           class Blog::Post < ActiveRecord::Base
           end
           EOF
-          runner.prepare("app/models/admin/post.rb", content)
+          runner.prepare('app/models/admin/post.rb', content)
           models = Prepares.models
-          expect(models.map(&:to_s)).to eq(["Blog::Post"])
+          expect(models.map(&:to_s)).to eq(['Blog::Post'])
         end
 
-        it "class_name with modules" do
+        it 'class_name with modules' do
           content =<<-EOF
           module Blog
             class Post < ActiveRecord::Base
             end
           end
           EOF
-          runner.prepare("app/models/admin/post.rb", content)
+          runner.prepare('app/models/admin/post.rb', content)
           models = Prepares.models
-          expect(models.map(&:to_s)).to eq(["Blog::Post"])
+          expect(models.map(&:to_s)).to eq(['Blog::Post'])
         end
       end
 
-      context "associations" do
-        it "should parse model associations" do
+      context 'associations' do
+        it 'should parse model associations' do
           content =<<-EOF
           class Project < ActiveRecord::Base
             belongs_to              :portfolio
@@ -41,177 +41,177 @@ module RailsBestPractices
           EOF
           runner.prepare('app/models/project.rb', content)
           model_associations = Prepares.model_associations
-          expect(model_associations.get_association("Project", "portfolio")).to eq({"meta" => "belongs_to", "class_name" => "Portfolio"})
-          expect(model_associations.get_association("Project", "project_manager")).to eq({"meta" => "has_one", "class_name" => "ProjectManager"})
-          expect(model_associations.get_association("Project", "milestones")).to eq({"meta" => "has_many", "class_name" => "Milestone"})
-          expect(model_associations.get_association("Project", "categories")).to eq({"meta" => "has_and_belongs_to_many", "class_name" => "Category"})
+          expect(model_associations.get_association('Project', 'portfolio')).to eq({'meta' => 'belongs_to', 'class_name' => 'Portfolio'})
+          expect(model_associations.get_association('Project', 'project_manager')).to eq({'meta' => 'has_one', 'class_name' => 'ProjectManager'})
+          expect(model_associations.get_association('Project', 'milestones')).to eq({'meta' => 'has_many', 'class_name' => 'Milestone'})
+          expect(model_associations.get_association('Project', 'categories')).to eq({'meta' => 'has_and_belongs_to_many', 'class_name' => 'Category'})
         end
 
-        context "with class_name option" do
-          it "should parse belongs_to" do
+        context 'with class_name option' do
+          it 'should parse belongs_to' do
             content =<<-EOF
             class Post < ActiveRecord::Base
               belongs_to :author, "class_name" => "Person"
             end
             EOF
-            runner.prepare("app/models/post.rb", content)
+            runner.prepare('app/models/post.rb', content)
             model_associations = Prepares.model_associations
-            expect(model_associations.get_association("Post", "author")).to eq({"meta" => "belongs_to", "class_name" => "Person"})
+            expect(model_associations.get_association('Post', 'author')).to eq({'meta' => 'belongs_to', 'class_name' => 'Person'})
           end
 
-          it "should parse has_one" do
+          it 'should parse has_one' do
             content =<<-EOF
             class Project < ActiveRecord::Base
               has_one :project_manager, "class_name" => "Person"
             end
             EOF
-            runner.prepare("app/models/post.rb", content)
+            runner.prepare('app/models/post.rb', content)
             model_associations = Prepares.model_associations
-            expect(model_associations.get_association("Project", "project_manager")).to eq({"meta" => "has_one", "class_name" => "Person"})
+            expect(model_associations.get_association('Project', 'project_manager')).to eq({'meta' => 'has_one', 'class_name' => 'Person'})
           end
 
-          it "should parse has_many" do
+          it 'should parse has_many' do
             content =<<-EOF
             class Project < ActiveRecord::Base
               has_many :people, "class_name" => "Person"
             end
             EOF
-            runner.prepare("app/models/project.rb", content)
+            runner.prepare('app/models/project.rb', content)
             model_associations = Prepares.model_associations
-            expect(model_associations.get_association("Project", "people")).to eq({"meta" => "has_many", "class_name" => "Person"})
+            expect(model_associations.get_association('Project', 'people')).to eq({'meta' => 'has_many', 'class_name' => 'Person'})
           end
 
-          it "should parse has_and_belongs_to_many" do
+          it 'should parse has_and_belongs_to_many' do
             content =<<-EOF
             class Citizen < ActiveRecord::Base
               has_and_belongs_to_many :nations, "class_name" => "Country"
             end
             EOF
-            runner.prepare("app/models/citizen.rb", content)
+            runner.prepare('app/models/citizen.rb', content)
             model_associations = Prepares.model_associations
-            expect(model_associations.get_association("Citizen", "nations")).to eq({"meta" => "has_and_belongs_to_many", "class_name" => "Country"})
+            expect(model_associations.get_association('Citizen', 'nations')).to eq({'meta' => 'has_and_belongs_to_many', 'class_name' => 'Country'})
           end
 
-          context "namespace" do
-            it "should parse with namespace" do
+          context 'namespace' do
+            it 'should parse with namespace' do
               content =<<-EOF
               class Community < ActiveRecord::Base
                 has_many :members
               end
               EOF
-              runner.prepare("app/models/community.rb", content)
+              runner.prepare('app/models/community.rb', content)
               content =<<-EOF
               class Community::Member < ActiveRecord::Base
                 belongs_to :community
               end
               EOF
-              runner.prepare("app/models/community/member.rb", content)
+              runner.prepare('app/models/community/member.rb', content)
               runner.after_prepare
               model_associations = Prepares.model_associations
-              expect(model_associations.get_association("Community", "members")).to eq({"meta" => "has_many", "class_name" => "Community::Member"})
-              expect(model_associations.get_association("Community::Member", "community")).to eq({"meta" => "belongs_to", "class_name" => "Community"})
+              expect(model_associations.get_association('Community', 'members')).to eq({'meta' => 'has_many', 'class_name' => 'Community::Member'})
+              expect(model_associations.get_association('Community::Member', 'community')).to eq({'meta' => 'belongs_to', 'class_name' => 'Community'})
             end
 
-            it "should parse without namespace" do
+            it 'should parse without namespace' do
               content =<<-EOF
               class Community::Member::Rating < ActiveRecord::Base
                 belongs_to :member
               end
               EOF
-              runner.prepare("app/models/community/member/rating.rb", content)
+              runner.prepare('app/models/community/member/rating.rb', content)
               content =<<-EOF
               class Community::Member < ActiveRecord::Base
                 has_many :ratings
               end
               EOF
-              runner.prepare("app/models/community/member.rb", content)
+              runner.prepare('app/models/community/member.rb', content)
               runner.after_prepare
               model_associations = Prepares.model_associations
-              expect(model_associations.get_association("Community::Member::Rating", "member")).to eq({"meta" => "belongs_to", "class_name" => "Community::Member"})
-              expect(model_associations.get_association("Community::Member", "ratings")).to eq({"meta" => "has_many", "class_name" => "Community::Member::Rating"})
+              expect(model_associations.get_association('Community::Member::Rating', 'member')).to eq({'meta' => 'belongs_to', 'class_name' => 'Community::Member'})
+              expect(model_associations.get_association('Community::Member', 'ratings')).to eq({'meta' => 'has_many', 'class_name' => 'Community::Member::Rating'})
             end
           end
         end
 
-        context "mongoid embeds" do
-          it "should parse embeds_many" do
+        context 'mongoid embeds' do
+          it 'should parse embeds_many' do
             content =<<-EOF
             class Person
               include Mongoid::Document
               embeds_many :addresses
             end
             EOF
-            runner.prepare("app/models/person.rb", content)
+            runner.prepare('app/models/person.rb', content)
             model_associations = Prepares.model_associations
-            expect(model_associations.get_association("Person", "addresses")).to eq({"meta" => "embeds_many", "class_name" => "Address"})
+            expect(model_associations.get_association('Person', 'addresses')).to eq({'meta' => 'embeds_many', 'class_name' => 'Address'})
           end
 
-          it "should parse embeds_one" do
+          it 'should parse embeds_one' do
             content =<<-EOF
             class Lush
               include Mongoid::Document
               embeds_one :whiskey, class_name: "Drink", inverse_of: :alcoholic
             end
             EOF
-            runner.prepare("app/models/lush.rb", content)
+            runner.prepare('app/models/lush.rb', content)
             model_associations = Prepares.model_associations
-            expect(model_associations.get_association("Lush", "whiskey")).to eq({"meta" => "embeds_one", "class_name" => "Drink"})
+            expect(model_associations.get_association('Lush', 'whiskey')).to eq({'meta' => 'embeds_one', 'class_name' => 'Drink'})
           end
 
-          it "should parse embedded_in" do
+          it 'should parse embedded_in' do
             content =<<-EOF
             class Drink
               include Mongoid::Document
               embedded_in :alcoholic, class_name: "Lush", inverse_of: :whiskey
             end
             EOF
-            runner.prepare("app/models/drink.rb", content)
+            runner.prepare('app/models/drink.rb', content)
             model_associations = Prepares.model_associations
-            expect(model_associations.get_association("Drink", "alcoholic")).to eq({"meta" => "embedded_in", "class_name" => "Lush"})
+            expect(model_associations.get_association('Drink', 'alcoholic')).to eq({'meta' => 'embedded_in', 'class_name' => 'Lush'})
           end
         end
 
-        context "mongomapper many/one" do
-          it "should parse one" do
+        context 'mongomapper many/one' do
+          it 'should parse one' do
             content =<<-EOF
             class Employee
               include MongoMapper::Document
               one :desk
             end
             EOF
-            runner.prepare("app/models/employee.rb", content)
+            runner.prepare('app/models/employee.rb', content)
             model_associations = Prepares.model_associations
-            expect(model_associations.get_association("Employee", "desk")).to eq({"meta" => "one", "class_name" => "Desk"})
+            expect(model_associations.get_association('Employee', 'desk')).to eq({'meta' => 'one', 'class_name' => 'Desk'})
           end
 
-          it "should parse many" do
+          it 'should parse many' do
             content =<<-EOF
             class Tree
               include MongoMapper::Document
               many :birds
             end
             EOF
-            runner.prepare("app/models/tree.rb", content)
+            runner.prepare('app/models/tree.rb', content)
             model_associations = Prepares.model_associations
-            expect(model_associations.get_association("Tree", "birds")).to eq({"meta" => "many", "class_name" => "Bird"})
+            expect(model_associations.get_association('Tree', 'birds')).to eq({'meta' => 'many', 'class_name' => 'Bird'})
           end
         end
       end
 
-      context "methods" do
-        it "should parse model methods" do
+      context 'methods' do
+        it 'should parse model methods' do
           content =<<-EOF
           class Post < ActiveRecord::Base
             def save; end
             def find; end
           end
           EOF
-          runner.prepare("app/models/post.rb", content)
+          runner.prepare('app/models/post.rb', content)
           methods = Prepares.model_methods
-          expect(methods.get_methods("Post").map(&:method_name)).to eq(["save", "find"])
+          expect(methods.get_methods('Post').map(&:method_name)).to eq(['save', 'find'])
         end
 
-        it "should parse model methods with access control" do
+        it 'should parse model methods with access control' do
           content =<<-EOF
           class Post < ActiveRecord::Base
             def save; end
@@ -222,27 +222,27 @@ module RailsBestPractices
             def find_by_sql; end
           end
           EOF
-          runner.prepare("app/models/post.rb", content)
+          runner.prepare('app/models/post.rb', content)
           methods = Prepares.model_methods
-          expect(methods.get_methods("Post").map(&:method_name)).to eq(["save", "find", "create_or_update", "find_by_sql"])
-          expect(methods.get_methods("Post", "public").map(&:method_name)).to eq(["save", "find"])
-          expect(methods.get_methods("Post", "protected").map(&:method_name)).to eq(["create_or_update"])
-          expect(methods.get_methods("Post", "private").map(&:method_name)).to eq(["find_by_sql"])
+          expect(methods.get_methods('Post').map(&:method_name)).to eq(['save', 'find', 'create_or_update', 'find_by_sql'])
+          expect(methods.get_methods('Post', 'public').map(&:method_name)).to eq(['save', 'find'])
+          expect(methods.get_methods('Post', 'protected').map(&:method_name)).to eq(['create_or_update'])
+          expect(methods.get_methods('Post', 'private').map(&:method_name)).to eq(['find_by_sql'])
         end
 
-        it "should parse model methods with module ::" do
+        it 'should parse model methods with module ::' do
           content =<<-EOF
           class Admin::Blog::Post < ActiveRecord::Base
             def save; end
             def find; end
           end
           EOF
-          runner.prepare("app/models/admin/blog/post.rb", content)
+          runner.prepare('app/models/admin/blog/post.rb', content)
           methods = Prepares.model_methods
-          expect(methods.get_methods("Admin::Blog::Post").map(&:method_name)).to eq(["save", "find"])
+          expect(methods.get_methods('Admin::Blog::Post').map(&:method_name)).to eq(['save', 'find'])
         end
 
-        it "should parse model methods with module" do
+        it 'should parse model methods with module' do
           content =<<-EOF
           module Admin
             module Blog
@@ -253,90 +253,90 @@ module RailsBestPractices
             end
           end
           EOF
-          runner.prepare("app/models/admin/blog/post.rb", content)
+          runner.prepare('app/models/admin/blog/post.rb', content)
           methods = Prepares.model_methods
-          expect(methods.get_methods("Admin::Blog::Post").map(&:method_name)).to eq(["save", "find"])
+          expect(methods.get_methods('Admin::Blog::Post').map(&:method_name)).to eq(['save', 'find'])
         end
 
-        it "should not add methods from module" do
+        it 'should not add methods from module' do
           content =<<-EOF
             class Model < ActiveRecord::Base
             end
           EOF
-          runner.prepare("app/models/model.rb", content)
+          runner.prepare('app/models/model.rb', content)
           content =<<-EOF
             module Mixin
               def mixed_method
               end
             end
           EOF
-          runner.prepare("app/models/mixins/mixin.rb", content)
+          runner.prepare('app/models/mixins/mixin.rb', content)
           methods = Prepares.model_methods
           expect(methods.get_methods('Model')).to be_empty
         end
       end
 
-      context "scope" do
-        it "should treat named_scope as method" do
+      context 'scope' do
+        it 'should treat named_scope as method' do
           content =<<-EOF
           class Post < ActiveRecord::Base
             named_scope :active, conditions: {active: true}
           end
           EOF
-          runner.prepare("app/models/post.rb", content)
+          runner.prepare('app/models/post.rb', content)
           methods = Prepares.model_methods
-          expect(methods.get_methods("Post").map(&:method_name)).to eq(["active"])
+          expect(methods.get_methods('Post').map(&:method_name)).to eq(['active'])
         end
 
-        it "should treat scope as method" do
+        it 'should treat scope as method' do
           content =<<-EOF
           class Post < ActiveRecord::Base
             scope :active, where(active: true)
           end
           EOF
-          runner.prepare("app/models/post.rb", content)
+          runner.prepare('app/models/post.rb', content)
           methods = Prepares.model_methods
-          expect(methods.get_methods("Post").map(&:method_name)).to eq(["active"])
+          expect(methods.get_methods('Post').map(&:method_name)).to eq(['active'])
         end
       end
 
-      context "alias" do
-        it "should treat alias as method" do
+      context 'alias' do
+        it 'should treat alias as method' do
           content =<<-EOF
           class Post < ActiveRecord::Base
             alias :new :old
           end
           EOF
-          runner.prepare("app/models/post.rb", content)
+          runner.prepare('app/models/post.rb', content)
           methods = Prepares.model_methods
-          expect(methods.get_methods("Post").map(&:method_name)).to eq(["new"])
+          expect(methods.get_methods('Post').map(&:method_name)).to eq(['new'])
         end
 
-        it "should treat alias_method as method" do
+        it 'should treat alias_method as method' do
           content =<<-EOF
           class Post < ActiveRecord::Base
             alias_method :new, :old
           end
           EOF
-          runner.prepare("app/models/post.rb", content)
+          runner.prepare('app/models/post.rb', content)
           methods = Prepares.model_methods
-          expect(methods.get_methods("Post").map(&:method_name)).to eq(["new"])
+          expect(methods.get_methods('Post').map(&:method_name)).to eq(['new'])
         end
 
-        it "should treat alias_method_chain as method" do
+        it 'should treat alias_method_chain as method' do
           content =<<-EOF
           class Post < ActiveRecord::Base
             alias_method_chain :method, :feature
           end
           EOF
-          runner.prepare("app/models/post.rb", content)
+          runner.prepare('app/models/post.rb', content)
           methods = Prepares.model_methods
-          expect(methods.get_methods("Post").map(&:method_name)).to eq(["method_with_feature", "method"])
+          expect(methods.get_methods('Post').map(&:method_name)).to eq(['method_with_feature', 'method'])
         end
       end
 
-      context "attributes" do
-        it "should parse mongoid field" do
+      context 'attributes' do
+        it 'should parse mongoid field' do
           content =<<-EOF
           class Post
             include Mongoid::Document
@@ -347,16 +347,16 @@ module RailsBestPractices
             field :active, type: Boolean
           end
           EOF
-          runner.prepare("app/models/post.rb", content)
+          runner.prepare('app/models/post.rb', content)
           model_attributes = Prepares.model_attributes
-          expect(model_attributes.get_attribute_type("Post", "title")).to eq("String")
-          expect(model_attributes.get_attribute_type("Post", "tags")).to eq("Array")
-          expect(model_attributes.get_attribute_type("Post", "comments_count")).to eq("Integer")
-          expect(model_attributes.get_attribute_type("Post", "deleted_at")).to eq("DateTime")
-          expect(model_attributes.get_attribute_type("Post", "active")).to eq("Boolean")
+          expect(model_attributes.get_attribute_type('Post', 'title')).to eq('String')
+          expect(model_attributes.get_attribute_type('Post', 'tags')).to eq('Array')
+          expect(model_attributes.get_attribute_type('Post', 'comments_count')).to eq('Integer')
+          expect(model_attributes.get_attribute_type('Post', 'deleted_at')).to eq('DateTime')
+          expect(model_attributes.get_attribute_type('Post', 'active')).to eq('Boolean')
         end
 
-        it "should parse mongomapper field" do
+        it 'should parse mongomapper field' do
           content =<<-EOF
           class Post
             include MongoMapper::Document
@@ -368,19 +368,19 @@ module RailsBestPractices
             key :fav_colors,  Array
           end
           EOF
-          runner.prepare("app/models/post.rb", content)
+          runner.prepare('app/models/post.rb', content)
           model_attributes = Prepares.model_attributes
-          expect(model_attributes.get_attribute_type("Post", "first_name")).to eq("String")
-          expect(model_attributes.get_attribute_type("Post", "last_name")).to eq("String")
-          expect(model_attributes.get_attribute_type("Post", "age")).to eq("Integer")
-          expect(model_attributes.get_attribute_type("Post", "born_at")).to eq("Time")
-          expect(model_attributes.get_attribute_type("Post", "active")).to eq("Boolean")
-          expect(model_attributes.get_attribute_type("Post", "fav_colors")).to eq("Array")
+          expect(model_attributes.get_attribute_type('Post', 'first_name')).to eq('String')
+          expect(model_attributes.get_attribute_type('Post', 'last_name')).to eq('String')
+          expect(model_attributes.get_attribute_type('Post', 'age')).to eq('Integer')
+          expect(model_attributes.get_attribute_type('Post', 'born_at')).to eq('Time')
+          expect(model_attributes.get_attribute_type('Post', 'active')).to eq('Boolean')
+          expect(model_attributes.get_attribute_type('Post', 'fav_colors')).to eq('Array')
         end
       end
 
-      context "no error" do
-        it "should raised for finder_sql option" do
+      context 'no error' do
+        it 'should raised for finder_sql option' do
           content =<<-EOF
           class EventSubscription < ActiveRecord::Base
             has_many :event_notification_template, finder_sql: ?