ducalis 0.5.10 → 0.5.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: '04397f76396f26b3580241dec8c514e605122819'
-  data.tar.gz: dca5ae9744fdc0d42f5e590d87898802668f1f25
+  metadata.gz: 0e9545be92ee4417db0ef82c0becd1ccb5c7a8cd
+  data.tar.gz: a11c6683e3364627615fcaec02444e21100aadb8
 SHA512:
-  metadata.gz: '0982cd88ca55631580c818f5447ae185eb4b43977ae8b1ad395782c944e412548c814406176b6816b35f0260a214b3b50932c2c85b166e3ed4bad583aed30097'
-  data.tar.gz: 9cea3e6216bc80ef22458c066548dcfb42531c73d95fadab116bcd8395c25be746c13e04565983451a08c491634b69533913b70c832e7154464ee1134a8dbe55
+  metadata.gz: 21529fb2e38466c9c011bf2310811db2bc35b197d178e8c87ab2067a67a35ef2987a1920dcc6f54bc41945c774c84d90fdbf4ca1561defc1d3f55dc1fe089356
+  data.tar.gz: 6d8d1be1aeda6b342d594f87bb9a68037712aea33b13802b7637d8c5055c608a9686e5d44647e41f3595ece8f9d6e2a2387307b21f9975c175657cd2bd7dbf84

data/DOCUMENTATION.md

@@ -1,11 +1,9 @@
 ## Ducalis::BlackListSuffix
 
-Please, avoid using of class suffixes like `Meneger`, `Client`
- and so on. If it has no parts, change the name of the class to what
- each object is managing. It's ok to use Manager as subclass of Person,
- which is there to refine a type of personal that has management
- behavior to it.
- Related [article](<http://www.carlopescio.com/2011/04/your-coding-conventions-are-hurting-you.html>)
+Please, avoid using of class suffixes like `Meneger`, `Client` and so on. If it has no parts, change the name of the class to what each object is managing.
+
+It's ok to use Manager as subclass of Person, which is there to refine a type of personal that has management behavior to it.
+Related [article](<http://www.carlopescio.com/2011/04/your-coding-conventions-are-hurting-you.html>)
 
 ![](https://placehold.it/10/f03c15/000000?text=+) raises on classes with suffixes from black list
 ```ruby
@@ -32,10 +30,8 @@ end
 ```
 ## Ducalis::CallbacksActiverecord
 
-Please, avoid using of callbacks for models. It's better to
- keep models small ("dumb") and instead use "builder" classes
- / services: to construct new objects. You can read more
- [here](https://medium.com/planet-arkency/a61fd75ab2d3).
+Please, avoid using of callbacks for models. It's better to keep models small ("dumb") and instead use "builder" classes/services: to construct new objects.
+You can read more [here](https://medium.com/planet-arkency/a61fd75ab2d3).
 
 ![](https://placehold.it/10/f03c15/000000?text=+) raises on ActiveRecord classes which contains callbacks
 ```ruby
@@ -56,20 +52,14 @@ end
 ```
 ## Ducalis::CaseMapping
 
-Try to avoid `case when` statements. You can replace it with a sequence
- of `if... elsif... elsif... else`. For cases where you need to choose
- from a large number of possibilities, you can create a dictionary
- mapping case values to functions to call by `call`. It's nice to have
- prefix for the method names, i.e.: `visit_`.
+Try to avoid `case when` statements. You can replace it with a sequence of `if... elsif... elsif... else`.
+For cases where you need to choose from a large number of possibilities, you can create a dictionary mapping case values to functions to call by `call`. It's nice to have prefix for the method names, i.e.: `visit_`.
 Usually `case when` statements are using for the next reasons:
 
 I. Mapping between different values.
 ("A" => 1, "B" => 2, ...)
 
-This case is all about data representing. If you do not need to execute any code
-it's better to use data structure which represents it. This way you are
-separating concepts: code returns corresponding value and you have config-like
-data structure which describes your data.
+This case is all about data representing. If you do not need to execute any code it's better to use data structure which represents it. This way you are separating concepts: code returns corresponding value and you have config-like data structure which describes your data.
 
 ```ruby
   %w[A B ...].index("A") + 1
@@ -82,19 +72,16 @@ II. Code execution depending of parameter or type:
   - a. (:attack => attack, :defend => defend)
   - b. (Feet => value * 0.348, Meters => `value`)
 
-In this case code violates OOP and S[O]LID principle. Code shouldn't know about
-object type and classes should be open for extension, but closed for
-modification (but you can't do it with case-statements).
-This is a signal that you have some problems with architecture.
+In this case code violates OOP and S[O]LID principle. Code shouldn't know about object type and classes should be open for extension, but closed for modification (but you can't do it with case-statements). This is a signal that you have some problems with architecture.
 
-  a.
+ a.
 ```ruby
 attack: -> { execute_attack }, defend: -> { execute_defend }
 # or
 call(:"execute_#{action}")
 ```
 
-  b.
+b.
 ```ruby
 class Meters; def to_metters; value;         end
 class Feet;   def to_metters; value * 0.348; end
@@ -103,17 +90,16 @@ class Feet;   def to_metters; value * 0.348; end
 III. Code execution depending on some statement.
 (`a > 0` => 1, `a == 0` => 0, `a < 0` => -1)
 
-This case is combination of I and II -- high code complexity and unit-tests
-complexity. There are variants how to solve it:
+This case is combination of I and II -- high code complexity and unit-tests complexity. There are variants how to solve it:
 
-  a. Rewrite to simple if statement
+ a. Rewrite to simple if statement
 
 ```ruby
 return 0 if a == 0
 a > 0 ? 1 : -1
 ```
 
-  b. Move statements to lambdas:
+ b. Move statements to lambdas:
 
 ```ruby
  ->(a) { a > 0 }  =>  1,
@@ -121,17 +107,9 @@ a > 0 ? 1 : -1
  ->(a) { a < 0 }  => -1
 ```
 
-This way decreases code complexity by delegating it to lambdas and makes it easy
- to unit-testing because it's easy to test pure lambdas.
+This way decreases code complexity by delegating it to lambdas and makes it easy to unit-testing because it's easy to test pure lambdas.
 
-Such approach is named
-[table-driven design](<https://www.d.umn.edu/~gshute/softeng/table-driven.html>)
-. Table-driven methods are schemes that allow you to look up information in a
-table rather than using logic statements (i.e. case, if). In simple cases,
-it's quicker and easier to use logic statements, but as the logic chain becomes
-more complex, table-driven code is simpler than complicated logic, easier to
-modify and more efficient.
-</details>
+Such approach is named [table-driven design](<https://www.d.umn.edu/~gshute/softeng/table-driven.html>). Table-driven methods are schemes that allow you to look up information in a table rather than using logic statements (i.e. case, if). In simple cases, it's quicker and easier to use logic statements, but as the logic chain becomes more complex, table-driven code is simpler than complicated logic, easier to modify and more efficient.
 
 ![](https://placehold.it/10/f03c15/000000?text=+) raises on case statements
 ```ruby
@@ -150,8 +128,7 @@ end
 ```
 ## Ducalis::ControllersExcept
 
-Prefer to use `:only` over `:except` in controllers because it's more
- explicit and will be easier to maintain for new developers.
+Prefer to use `:only` over `:except` in controllers because it's more explicit and will be easier to maintain for new developers.
 
 ![](https://placehold.it/10/f03c15/000000?text=+) raises for `before_filters` with `except` method as array
 ```ruby
@@ -202,8 +179,7 @@ end
 ```
 ## Ducalis::KeywordDefaults
 
-Prefer to use keyword arguments for defaults. It increases readability
- and reduces ambiguities.
+Prefer to use keyword arguments for defaults. It increases readability and reduces ambiguities.
 
 ![](https://placehold.it/10/f03c15/000000?text=+) raises if method definition contains default values
 ```ruby
@@ -231,8 +207,7 @@ def self.calculate_amount; end
 ```
 ## Ducalis::ModuleLikeClass
 
-Seems like it will be better to define initialize and pass %<args>s
- there instead of each method.
+Seems like it will be better to define initialize and pass %<args>s there instead of each method.
 
 ![](https://placehold.it/10/f03c15/000000?text=+) raises if class doesn't contain constructor but accept the same args
 ```ruby
@@ -319,11 +294,62 @@ class TaskJournal
   end
 end
 
+```
+## Ducalis::OptionsArgument
+
+Default options argument isn't good idea. It's better to explicitly pass which keys are you interested in as keyword arguments. You can use split operator to support hash arguments.
+
+Compare:
+
+```ruby
+def generate_1(document, options = {})
+  format = options.delete(:format)
+  limit = options.delete(:limit) || 20
+  # ...
+  [format, limit, options]
+end
+generate_1(1, format: 'csv', limit: 5, useless_arg: :value)
+
+# vs
+
+def generate_2(document, format:, limit: 20, **options)
+  # ...
+  [format, limit, options]
+end
+generate_2(1, format: 'csv', limit: 5, useless_arg: :value)
+```
+
+![](https://placehold.it/10/f03c15/000000?text=+) raises if method accepts default options argument
+```ruby
+
+def generate(document, options = {})
+  format = options.delete(:format)
+  limit = options.delete(:limit) || 20
+  [format, limit, options]
+end
+
+```
+
+![](https://placehold.it/10/f03c15/000000?text=+) raises if method accepts options argument
+```ruby
+
+def log(record, options)
+  # ...
+end
+
+```
+
+![](https://placehold.it/10/2cbe4e/000000?text=+) ignores passing options with split operator
+```ruby
+
+def generate(document, format:, limit: 20, **options)
+  [format, limit, options]
+end
+
 ```
 ## Ducalis::ParamsPassing
 
-It's better to pass already preprocessed params hash to services. Or
- you can use `arcane` gem.
+It's better to pass already preprocessed params hash to services. Or you can use `arcane` gem.
 
 ![](https://placehold.it/10/f03c15/000000?text=+) raises if user pass `params` as argument from controller
 ```ruby
@@ -392,12 +418,9 @@ end
 ```
 ## Ducalis::PossibleTap
 
-Consider of using `.tap`, default ruby
- [method](<https://apidock.com/ruby/Object/tap>)
- which allows to replace intermediate variables with block, by this you
- are limiting scope pollution and make method scope more clear. If it isn't
- possible, consider of moving it to method or even inline it.
- [Related article](<http://seejohncode.com/2012/01/02/ruby-tap-that/>).
+Consider of using `.tap`, default ruby [method](<https://apidock.com/ruby/Object/tap>) which allows to replace intermediate variables with block, by this you are limiting scope pollution and make method scope more clear.
+If it isn't possible, consider of moving it to method or even inline it.
+[Related article](<http://seejohncode.com/2012/01/02/ruby-tap-that/>).
 
 ![](https://placehold.it/10/f03c15/000000?text=+) raises for methods with scope variable return
 ```ruby
@@ -493,16 +516,35 @@ end
 ```
 ## Ducalis::PreferableMethods
 
-Prefer to use %<alternative>s method instead of %<original>s because of
- %<reason>s.
+Prefer to use %<alternative>s method instead of %<original>s because of %<reason>s.
 Dangerous methods are:
-`delete_all`, `delete`.
+`toggle!`, `save`, `delete`, `delete_all`, `update_attribute`, `update_column`, `update_columns`.
 
 ![](https://placehold.it/10/f03c15/000000?text=+) raises for `delete` method calling
 ```ruby
 User.where(id: 7).delete
 ```
 
+![](https://placehold.it/10/f03c15/000000?text=+) raises `save` method calling with validate: false
+```ruby
+User.where(id: 7).save(validate: false)
+```
+
+![](https://placehold.it/10/f03c15/000000?text=+) raises `toggle!` method calling
+```ruby
+User.where(id: 7).toggle!
+```
+
+![](https://placehold.it/10/2cbe4e/000000?text=+) ignores `save` method calling without validate: false
+```ruby
+User.where(id: 7).save
+```
+
+![](https://placehold.it/10/2cbe4e/000000?text=+) ignores `save` method calling without validate: false
+```ruby
+User.where(id: 7).save(some_arg: true)
+```
+
 ![](https://placehold.it/10/2cbe4e/000000?text=+) ignores calling `delete` with symbol
 ```ruby
 params.delete(:code)
@@ -524,12 +566,7 @@ tempfile.delete
 ```
 ## Ducalis::PrivateInstanceAssign
 
-Don't use controller's filter methods for setting instance variables, use
- them only for changing application flow, such as redirecting if a user
- is not authenticated. Controller instance variables are forming contract
- between controller and view. Keeping instance variables defined in one
- place makes it easier to: reason, refactor and remove old views, test
- controllers and views, extract actions to new controllers, etc.
+Don't use controller's filter methods for setting instance variables, use them only for changing application flow, such as redirecting if a user is not authenticated. Controller instance variables are forming contract between controller and view. Keeping instance variables defined in one place makes it easier to: reason, refactor and remove old views, test controllers and views, extract actions to new controllers, etc.
 If you want to memoize variable, please, add underscore to the variable name start: `@_name`.
 
 ![](https://placehold.it/10/f03c15/000000?text=+) raises for assigning instance variables in controllers private methods
@@ -589,15 +626,14 @@ end
 ```
 ## Ducalis::ProtectedScopeCop
 
-Seems like you are using `find` on non-protected scope. Potentially it
- could lead to unauthorized access. It's better to call `find` on
- authorized resources scopes. Example:
+Seems like you are using `find` on non-protected scope. Potentially it could lead to unauthorized access. It's better to call `find` on authorized resources scopes.
+Example:
 
- ```ruby
- current_group.employees.find(params[:id])
- # better then
- Employee.find(params[:id])
- ```
+```ruby
+current_group.employees.find(params[:id])
+# better then
+Employee.find(params[:id])
+```
 
 ![](https://placehold.it/10/f03c15/000000?text=+) raises if somewhere AR search was called on not protected scope
 ```ruby
@@ -629,8 +665,7 @@ end
 ```
 ## Ducalis::RaiseWithoutErrorClass
 
-It's better to add exception class as raise argument. It will make
- easier to catch and process it later.
+It's better to add exception class as raise argument. It will make easier to catch and process it later.
 
 ![](https://placehold.it/10/f03c15/000000?text=+) raises when `raise` called without exception class
 ```ruby
@@ -653,9 +688,7 @@ raise StandardError.new("Something went wrong")
 ```
 ## Ducalis::RegexCop
 
-It's better to move regex to constants with example instead of direct
- using it. It will allow you to reuse this regex and provide instructions
- for others.
+It's better to move regex to constants with example instead of direct using it. It will allow you to reuse this regex and provide instructions for others.
 
 ```ruby
 CONST_NAME = %<constant>s # "%<example>s"
@@ -699,7 +732,7 @@ puts "hi" if name =~ /.{#{name.length}}/
 ## Ducalis::RestOnlyCop
 
 It's better for controllers to stay adherent to REST:
- http://jeromedalbert.com/how-dhh-organizes-his-rails-controllers/.
+http://jeromedalbert.com/how-dhh-organizes-his-rails-controllers/.
 [About RESTful architecture](<https://confreaks.tv/videos/railsconf2017-in-relentless-pursuit-of-rest>)
 
 ![](https://placehold.it/10/f03c15/000000?text=+) raises for controllers with non-REST methods
@@ -751,8 +784,7 @@ end
 ```
 ## Ducalis::RubocopDisable
 
-Please, do not suppress RuboCop metrics, may be you can introduce some
- refactoring or another concept.
+Please, do not suppress RuboCop metrics, may be you can introduce some refactoring or another concept.
 
 ![](https://placehold.it/10/f03c15/000000?text=+) raises on RuboCop disable comments
 ```ruby
@@ -768,12 +800,32 @@ def calculate(five, args, at, one, list); end
 # some meaningful comment
 def calculate(five, args, at, one, list); end
 
+```
+## Ducalis::StandardMethods
+
+Please, be sure that you really want to redefine standard ruby methods.
+You should know what are you doing and all consequences.
+
+![](https://placehold.it/10/f03c15/000000?text=+) raises if use redefines default ruby methods
+```ruby
+
+def to_s
+  "my version"
+end
+
+```
+
+![](https://placehold.it/10/2cbe4e/000000?text=+) ignores if use defines simple ruby methods
+```ruby
+
+def present
+  "my version"
+end
+
 ```
 ## Ducalis::StringsInActiverecords
 
-Please, do not use strings as arguments for %<method_name>s argument.
- It's hard to test, grep sources, code highlighting and so on.
- Consider using of symbols or lambdas for complex expressions.
+Please, do not use strings as arguments for %<method_name>s argument. It's hard to test, grep sources, code highlighting and so on. Consider using of symbols or lambdas for complex expressions.
 
 ![](https://placehold.it/10/f03c15/000000?text=+) raises for string if argument
 ```ruby
@@ -789,11 +841,9 @@ validates :file, if: -> { remote_url.blank? }
 ```
 ## Ducalis::TooLongWorkers
 
-Seems like your worker is doing too much work, consider of moving business
- logic to service object. As rule, workers should have only two responsibilities:
- - __Model materialization__: As async jobs working with serialized attributes
- it's nescessary to cast them into actual objects.
- - __Errors handling__: Rescue errors and figure out what to do with them.
+Seems like your worker is doing too much work, consider of moving business logic to service object. As rule, workers should have only two responsibilities:
+- __Model materialization__: As async jobs working with serialized attributes it's nescessary to cast them into actual objects.
+- __Errors handling__: Rescue errors and figure out what to do with them.
 
 ![](https://placehold.it/10/f03c15/000000?text=+) raises for a class with more than 5 lines
 ```ruby
@@ -859,9 +909,8 @@ end
 ```
 ## Ducalis::UncommentedGem
 
-Please, add comment why are you including non-realized gem version for
- %<gem>s. It will increase
- [bus-factor](<https://en.wikipedia.org/wiki/Bus_factor>).
+Please, add comment why are you including non-realized gem version for %<gem>s.
+It will increase [bus-factor](<https://en.wikipedia.org/wiki/Bus_factor>).
 
 ![](https://placehold.it/10/f03c15/000000?text=+) raises for gem from github without comment
 ```ruby
@@ -879,22 +928,39 @@ gem 'pry', '~> 0.10', '>= 0.10.0'
 gem 'rake', '~> 12.1'
 gem 'rspec', github: 'rspec/rspec' # new non released API
 
+```
+## Ducalis::UnlockedGem
+
+It's better to lock gem versions explicitly with pessimistic operator (~>).
+
+![](https://placehold.it/10/f03c15/000000?text=+) raises for gem without version
+```ruby
+gem 'pry'
+```
+
+![](https://placehold.it/10/2cbe4e/000000?text=+) ignores gems with locked versions
+```ruby
+
+gem 'pry', '~> 0.10', '>= 0.10.0'
+gem 'rake', '~> 12.1'
+gem 'thor', '= 0.20.0'
+gem 'rspec', github: 'rspec/rspec'
+
 ```
 ## Ducalis::UselessOnly
 
-Seems like there is no any reason to keep before filter only for one
- action. Maybe it will be better to inline it?
+Seems like there is no any reason to keep before filter only for one action. Maybe it will be better to inline it?
 
- ```ruby
- before_filter :do_something, only: %i[index]
- def index; end
+```ruby
+before_filter :do_something, only: %i[index]
+def index; end
 
- # to
+# to
 
- def index
-   do_something
- end
- ```
+def index
+  do_something
+end
+```
 
 ![](https://placehold.it/10/f03c15/000000?text=+) raises for `before_filters` with only one method as array
 ```ruby

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ducalis (0.5.10)
+    ducalis (0.5.11)
       git (~> 1.3, >= 1.3.0)
       policial (= 0.0.4)
       regexp-examples (~> 1.3, >= 1.3.2)

data/README.md

@@ -59,6 +59,17 @@ In CLI modes you can provide yours `.ducalis.yml` file based on
 [default](https://github.com/ignat-z/ducalis/blob/master/config/.ducalis.yml) by
 `-c` flag or simply putting it in your project directory.
 
+## Configuration
+
+One or more individual cops can be disabled locally in a section of a file by adding a comment such as
+
+```ruby
+# ducalis:disable Ducalis/PreferableMethods Use `delete_all` because of performance reasons
+def remove_audits
+  AuditLog.where(user_id: user_id).delete_all
+end
+```
+
 ## Contribution
 
 To pass your code through the all checks you simply need to run:

data/config/.ducalis.yml

@@ -30,7 +30,7 @@ Ducalis/CallbacksActiverecord:
   Enabled: true
 
 Ducalis/PossibleTap:
-  Enabled: true
+  Enabled: false
 
 Ducalis/ProtectedScopeCop:
   Enabled: true
@@ -60,6 +60,9 @@ Ducalis/RestOnlyCop:
 Ducalis/KeywordDefaults:
   Enabled: true
 
+Ducalis/OptionsArgument:
+  Enabled: true
+
 Ducalis/RubocopDisable:
   Enabled: true
 
@@ -80,9 +83,15 @@ Ducalis/ControllersExcept:
 Ducalis/PrivateInstanceAssign:
   Enabled: true
 
+Ducalis/StandardMethods:
+  Enabled: true
+
 Ducalis/RaiseWithoutErrorClass:
   Enabled: true
 
+Ducalis/UnlockedGem:
+  Enabled: true
+
 Ducalis/ModuleLikeClass:
   Enabled: true
   AllowedIncludes:

data/lib/ducalis/cops/black_list_suffix.rb

@@ -4,12 +4,10 @@ require 'rubocop'
 
 module Ducalis
   class BlackListSuffix < RuboCop::Cop::Cop
-    OFFENSE = <<-MESSAGE.gsub(/^ +\|/, '').strip
-      | Please, avoid using of class suffixes like `Meneger`, `Client`
-      | and so on. If it has no parts, change the name of the class to what
-      | each object is managing. It's ok to use Manager as subclass of Person,
-      | which is there to refine a type of personal that has management
-      | behavior to it.
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | Please, avoid using of class suffixes like `Meneger`, `Client` and so on. If it has no parts, change the name of the class to what each object is managing.
+
+      | It's ok to use Manager as subclass of Person, which is there to refine a type of personal that has management behavior to it.
       | Related [article](<http://www.carlopescio.com/2011/04/your-coding-conventions-are-hurting-you.html>)
     MESSAGE
 

data/lib/ducalis/cops/callbacks_activerecord.rb

@@ -4,11 +4,9 @@ require 'rubocop'
 
 module Ducalis
   class CallbacksActiverecord < RuboCop::Cop::Cop
-    OFFENSE = <<-MESSAGE.gsub(/^ +\|/, '').strip
-      | Please, avoid using of callbacks for models. It's better to
-      | keep models small ("dumb") and instead use "builder" classes
-      | / services: to construct new objects. You can read more
-      | [here](https://medium.com/planet-arkency/a61fd75ab2d3).
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | Please, avoid using of callbacks for models. It's better to keep models small ("dumb") and instead use "builder" classes/services: to construct new objects.
+      | You can read more [here](https://medium.com/planet-arkency/a61fd75ab2d3).
     MESSAGE
 
     MODELS_CLASS_NAMES = [

data/lib/ducalis/cops/case_mapping.rb

@@ -4,87 +4,69 @@ require 'rubocop'
 
 module Ducalis
   class CaseMapping < RuboCop::Cop::Cop
-    OFFENSE = <<-MESSAGE.gsub(/^ +\|/, '').strip
-      | Try to avoid `case when` statements. You can replace it with a sequence
-      | of `if... elsif... elsif... else`. For cases where you need to choose
-      | from a large number of possibilities, you can create a dictionary
-      | mapping case values to functions to call by `call`. It's nice to have
-      | prefix for the method names, i.e.: `visit_`.
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | Try to avoid `case when` statements. You can replace it with a sequence of `if... elsif... elsif... else`.
+      | For cases where you need to choose from a large number of possibilities, you can create a dictionary mapping case values to functions to call by `call`. It's nice to have prefix for the method names, i.e.: `visit_`.
     MESSAGE
 
-    DETAILS = %(
-Usually `case when` statements are using for the next reasons:
-
-I. Mapping between different values.
-("A" => 1, "B" => 2, ...)
-
-This case is all about data representing. If you do not need to execute any code
-it's better to use data structure which represents it. This way you are
-separating concepts: code returns corresponding value and you have config-like
-data structure which describes your data.
-
-```ruby
-  %w[A B ...].index("A") + 1
-  # or
-  { "A" => 1, "B" => 2 }.fetch("A")
-```
-
-II. Code execution depending of parameter or type:
-
-  - a. (:attack => attack, :defend => defend)
-  - b. (Feet => value * 0.348, Meters => `value`)
-
-In this case code violates OOP and S[O]LID principle. Code shouldn't know about
-object type and classes should be open for extension, but closed for
-modification (but you can't do it with case-statements).
-This is a signal that you have some problems with architecture.
-
-  a.
-```ruby
-attack: -> { execute_attack }, defend: -> { execute_defend }
-#{(action = '#{' + 'action' + '}') && '# or'}
-call(:"execute_#{action}")
-```
-
-  b.
-```ruby
-class Meters; def to_metters; value;         end
-class Feet;   def to_metters; value * 0.348; end
-```
-
-III. Code execution depending on some statement.
-(`a > 0` => 1, `a == 0` => 0, `a < 0` => -1)
-
-This case is combination of I and II -- high code complexity and unit-tests
-complexity. There are variants how to solve it:
-
-  a. Rewrite to simple if statement
-
-```ruby
-return 0 if a == 0
-a > 0 ? 1 : -1
-```
-
-  b. Move statements to lambdas:
-
-```ruby
- ->(a) { a > 0 }  =>  1,
- ->(a) { a == 0 } =>  0,
- ->(a) { a < 0 }  => -1
-```
-
-This way decreases code complexity by delegating it to lambdas and makes it easy
- to unit-testing because it's easy to test pure lambdas.
-
-Such approach is named
-[table-driven design](<https://www.d.umn.edu/~gshute/softeng/table-driven.html>)
-. Table-driven methods are schemes that allow you to look up information in a
-table rather than using logic statements (i.e. case, if). In simple cases,
-it's quicker and easier to use logic statements, but as the logic chain becomes
-more complex, table-driven code is simpler than complicated logic, easier to
-modify and more efficient.
-</details>
-    ).strip
+    DETAILS = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | Usually `case when` statements are using for the next reasons:
+
+      | I. Mapping between different values.
+      | ("A" => 1, "B" => 2, ...)
+
+      | This case is all about data representing. If you do not need to execute any code it's better to use data structure which represents it. This way you are separating concepts: code returns corresponding value and you have config-like data structure which describes your data.
+
+      | ```ruby
+      |   %w[A B ...].index("A") + 1
+      |   # or
+      |   { "A" => 1, "B" => 2 }.fetch("A")
+      | ```
+
+      | II. Code execution depending of parameter or type:
+
+      |   - a. (:attack => attack, :defend => defend)
+      |   - b. (Feet => value * 0.348, Meters => `value`)
+
+      | In this case code violates OOP and S[O]LID principle. Code shouldn't know about object type and classes should be open for extension, but closed for modification (but you can't do it with case-statements). This is a signal that you have some problems with architecture.
+
+      |  a.
+      | ```ruby
+      | attack: -> { execute_attack }, defend: -> { execute_defend }
+      | #{(action = '#{' + 'action' + '}') && '# or'}
+      | call(:"execute_#{action}")
+      | ```
+
+      | b.
+      | ```ruby
+      | class Meters; def to_metters; value;         end
+      | class Feet;   def to_metters; value * 0.348; end
+      | ```
+
+      | III. Code execution depending on some statement.
+      | (`a > 0` => 1, `a == 0` => 0, `a < 0` => -1)
+
+      | This case is combination of I and II -- high code complexity and unit-tests complexity. There are variants how to solve it:
+
+      |  a. Rewrite to simple if statement
+
+      | ```ruby
+      | return 0 if a == 0
+      | a > 0 ? 1 : -1
+      | ```
+
+      |  b. Move statements to lambdas:
+
+      | ```ruby
+      |  ->(a) { a > 0 }  =>  1,
+      |  ->(a) { a == 0 } =>  0,
+      |  ->(a) { a < 0 }  => -1
+      | ```
+
+      | This way decreases code complexity by delegating it to lambdas and makes it easy to unit-testing because it's easy to test pure lambdas.
+
+      | Such approach is named [table-driven design](<https://www.d.umn.edu/~gshute/softeng/table-driven.html>). Table-driven methods are schemes that allow you to look up information in a table rather than using logic statements (i.e. case, if). In simple cases, it's quicker and easier to use logic statements, but as the logic chain becomes more complex, table-driven code is simpler than complicated logic, easier to modify and more efficient.
+    MESSAGE
 
     def on_case(node)
       add_offense(node, :expression, OFFENSE)

data/lib/ducalis/cops/controllers_except.rb

@@ -4,9 +4,8 @@ require 'rubocop'
 
 module Ducalis
   class ControllersExcept < RuboCop::Cop::Cop
-    OFFENSE = <<-MESSAGE.gsub(/^ +\|/, '').strip
-      | Prefer to use `:only` over `:except` in controllers because it's more
-      | explicit and will be easier to maintain for new developers.
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | Prefer to use `:only` over `:except` in controllers because it's more explicit and will be easier to maintain for new developers.
     MESSAGE
 
     FILTERS = %i(before_filter after_filter around_filter

data/lib/ducalis/cops/keyword_defaults.rb

@@ -4,9 +4,8 @@ require 'rubocop'
 
 module Ducalis
   class KeywordDefaults < RuboCop::Cop::Cop
-    OFFENSE = <<-MESSAGE.gsub(/^ +\|/, '').strip
-      | Prefer to use keyword arguments for defaults. It increases readability
-      | and reduces ambiguities.
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | Prefer to use keyword arguments for defaults. It increases readability and reduces ambiguities.
     MESSAGE
 
     def on_def(node)

data/lib/ducalis/cops/module_like_class.rb

@@ -5,9 +5,8 @@ require 'rubocop'
 module Ducalis
   class ModuleLikeClass < RuboCop::Cop::Cop
     include RuboCop::Cop::DefNode
-    OFFENSE = <<-MESSAGE.gsub(/^ +\|/, '').strip
-      | Seems like it will be better to define initialize and pass %<args>s
-      | there instead of each method.
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | Seems like it will be better to define initialize and pass %<args>s there instead of each method.
     MESSAGE
 
     def on_class(node)

data/lib/ducalis/cops/options_argument.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Ducalis
+  class OptionsArgument < RuboCop::Cop::Cop
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | Default options argument isn't good idea. It's better to explicitly pass which keys are you interested in as keyword arguments. You can use split operator to support hash arguments.
+
+      | Compare:
+
+      | ```ruby
+      | def generate_1(document, options = {})
+      |   format = options.delete(:format)
+      |   limit = options.delete(:limit) || 20
+      |   # ...
+      |   [format, limit, options]
+      | end
+      | generate_1(1, format: 'csv', limit: 5, useless_arg: :value)
+
+      | # vs
+
+      | def generate_2(document, format:, limit: 20, **options)
+      |   # ...
+      |   [format, limit, options]
+      | end
+      | generate_2(1, format: 'csv', limit: 5, useless_arg: :value)
+      | ```
+    MESSAGE
+
+    def on_def(node)
+      _name, args, _body = *node
+      return unless default_options?(args)
+      add_offense(node, :expression, OFFENSE)
+    end
+
+    private
+
+    def_node_search :options_arg?, '(arg :options)'
+    def_node_search :options_arg_with_default?, '(optarg :options ...)'
+
+    def default_options?(args)
+      args.children.any? do |node|
+        options_arg?(node) || options_arg_with_default?(node)
+      end
+    end
+  end
+end

data/lib/ducalis/cops/params_passing.rb

@@ -4,9 +4,8 @@ require 'rubocop'
 
 module Ducalis
   class ParamsPassing < RuboCop::Cop::Cop
-    OFFENSE = <<-MESSAGE.gsub(/^ +\|/, '').strip
-      | It's better to pass already preprocessed params hash to services. Or
-      | you can use `arcane` gem.
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | It's better to pass already preprocessed params hash to services. Or you can use `arcane` gem.
     MESSAGE
 
     PARAMS_CALL = s(:send, nil, :params)

data/lib/ducalis/cops/possible_tap.rb

@@ -4,12 +4,9 @@ require 'rubocop'
 
 module Ducalis
   class PossibleTap < RuboCop::Cop::Cop
-    OFFENSE = <<-MESSAGE.gsub(/^ +\|/, '').strip
-      | Consider of using `.tap`, default ruby
-      | [method](<https://apidock.com/ruby/Object/tap>)
-      | which allows to replace intermediate variables with block, by this you
-      | are limiting scope pollution and make method scope more clear. If it isn't
-      | possible, consider of moving it to method or even inline it.
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | Consider of using `.tap`, default ruby [method](<https://apidock.com/ruby/Object/tap>) which allows to replace intermediate variables with block, by this you are limiting scope pollution and make method scope more clear.
+      | If it isn't possible, consider of moving it to method or even inline it.
       | [Related article](<http://seejohncode.com/2012/01/02/ruby-tap-that/>).
     MESSAGE
 

data/lib/ducalis/cops/preferable_methods.rb

@@ -3,9 +3,8 @@ require 'rubocop'
 
 module Ducalis
   class PreferableMethods < RuboCop::Cop::Cop
-    OFFENSE = <<-MESSAGE.gsub(/^ +\|/, '').strip
-      | Prefer to use %<alternative>s method instead of %<original>s because of
-      | %<reason>s.
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | Prefer to use %<alternative>s method instead of %<original>s because of %<reason>s.
     MESSAGE
 
     ALWAYS_TRUE = ->(_who, _what, _args) { true }
@@ -15,10 +14,22 @@ module Ducalis
         args.count <= 1 && who.to_s !~ /file/
     end
 
+    VALIDATE_CHECK = lambda do |_who, _what, args|
+      (args.first && args.first.source) =~ /validate/
+    end
+
     DESCRIPTION = {
       # Method => [Alternative, Reason, Callable condition]
+      toggle!: ['toggle.save', 'it is not invoking validations', ALWAYS_TRUE],
+      save: [:save, 'it is not invoking validations', VALIDATE_CHECK],
+      delete: [:destroy, 'it is not invoking callbacks', DELETE_CHECK],
       delete_all: [:destroy_all, 'it is not invoking callbacks', ALWAYS_TRUE],
-      delete: [:destroy, 'it is not invoking callbacks', DELETE_CHECK]
+      update_attribute: [:update, 'it is not invoking validation', ALWAYS_TRUE],
+      update_column: [:update, 'it is not invoking callbacks', ALWAYS_TRUE],
+      update_columns: [
+        :update, 'it is not invoking validations, callbacks and updated_at',
+        ALWAYS_TRUE
+      ]
     }.freeze
 
     DETAILS = "Dangerous methods are:

data/lib/ducalis/cops/private_instance_assign.rb

@@ -5,19 +5,13 @@ require 'rubocop'
 module Ducalis
   class PrivateInstanceAssign < RuboCop::Cop::Cop
     include RuboCop::Cop::DefNode
-    OFFENSE = <<-MESSAGE.gsub(/^ +\|/, '').strip
-      | Don't use controller's filter methods for setting instance variables, use
-      | them only for changing application flow, such as redirecting if a user
-      | is not authenticated. Controller instance variables are forming contract
-      | between controller and view. Keeping instance variables defined in one
-      | place makes it easier to: reason, refactor and remove old views, test
-      | controllers and views, extract actions to new controllers, etc.
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | Don't use controller's filter methods for setting instance variables, use them only for changing application flow, such as redirecting if a user is not authenticated. Controller instance variables are forming contract between controller and view. Keeping instance variables defined in one place makes it easier to: reason, refactor and remove old views, test controllers and views, extract actions to new controllers, etc.
     MESSAGE
 
-    ADD_OFFENSE = %(
-If you want to memoize variable, please, add underscore to the variable name \
-start: `@_name`.
-).strip
+    ADD_OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      If you want to memoize variable, please, add underscore to the variable name start: `@_name`.
+    MESSAGE
 
     DETAILS = ADD_OFFENSE
 

data/lib/ducalis/cops/protected_scope_cop.rb

@@ -4,11 +4,10 @@ require 'rubocop'
 
 module Ducalis
   class ProtectedScopeCop < RuboCop::Cop::Cop
-    OFFENSE = <<-MESSAGE.gsub(/^ +\|/, '').strip
-      | Seems like you are using `find` on non-protected scope. Potentially it
-      | could lead to unauthorized access. It's better to call `find` on
-      | authorized resources scopes. Example:
-      |
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | Seems like you are using `find` on non-protected scope. Potentially it could lead to unauthorized access. It's better to call `find` on authorized resources scopes.
+      | Example:
+
       | ```ruby
       | current_group.employees.find(params[:id])
       | # better then

data/lib/ducalis/cops/raise_without_error_class.rb

@@ -4,9 +4,8 @@ require 'rubocop'
 
 module Ducalis
   class RaiseWithoutErrorClass < RuboCop::Cop::Cop
-    OFFENSE = <<-MESSAGE.gsub(/^ +\|/, '').strip
-      | It's better to add exception class as raise argument. It will make
-      | easier to catch and process it later.
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | It's better to add exception class as raise argument. It will make easier to catch and process it later.
     MESSAGE
 
     def on_send(node)

data/lib/ducalis/cops/regex_cop.rb

@@ -5,15 +5,13 @@ require 'regexp-examples'
 
 module Ducalis
   class RegexCop < RuboCop::Cop::Cop
-    OFFENSE = <<-MESSAGE.gsub(/^ +\|/, '').strip
-      | It's better to move regex to constants with example instead of direct
-      | using it. It will allow you to reuse this regex and provide instructions
-      | for others.
-      |
-      |```ruby
-      |CONST_NAME = %<constant>s # "%<example>s"
-      |%<fixed_string>s
-      |```
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | It's better to move regex to constants with example instead of direct using it. It will allow you to reuse this regex and provide instructions for others.
+
+      | ```ruby
+      | CONST_NAME = %<constant>s # "%<example>s"
+      | %<fixed_string>s
+      | ```
     MESSAGE
 
     SELF_DESCRIPTIVE = %w(

data/lib/ducalis/cops/rest_only_cop.rb

@@ -5,12 +5,12 @@ require 'rubocop'
 module Ducalis
   class RestOnlyCop < RuboCop::Cop::Cop
     include RuboCop::Cop::DefNode
-    OFFENSE = <<-MESSAGE.gsub(/^ +\|/, '').strip
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
       | It's better for controllers to stay adherent to REST:
       | http://jeromedalbert.com/how-dhh-organizes-his-rails-controllers/.
     MESSAGE
 
-    DETAILS = <<-MESSAGE.gsub(/^ +\|/, '').strip
+    DETAILS = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
       | [About RESTful architecture](<https://confreaks.tv/videos/railsconf2017-in-relentless-pursuit-of-rest>)
     MESSAGE
 

data/lib/ducalis/cops/rubocop_disable.rb

@@ -4,9 +4,8 @@ require 'rubocop'
 
 module Ducalis
   class RubocopDisable < RuboCop::Cop::Cop
-    OFFENSE = <<-MESSAGE.gsub(/^ +\|/, '').strip
-      | Please, do not suppress RuboCop metrics, may be you can introduce some
-      | refactoring or another concept.
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | Please, do not suppress RuboCop metrics, may be you can introduce some refactoring or another concept.
     MESSAGE
 
     def investigate(processed_source)

data/lib/ducalis/cops/standard_methods.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Ducalis
+  class StandardMethods < RuboCop::Cop::Cop
+    BLACK_LIST = [Object].flat_map { |klass| klass.new.methods }
+
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | Please, be sure that you really want to redefine standard ruby methods.
+      | You should know what are you doing and all consequences.
+    MESSAGE
+
+    def on_def(node)
+      name, _args, _body = *node
+      return unless BLACK_LIST.include?(name)
+      add_offense(node, :expression, OFFENSE)
+    end
+  end
+end

data/lib/ducalis/cops/strings_in_activerecords.rb

@@ -5,10 +5,8 @@ require_relative './callbacks_activerecord'
 
 module Ducalis
   class StringsInActiverecords < RuboCop::Cop::Cop
-    OFFENSE = <<-MESSAGE.gsub(/^ +\|/, '').strip
-      | Please, do not use strings as arguments for %<method_name>s argument.
-      | It's hard to test, grep sources, code highlighting and so on.
-      | Consider using of symbols or lambdas for complex expressions.
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | Please, do not use strings as arguments for %<method_name>s argument. It's hard to test, grep sources, code highlighting and so on. Consider using of symbols or lambdas for complex expressions.
     MESSAGE
 
     VALIDATEBLE_METHODS =

data/lib/ducalis/cops/too_long_workers.rb

@@ -6,11 +6,9 @@ module Ducalis
   class TooLongWorkers < RuboCop::Cop::Cop
     include RuboCop::Cop::ClassishLength
 
-    OFFENSE = <<-MESSAGE.gsub(/^ +\|/, '').strip
-      | Seems like your worker is doing too much work, consider of moving business
-      | logic to service object. As rule, workers should have only two responsibilities:
-      | - __Model materialization__: As async jobs working with serialized attributes
-      | it's nescessary to cast them into actual objects.
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | Seems like your worker is doing too much work, consider of moving business logic to service object. As rule, workers should have only two responsibilities:
+      | - __Model materialization__: As async jobs working with serialized attributes it's nescessary to cast them into actual objects.
       | - __Errors handling__: Rescue errors and figure out what to do with them.
     MESSAGE
 

data/lib/ducalis/cops/uncommented_gem.rb

@@ -4,10 +4,9 @@ require 'rubocop'
 
 module Ducalis
   class UncommentedGem < RuboCop::Cop::Cop
-    OFFENSE = <<-MESSAGE.gsub(/^ +\|/, '').strip
-      | Please, add comment why are you including non-realized gem version for
-      | %<gem>s. It will increase
-      | [bus-factor](<https://en.wikipedia.org/wiki/Bus_factor>).
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | Please, add comment why are you including non-realized gem version for %<gem>s.
+      | It will increase [bus-factor](<https://en.wikipedia.org/wiki/Bus_factor>).
     MESSAGE
 
     def investigate(processed_source)

data/lib/ducalis/cops/unlocked_gem.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Ducalis
+  class UnlockedGem < RuboCop::Cop::Cop
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | It's better to lock gem versions explicitly with pessimistic operator (~>).
+    MESSAGE
+
+    def investigate(processed_source)
+      return unless processed_source.ast
+      gem_declarations(processed_source.ast).select do |node|
+        _, _, gemname, _args = *node
+        add_offense(node, :selector,
+                    format(OFFENSE, gem: gemname.loc.expression.source))
+      end
+    end
+
+    def_node_search :gem_declarations, '(send nil :gem (str _))'
+  end
+end

data/lib/ducalis/cops/useless_only.rb

@@ -4,16 +4,15 @@ require 'rubocop'
 
 module Ducalis
   class UselessOnly < RuboCop::Cop::Cop
-    OFFENSE = <<-MESSAGE.gsub(/^ +\|/, '').strip
-      | Seems like there is no any reason to keep before filter only for one
-      | action. Maybe it will be better to inline it?
-      |
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | Seems like there is no any reason to keep before filter only for one action. Maybe it will be better to inline it?
+
       | ```ruby
       | before_filter :do_something, only: %i[index]
       | def index; end
-      |
+
       | # to
-      |
+
       | def index
       |   do_something
       | end

data/lib/ducalis/documentation.rb

@@ -96,7 +96,7 @@ class Documentation
 
   def spec_cases_for(f)
     source_code = File.read(
-      f.sub('/lib/ducalis/', '/spec/')
+      f.sub('/lib/', '/spec/')
        .sub(/.rb$/, '_spec.rb')
     )
     SpecsProcessor.new.tap do |processor|

data/lib/ducalis/passed_args.rb

@@ -4,8 +4,10 @@ module Ducalis
   module PassedArgs
     module_function
 
+    RUBOCOP_FLAGS = %w(-D).freeze
+
     def help_command?
-      ARGV.any? { |arg| Thor::HELP_MAPPINGS.include?(arg) }
+      ARGV.any? { |arg| (Thor::HELP_MAPPINGS - RUBOCOP_FLAGS).include?(arg) }
     end
 
     def ci_mode?

data/lib/ducalis/patched_rubocop/rubo_cop.rb

@@ -8,6 +8,14 @@ module RuboCop
     end
   end
 
+  class CommentConfig
+    ::Ducalis::Utils.silence_warnings do
+      COMMENT_DIRECTIVE_REGEXP = Regexp.new(
+        ('# ducalis : ((?:dis|en)able)\b ' + COPS_PATTERN).gsub(' ', '\s*')
+      )
+    end
+  end
+
   class TargetFinder
     prepend PatchedRubocop::GitTurgetFinder
   end

data/lib/ducalis/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ducalis
-  VERSION = '0.5.10'
+  VERSION = '0.5.11'
 end

data/lib/ducalis.rb

@@ -37,6 +37,7 @@ require 'ducalis/cops/case_mapping'
 require 'ducalis/cops/controllers_except'
 require 'ducalis/cops/keyword_defaults'
 require 'ducalis/cops/module_like_class'
+require 'ducalis/cops/options_argument'
 require 'ducalis/cops/params_passing'
 require 'ducalis/cops/possible_tap'
 require 'ducalis/cops/private_instance_assign'
@@ -46,7 +47,9 @@ require 'ducalis/cops/raise_without_error_class'
 require 'ducalis/cops/regex_cop'
 require 'ducalis/cops/rest_only_cop'
 require 'ducalis/cops/rubocop_disable'
+require 'ducalis/cops/standard_methods'
 require 'ducalis/cops/strings_in_activerecords'
 require 'ducalis/cops/too_long_workers'
 require 'ducalis/cops/uncommented_gem'
+require 'ducalis/cops/unlocked_gem'
 require 'ducalis/cops/useless_only'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ducalis
 version: !ruby/object:Gem::Version
-  version: 0.5.10
+  version: 0.5.11
 platform: ruby
 authors:
 - Ignat Zakrevsky
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-21 00:00:00.000000000 Z
+date: 2017-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: git
@@ -136,6 +136,7 @@ files:
 - lib/ducalis/cops/controllers_except.rb
 - lib/ducalis/cops/keyword_defaults.rb
 - lib/ducalis/cops/module_like_class.rb
+- lib/ducalis/cops/options_argument.rb
 - lib/ducalis/cops/params_passing.rb
 - lib/ducalis/cops/possible_tap.rb
 - lib/ducalis/cops/preferable_methods.rb
@@ -145,9 +146,11 @@ files:
 - lib/ducalis/cops/regex_cop.rb
 - lib/ducalis/cops/rest_only_cop.rb
 - lib/ducalis/cops/rubocop_disable.rb
+- lib/ducalis/cops/standard_methods.rb
 - lib/ducalis/cops/strings_in_activerecords.rb
 - lib/ducalis/cops/too_long_workers.rb
 - lib/ducalis/cops/uncommented_gem.rb
+- lib/ducalis/cops/unlocked_gem.rb
 - lib/ducalis/cops/useless_only.rb
 - lib/ducalis/documentation.rb
 - lib/ducalis/passed_args.rb