ducalis 0.5.14 → 0.6.0

data/lib/ducalis/cops/rest_only_cop.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
 require 'rubocop'
+require 'ducalis/cops/extensions/type_resolving'
 
 module Ducalis
   class RestOnlyCop < RuboCop::Cop::Cop
     include RuboCop::Cop::DefNode
+    prepend TypeResolving
+
     OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
       | It's better for controllers to stay adherent to REST:
       | http://jeromedalbert.com/how-dhh-organizes-his-rails-controllers/.
@@ -16,23 +19,13 @@ module Ducalis
 
     WHITELIST = %i(index show new edit create update destroy).freeze
 
-    def on_class(node)
-      _classdef_node, superclass, _body = *node
-      return if superclass.nil?
-      @triggered = superclass.loc.expression.source =~ /Controller/
-    end
-
     def on_def(node)
-      return unless triggered
+      return unless in_controller?
       return if non_public?(node)
       method_name, = *node
       return if WHITELIST.include?(method_name)
       add_offense(node, :expression, OFFENSE)
     end
     alias on_defs on_def
-
-    private
-
-    attr_reader :triggered
   end
 end

data/lib/ducalis/cops/too_long_workers.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 require 'rubocop'
+require 'ducalis/cops/extensions/type_resolving'
 
 module Ducalis
   class TooLongWorkers < RuboCop::Cop::Cop
     include RuboCop::Cop::ClassishLength
+    prepend TypeResolving
 
     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:
@@ -12,20 +14,13 @@ module Ducalis
       | - __Errors handling__: Rescue errors and figure out what to do with them.
     MESSAGE
 
-    WORKERS_SUFFIXES = %w(Worker Job).freeze
-
     def on_class(node)
-      return unless worker_class?(node)
+      return unless in_worker?
       check_code_length(node)
     end
 
     private
 
-    def worker_class?(node)
-      classdef_node, _superclass, _body = *node
-      classdef_node.source.end_with?(*WORKERS_SUFFIXES)
-    end
-
     def message(length, max_length)
       format("#{OFFENSE} [%d/%d]", length, max_length)
     end

data/lib/ducalis/cops/uncommented_gem.rb

@@ -6,9 +6,14 @@ module Ducalis
   class UncommentedGem < RuboCop::Cop::Cop
     OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
       | Please, add comment why are you including non-realized gem version for %<gem>s.
+    MESSAGE
+
+    DETAILS = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
       | It will increase [bus-factor](<https://en.wikipedia.org/wiki/Bus_factor>).
     MESSAGE
 
+    ALLOWED_KEYS = %w(require group :require :group).freeze
+
     def investigate(processed_source)
       return unless processed_source.ast
       gem_declarations(processed_source.ast).select do |node|
@@ -22,12 +27,19 @@ module Ducalis
 
     private
 
-    def_node_search :gem_declarations, '(send nil :gem str ...)'
+    def_node_search :gem_declarations, '(send nil :gem str #allowed_args?)'
 
     def commented?(processed_source, node)
       processed_source.comments
                       .map { |subnode| subnode.loc.line }
                       .include?(node.loc.line)
     end
+
+    def allowed_args?(args)
+      return false if args.nil? || args.type != :hash
+      args.children.any? do |arg_node|
+        !ALLOWED_KEYS.include?(arg_node.children.first.source)
+      end
+    end
   end
 end

data/lib/ducalis/cops/useless_only.rb

@@ -6,6 +6,10 @@ module Ducalis
   class UselessOnly < RuboCop::Cop::Cop
     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?
+    MESSAGE
+
+    DETAILS = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | Compare:
 
       | ```ruby
       | before_filter :do_something, only: %i[index]
@@ -16,18 +20,14 @@ module Ducalis
       | def index
       |   do_something
       | end
+
       | ```
+
     MESSAGE
 
     FILTERS = %i(before_filter after_filter around_filter
                  before_action after_action around_action).freeze
 
-    def on_class(node)
-      _classdef_node, superclass, _body = *node
-      return if superclass.nil?
-      @triggered = superclass.loc.expression.source =~ /Controller/
-    end
-
     def on_send(node)
       _, method_name, *args = *node
       hash_node = args.find { |subnode| subnode.type == :hash }
@@ -43,7 +43,5 @@ module Ducalis
     def decomposite_hash(args)
       args.to_a.first.children.to_a
     end
-
-    attr_reader :triggered
   end
 end

data/lib/ducalis/documentation.rb

@@ -27,17 +27,25 @@ class SpecsProcessor < Parser::AST::Processor
 
   def on_send(node)
     _, name, _body = *node
-    if name == :inspect_source
-      source_code = remove_array_wrapping(node.to_a.last.loc.expression.source)
-                    .split("\n")
-                    .map { |line| remove_string_wrapping(line) }
-      cases << [current_it, source_code]
-    end
+    cases << [current_it, source_code(node)] if name == :inspect_source
     super
   end
 
   private
 
+  def source_code(node)
+    prepare_code(node).tap do |code|
+      code.shift if code.first.empty?
+      code.pop if code.last.empty?
+    end
+  end
+
+  def prepare_code(node)
+    remove_array_wrapping(node.to_a.last.loc.expression.source)
+      .split("\n")
+      .map { |line| remove_string_wrapping(line) }
+  end
+
   def current_it
     it_block = @nesting.reverse.find { |node| node.type == :block }
     it = it_block.to_a.first
@@ -57,13 +65,11 @@ class SpecsProcessor < Parser::AST::Processor
 end
 
 class Documentation
-  RED_SQUARE = '![](https://placehold.it/10/f03c15/000000?text=+)'
-  GREEN_SQUARE = '![](https://placehold.it/10/2cbe4e/000000?text=+)'
   SIGNAL_WORD = 'raises'
-  IGNORE_WORDS = ['[bugfix]'].freeze
+  RULE_WORD = '[rule]'
 
   def call
-    Dir['./lib/ducalis/cops/*.rb'].sort.map do |f|
+    Dir[File.join(File.dirname(__FILE__), 'cops', '*.rb')].sort.map do |f|
       present_cop(klass_const_for(f), spec_cases_for(f))
     end.flatten.join("\n")
   end
@@ -73,18 +79,22 @@ class Documentation
   def present_cop(klass, specs)
     [
       "## #{klass}\n",                                  # header
-      message(klass)                                    # description
+      message(klass) + "\n"                             # description
     ] +
       specs.map do |(it, code)|
         [
-          "\n#{color(it)} #{it}",                       # case description
-          "```ruby\n#{code.join("\n")}\n```"            # code example
+          prepare(it).to_s, # case description
+          "\n```ruby\n#{mention(it)}\n#{code.join("\n")}\n```\n" # code example
         ]
       end
   end
 
-  def color(it)
-    it.include?(SIGNAL_WORD) ? RED_SQUARE : GREEN_SQUARE
+  def prepare(it)
+    it.sub("#{RULE_WORD} ", '')
+  end
+
+  def mention(it)
+    it.include?(SIGNAL_WORD) ? '# bad' : '# good'
   end
 
   def message(klass)
@@ -101,12 +111,12 @@ class Documentation
     )
     SpecsProcessor.new.tap do |processor|
       processor.process(Parser::CurrentRuby.parse(source_code))
-    end.cases.reject(&method(:ignored?))
+    end.cases.select(&method(:allowed?))
   end
 
-  def ignored?(example)
+  def allowed?(example)
     desc, _code = example
-    IGNORE_WORDS.any? { |word| desc.include?(word) }
+    desc.include?(RULE_WORD)
   end
 
   def klass_const_for(f)

data/lib/ducalis/passed_args.rb

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

data/lib/ducalis/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ducalis
 version: !ruby/object:Gem::Version
-  version: 0.5.14
+  version: 0.6.0
 platform: ruby
 authors:
 - Ignat Zakrevsky
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-22 00:00:00.000000000 Z
+date: 2018-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: git
@@ -84,20 +84,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.46.0
-- !ruby/object:Gem::Dependency
-  name: thor
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.20.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.20.0
 description: "    Ducalis is RuboCop based static code analyzer for enterprise Rails
   \    applications.\n"
 email:
@@ -113,7 +99,6 @@ files:
 - ".rubocop.yml"
 - ".ruby-version"
 - ".travis.yml"
-- DOCUMENTATION.md
 - Gemfile
 - Gemfile.lock
 - LICENSE
@@ -134,8 +119,14 @@ files:
 - lib/ducalis/cops/callbacks_activerecord.rb
 - lib/ducalis/cops/case_mapping.rb
 - lib/ducalis/cops/controllers_except.rb
+- lib/ducalis/cops/data_access_objects.rb
+- lib/ducalis/cops/enforce_namespace.rb
+- lib/ducalis/cops/evlis_overusing.rb
+- lib/ducalis/cops/extensions/type_resolving.rb
+- lib/ducalis/cops/fetch_expression.rb
 - lib/ducalis/cops/keyword_defaults.rb
 - lib/ducalis/cops/module_like_class.rb
+- lib/ducalis/cops/multiple_times.rb
 - lib/ducalis/cops/only_defs.rb
 - lib/ducalis/cops/options_argument.rb
 - lib/ducalis/cops/params_passing.rb
@@ -143,6 +134,7 @@ files:
 - lib/ducalis/cops/preferable_methods.rb
 - lib/ducalis/cops/private_instance_assign.rb
 - lib/ducalis/cops/protected_scope_cop.rb
+- lib/ducalis/cops/public_send.rb
 - lib/ducalis/cops/raise_without_error_class.rb
 - lib/ducalis/cops/regex_cop.rb
 - lib/ducalis/cops/rest_only_cop.rb

data/DOCUMENTATION.md

@@ -1,1185 +0,0 @@
-## 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>)
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises on classes with suffixes from black list
-```ruby
-
-class ListSorter
-end
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores classes with okish suffixes
-```ruby
-
-class SortedList
-end
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores classes with full match
-```ruby
-
-class Manager
-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).
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises on ActiveRecord classes which contains callbacks
-```ruby
-
-class Product < ActiveRecord::Base
-  before_create :generate_code
-end
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores non-ActiveRecord classes which contains callbacks
-```ruby
-
-class Product < BasicProduct
-  before_create :generate_code
-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_`.
-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 }
-# 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.
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises on case statements
-```ruby
-
-case grade
-when "A"
-  puts "Well done!"
-when "B"
-  puts "Try harder!"
-when "C"
-  puts "You need help!!!"
-else
-  puts "You just making it up!"
-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.
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises for `before_filters` with `except` method as array
-```ruby
-
-class ProductsController < ApplicationController
-  before_filter :update_cost, except: [:index]
-
-  def index; end
-  def edit; end
-
-  private
-
-  def update_cost; end
-end
-
-```
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises for filters with many actions and only one `except` method
-```ruby
-
-class ProductsController < ApplicationController
-  before_filter :update_cost, :load_me, except: %i[edit]
-
-  def index; end
-  def edit; end
-
-  private
-
-  def update_cost; end
-  def load_me; end
-end
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores `before_filters` without arguments
-```ruby
-
-class ProductsController < ApplicationController
-  before_filter :update_cost
-
-  def index; end
-
-  private
-
-  def update_cost; end
-end
-
-```
-## Ducalis::KeywordDefaults
-
-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
-def calculate(step, index, dry = true); end
-```
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises if class method definition contains default values
-```ruby
-def self.calculate(step, index, dry = true); end
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores if method definition contains default values through keywords
-```ruby
-def calculate(step, index, dry: true); end
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores for methods without arguments
-```ruby
-def calculate_amount; end
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores for class methods without arguments
-```ruby
-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.
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises if class doesn't contain constructor but accept the same args
-```ruby
-
-class TaskJournal
-  def initialize(customer)
-    # ...
-  end
-
-  def approve(task, estimate, options)
-    # ...
-  end
-
-  def decline(user, task, estimate, details)
-    # ...
-  end
-
-  private
-
-  def log(record)
-    # ...
-  end
-end
-
-```
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises for class with only one public method with args
-```ruby
-
-class TaskJournal
-  def approve(task)
-    # ...
-  end
-
-  private
-
-  def log(record)
-    # ...
-  end
-end
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores classes with custom includes
-```ruby
-
-class TaskJournal
-  include Singleton
-
-  def approve(task)
-    # ...
-  end
-end
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores classes with inheritance
-```ruby
-
-class TaskJournal < BasicJournal
-  def approve(task)
-    # ...
-  end
-
-  private
-
-  def log(record)
-    # ...
-  end
-end
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores classes with one method and initializer
-```ruby
-
-class TaskJournal
-  def initialize(task)
-    # ...
-  end
-
-  def call(args)
-    # ...
-  end
-end
-
-```
-## Ducalis::OnlyDefs
-
-Prefer object instances to class methods because class methods resist refactoring. Begin with an object instance, even if it doesn’t have state or multiple methods right away. If you come back to change it later, you will be more likely to refactor. If it never changes, the difference between the class method approach and the instance is negligible, and you certainly won’t be any worse off.
-Related article: https://codeclimate.com/blog/why-ruby-class-methods-resist-refactoring/
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores classes with one instance method
-```ruby
-
-class TaskJournal
-  def initialize(task)
-    # ...
-  end
-
-  def call(args)
-    # ...
-  end
-end
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores classes with mixed methods
-```ruby
-
-class TaskJournal
-  def self.find(task)
-    # ...
-  end
-
-  def call(args)
-    # ...
-  end
-end
-
-```
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises error for class with ONLY class methods
-```ruby
-
-class TaskJournal
-
-  def self.call(task)
-    # ...
-  end
-
-  def self.find(args)
-    # ...
-  end
-end
-
-```
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises error for class with ONLY class << self
-```ruby
-
-class TaskJournal
-  class << self
-    def call(task)
-      # ...
-    end
-
-    def find(args)
-      # ...
-    end
-  end
-end
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores instance methods mixed with ONLY class << self
-```ruby
-
-class TaskJournal
-  class << self
-    def call(task)
-      # ...
-    end
-  end
-
-  def find(args)
-    # ...
-  end
-end
-
-```
-## Ducalis::OptionsArgument
-
-Default `options` (or `args`) 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
-
-options = { format: 'csv', limit: 5, useless_arg: :value }
-generate_1(1, options) #=> ["csv", 5, {:useless_arg=>:value}]
-generate_1(1, format: 'csv', limit: 5, useless_arg: :value) #=> ["csv", 5, {:useless_arg=>:value}]
-
-# vs
-
-def generate_2(document, format:, limit: 20, **options)
-  # ...
-  [format, limit, options]
-end
-
-options = { format: 'csv', limit: 5, useless_arg: :value }
-generate_2(1, **options) #=> ["csv", 5, {:useless_arg=>:value}]
-generate_2(1, format: 'csv', limit: 5, useless_arg: :value) #=> ["csv", 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/f03c15/000000?text=+) raises if method accepts args argument
-```ruby
-
-def log(record, args)
-  # ...
-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.
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises if user pass `params` as argument from controller
-```ruby
-
-class ProductsController < ApplicationController
-  def index
-    Record.new(params).log
-  end
-end
-
-```
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises if user pass `params` as any argument from controller
-```ruby
-
-class ProductsController < ApplicationController
-  def index
-    Record.new(first_arg, params).log
-  end
-end
-
-```
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises if user pass `params` as keyword argument from controller
-```ruby
-
-class ProductsController < ApplicationController
-  def index
-    Record.new(first_arg, any_name: params).log
-  end
-end
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores passing only one `params` field
-```ruby
-
-class ProductsController < ApplicationController
-  def index
-    Record.new(first_arg, params[:id]).log
-  end
-end
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores passing processed `params`
-```ruby
-
-class ProductsController < ApplicationController
-  def index
-    Record.new(first_arg, params.slice(:name)).log
-  end
-end
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores passing `params` from `arcane` gem
-```ruby
-
-class ProductsController < ApplicationController
-  def index
-    Record.new(params.for(Log).as(user).refine).log
-  end
-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/>).
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises for methods with scope variable return
-```ruby
-
-def load_group
-  group = channel.groups.find(params[:group_id])
-  authorize group, :edit?
-  group
-end
-
-```
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises for methods with instance variable changes and return
-```ruby
-
-def load_group
-  @group = Group.find(params[:id])
-  authorize @group
-  @group
-end
-
-```
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises for methods with instance variable `||=` assign and return
-```ruby
-
-def define_roles
-  return [] unless employee
-
-  @roles ||= []
-  @roles << "primary"  if employee.primary?
-  @roles << "contract" if employee.contract?
-  @roles
-end
-
-```
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises for methods which return call on scope variable
-```ruby
-
-def load_group
-  elections = @elections.group_by(&:code)
-  result = elections.map do |code, elections|
-    { code => statistic }
-  end
-  result << total_spend(@elections)
-  result.inject(:merge)
-end
-
-```
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises for methods which return instance variable but have scope vars
-```ruby
-
-def generate_file(file_name)
-  @file = Tempfile.new([file_name, ".pdf"])
-  signed_pdf = some_new_stuff
-  @file.write(signed_pdf.to_pdf)
-  @file.close
-  @file
-end
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores empty methods
-```ruby
-
-def edit
-end
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores methods which body is just call
-```ruby
-
-def total_cost(cost_field)
-  Service.cost_sum(cost_field)
-end
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores methods which return some statement
-```ruby
-
-def stop_terminated_employee
-  if current_user && current_user.terminated?
-    sign_out current_user
-    redirect_to new_user_session_path
-  end
-end
-
-
-```
-## Ducalis::PreferableMethods
-
-Prefer to use %<alternative>s method instead of %<original>s because of %<reason>s.
-Dangerous methods are:
-`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 `update_column` method calling
-```ruby
-User.where(id: 7).update_column(admin: 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)
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores calling `delete` with string
-```ruby
-string.delete("-")
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores calling `delete` with multiple args
-```ruby
-some.delete(1, header: [])
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores calling `delete` on files-like variables
-```ruby
-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.
-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
-```ruby
-
-class EmployeesController < ApplicationController
-  private
-
-  def load_employee
-    @employee = Employee.find(params[:id])
-  end
-end
-
-```
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises for memoization variables in controllers private methods
-```ruby
-
-class EmployeesController < ApplicationController
-  private
-
-  def catalog
-    @catalog ||= Catalog.new
-  end
-end
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores memoization variables in controllers private methods with _
-```ruby
-
-class EmployeesController < ApplicationController
-  private
-
-  def catalog
-    @_catalog ||= Catalog.new
-  end
-end
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores assigning instance variables in controllers public methods
-```ruby
-
-class EmployeesController < ApplicationController
-  def index
-    @employee = load_employee
-  end
-
-  private
-
-  def load_employee
-    Employee.find(params[:id])
-  end
-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:
-
-```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
-Group.find(8)
-```
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises if AR search was called even for chain of calls
-```ruby
-Group.includes(:profiles).find(8)
-```
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises if AR search was called with find_by id
-```ruby
-Group.includes(:profiles).find_by(id: 8)
-```
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises if AR search was called on unnamespaced constant
-```ruby
-::Group.find(8)
-```
-
-![](https://placehold.it/10/f03c15/000000?text=+) ignores where statements and still raises error
-```ruby
-Group.includes(:profiles).where(name: "John").find(8)
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores find method with passed block
-```ruby
-MAPPING.find { |x| x == 42 }
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores find method with passed multiline block
-```ruby
-
-MAPPING.find do |x|
-  x == 42
-end
-
-```
-## Ducalis::RaiseWithoutErrorClass
-
-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
-raise "Something went wrong"
-```
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises when `raise` called without arguments
-```ruby
-raise
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores when `raise` called with exception class
-```ruby
-raise StandardError, "Something went wrong"
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores when `raise` called with exception instance
-```ruby
-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.
-
-```ruby
-CONST_NAME = %<constant>s # "%<example>s"
-%<fixed_string>s
-```
-Available regexes are:
-      `/[[:alnum:]]/`, `/[[:alpha:]]/`, `/[[:blank:]]/`, `/[[:cntrl:]]/`, `/[[:digit:]]/`, `/[[:graph:]]/`, `/[[:lower:]]/`, `/[[:print:]]/`, `/[[:punct:]]/`, `/[[:space:]]/`, `/[[:upper:]]/`, `/[[:xdigit:]]/`, `/[[:word:]]/`, `/[[:ascii:]]/`
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises if somewhere in code used regex which is not moved to const
-```ruby
-
-name = "john"
-puts "hi" if name =~ /john/
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores matching constants
-```ruby
-
-REGEX = /john/
-name = "john"
-puts "hi" if name =~ REGEX
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores named ruby constants
-```ruby
-
-name = "john"
-puts "hi" if name =~ /[[:alpha:]]/
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores dynamic regexs
-```ruby
-
-name = "john"
-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/.
-[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
-```ruby
-
-class ProductsController < ApplicationController
-  def index; end
-  def recalculate; end
-end
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores controllers with private non-REST methods
-```ruby
-
-class ProductsController < ApplicationController
-  def index; end
-
-  private
-
-  def recalculate; end
-end
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores controllers with only REST methods
-```ruby
-
-class ProductsController < ApplicationController
-  def index; end
-  def show; end
-  def new; end
-  def edit; end
-  def create; end
-  def update; end
-  def destroy; end
-end
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores non-controllers with non-REST methods
-```ruby
-
-class PriceStore
-  def index; end
-  def recalculate; end
-end
-
-```
-## Ducalis::RubocopDisable
-
-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
-
-# rubocop:disable Metrics/ParameterLists
-def calculate(five, args, at, one, list); end
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores comment without RuboCop disabling
-```ruby
-
-# 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.
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises for string if argument
-```ruby
-
-before_save :set_full_name, 
- if: 'name_changed? || postfix_name_changed?'
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores lambda if argument
-```ruby
-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.
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises for a class with more than 5 lines
-```ruby
-class TestWorker
-  a = 1
-  a = 2
-  a = 3
-  a = 4
-  a = 5
-  a = 6
-end
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores non-worker classes
-```ruby
-class StrangeClass
-  a = 1
-  a = 2
-  a = 3
-  a = 4
-  a = 5
-  a = 6
-end
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) accepts a class with 5 lines
-```ruby
-class TestWorker
-  a = 1
-  a = 2
-  a = 3
-  a = 4
-  a = 5
-end
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) accepts a class with less than 5 lines
-```ruby
-class TestWorker
-  a = 1
-  a = 2
-  a = 3
-  a = 4
-end
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) accepts empty classes
-```ruby
-class TestWorker
-end
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) also counts commented lines
-```ruby
-class TestWorker
-  a = 1
-  #a = 2
-  a = 3
-  #a = 4
-  a = 5
-  a = 6
-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>).
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises for gem from github without comment
-```ruby
-
-gem 'pry', '~> 0.10', '>= 0.10.0'
-gem 'rake', '~> 12.1'
-gem 'rspec', git: 'https://github.com/rspec/rspec'
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores for gem from github with comment
-```ruby
-
-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?
-
-```ruby
-before_filter :do_something, only: %i[index]
-def index; end
-
-# to
-
-def index
-  do_something
-end
-```
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises for `before_filters` with only one method as array
-```ruby
-
-class ProductsController < ApplicationController
-  before_filter :update_cost, only: [:index]
-
-  def index; end
-
-  private
-
-  def update_cost; end
-end
-
-```
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises for `before_filters` with only one method as keyword array
-```ruby
-
-class ProductsController < ApplicationController
-  before_filter :update_cost, only: %i[index]
-
-  def index; end
-
-  private
-
-  def update_cost; end
-end
-
-```
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises for `before_filters` with many actions and only one method
-```ruby
-
-class ProductsController < ApplicationController
-  before_filter :update_cost, :load_me, only: %i[index]
-
-  def index; end
-
-  private
-
-  def update_cost; end
-  def load_me; end
-end
-
-```
-
-![](https://placehold.it/10/f03c15/000000?text=+) raises for `before_filters` with only one method as argument
-```ruby
-
-class ProductsController < ApplicationController
-  before_filter :update_cost, only: :index
-
-  def index; end
-
-  private
-
-  def update_cost; end
-end
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores `before_filters` without arguments
-```ruby
-
-class ProductsController < ApplicationController
-  before_filter :update_cost
-
-  def index; end
-
-  private
-
-  def update_cost; end
-end
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores `before_filters` with `only` and many arguments
-```ruby
-
-class ProductsController < ApplicationController
-  before_filter :update_cost, only: %i[index show]
-
-  def index; end
-  def show; end
-
-  private
-
-  def update_cost; end
-end
-
-```
-
-![](https://placehold.it/10/2cbe4e/000000?text=+) ignores `before_filters` with `except` and one argument
-```ruby
-
-class ProductsController < ApplicationController
-  before_filter :update_cost, except: %i[index]
-
-  def index; end
-
-  private
-
-  def update_cost; end
-end
-
-```