ducalis 0.5.14 → 0.6.0

data/lib/ducalis/cops/data_access_objects.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+require 'ducalis/cops/extensions/type_resolving'
+
+module Ducalis
+  class DataAccessObjects < RuboCop::Cop::Cop
+    include RuboCop::Cop::DefNode
+    prepend TypeResolving
+
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | It's a good practice to move code related to serialization/deserialization out of the controller. Consider of creating Data Access Object to separate the data access parts from the application logic. It will eliminate problems related to refactoring and testing.
+    MESSAGE
+
+    NODE_EXPRESSIONS = [
+      s(:send, nil, :session),
+      s(:send, nil, :cookies),
+      s(:gvar, :$redis),
+      s(:send, s(:const, nil, :Redis), :current)
+    ].freeze
+
+    def on_send(node)
+      return unless in_controller?
+      return unless NODE_EXPRESSIONS.include?(node.to_a.first)
+      add_offense(node, :expression, OFFENSE)
+    end
+  end
+end

data/lib/ducalis/cops/enforce_namespace.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Ducalis
+  class EnforceNamespace < RuboCop::Cop::Cop
+    prepend TypeResolving
+
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | Too improve code organization it is better to define namespaces to group services by high-level features, domains or any other dimension.
+    MESSAGE
+
+    def on_class(node)
+      return if !node.parent.nil? || !in_service?
+      add_offense(node, :expression, OFFENSE)
+    end
+
+    def on_module(node)
+      return if !node.parent.nil? || !in_service?
+      return if contains_class?(node) || contains_classes?(node)
+      add_offense(node, :expression, OFFENSE)
+    end
+
+    def_node_search :contains_class?, '(module _ ({casgn module class} ...))'
+    def_node_search :contains_classes?,
+                    '(module _ (begin ({casgn module class} ...) ...))'
+  end
+end

data/lib/ducalis/cops/evlis_overusing.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Ducalis
+  class EvlisOverusing < RuboCop::Cop::Cop
+    prepend TypeResolving
+
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | Seems like you are overusing safe navigation operator. Try to use right method (ex: `dig` for hashes), null object pattern or ensure types via explicit conversion (`to_a`, `to_s` and so on).
+    MESSAGE
+
+    DETAILS = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | Related article: https://karolgalanciak.com/blog/2017/09/24/do-or-do-not-there-is-no-try-object-number-try-considered-harmful/
+    MESSAGE
+
+    def on_send(node)
+      return unless nested_try?(node)
+      add_offense(node, :expression, OFFENSE)
+    end
+
+    def on_csend(node)
+      return unless node.child_nodes.any?(&:csend_type?)
+      add_offense(node, :expression, OFFENSE)
+    end
+
+    def_node_search :nested_try?,
+                    '(send (send _ {:try :try!} ...) {:try :try!} ...)'
+  end
+end

data/lib/ducalis/cops/extensions/type_resolving.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+module TypeResolving
+  MODELS_CLASS_NAMES = %w(
+    ApplicationRecord
+    ActiveRecord::Base
+  ).freeze
+
+  WORKERS_SUFFIXES = %w(
+    Worker
+    Job
+  ).freeze
+
+  CONTROLLER_SUFFIXES = %w(
+    Controller
+  ).freeze
+
+  SERVICES_PATH = File.join('app', 'services')
+
+  def on_class(node)
+    classdef_node, superclass, _body = *node
+    @node = node
+    @class_name = classdef_node.loc.expression.source
+    @superclass_name = superclass.loc.expression.source unless superclass.nil?
+    super if defined?(super)
+  end
+
+  def on_module(node)
+    @node = node
+    super if defined?(super)
+  end
+
+  private
+
+  def in_service?
+    path = @node.location.expression.source_buffer.name
+    services_path = cop_config.fetch('ServicePath') { SERVICES_PATH }
+    path.include?(services_path)
+  end
+
+  def in_controller?
+    return false if @superclass_name.nil?
+    @superclass_name.end_with?(*CONTROLLER_SUFFIXES)
+  end
+
+  def in_model?
+    MODELS_CLASS_NAMES.include?(@superclass_name)
+  end
+
+  def in_worker?
+    @class_name.end_with?(*WORKERS_SUFFIXES)
+  end
+end

data/lib/ducalis/cops/fetch_expression.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Ducalis
+  class FetchExpression < RuboCop::Cop::Cop
+    HASH_CALLING_REGEX = /\:\[\]/ # params[:key]
+
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | You can use `fetch` instead:
+
+      | ```ruby
+      | %<source>s
+      | ```
+
+    MESSAGE
+
+    def investigate(processed_source)
+      return unless processed_source.ast
+      matching_nodes(processed_source.ast).each do |node|
+        add_offense(node, :expression, format(OFFENSE,
+                                              source: correct_variant(node)))
+      end
+    end
+
+    private
+
+    def matching_nodes(ast)
+      [
+        *ternar_gets_present(ast).select(&method(:matching_ternar?)),
+        *ternar_gets_nil(ast).select(&method(:matching_ternar?)),
+        *default_gets(ast)
+      ].uniq
+    end
+
+    def_node_search :default_gets, '(or (send (...) :[] (...)) (...))'
+    def_node_search :ternar_gets_present, '(if (...) (send ...) (...))'
+    def_node_search :ternar_gets_nil, '(if (send (...) :nil?) (...) (send ...))'
+
+    def matching_ternar?(node)
+      present_matching?(node) || nil_matching?(node)
+    end
+
+    def present_matching?(node)
+      source, result, = *node
+      (source == result && result.to_s =~ HASH_CALLING_REGEX)
+    end
+
+    def nil_matching?(node)
+      source, _, result = *node
+      (source.to_a.first == result && result.to_s =~ HASH_CALLING_REGEX)
+    end
+
+    def correct_variant(node)
+      if nil_matching?(node)
+        nil_correct(node)
+      else
+        present_correct(node)
+      end
+    end
+
+    def nil_correct(node)
+      hash, _, key = *node.to_a.last.to_a
+      construct_fetch(hash, key, node.to_a[1])
+    end
+
+    def present_correct(node)
+      hash, _, key = *node.to_a.first.to_a
+      construct_fetch(hash, key, node.to_a.last)
+    end
+
+    def construct_fetch(hash, key, default)
+      [source(hash), ".fetch(#{source(key)})", " { #{source(default)} }"].join
+    end
+
+    def source(node)
+      node.loc.expression.source
+    end
+  end
+end

data/lib/ducalis/cops/module_like_class.rb

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

data/lib/ducalis/cops/multiple_times.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Ducalis
+  class MultipleTimes < RuboCop::Cop::Cop
+    include RuboCop::Cop::DefNode
+
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | You should avoid multiple time-related calls to prevent bugs during the period junctions (like Time.now.day called twice in the same scope could return different values if you called it near 23:59:59). You can pass it as default keyword argument or assign to a local variable.
+    MESSAGE
+
+    DETAILS = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | Compare:
+
+      | ```ruby
+      | def period
+      |   Date.today..(Date.today + 1.day)
+      | end
+      | # vs
+      | def period(today: Date.today)
+      |   today..(today + 1.day)
+      | end
+      | ```
+
+    MESSAGE
+
+    PARAMS_CALL = s(:send, nil, :params)
+
+    def on_def(body)
+      multiple = [
+        date_today(body),
+        date_current(body),
+        time_current(body),
+        time_now(body)
+      ].map(&:to_a).compact.flatten.to_a
+      return if multiple.count < 2
+      multiple.each do |time_node|
+        add_offense(time_node, :expression, OFFENSE)
+      end
+    end
+    alias on_defs on_def
+    alias on_send on_def
+
+    def_node_search :date_today, '(send (const nil :Date) :today)'
+    def_node_search :date_current, '(send (const nil :Date) :current)'
+    def_node_search :time_current, '(send (const nil :Time) :current)'
+    def_node_search :time_now, '(send (const nil :Time) :now)'
+  end
+end

data/lib/ducalis/cops/options_argument.rb

@@ -6,7 +6,9 @@ module Ducalis
   class OptionsArgument < RuboCop::Cop::Cop
     OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
       | 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.
+    MESSAGE
 
+    DETAILS = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
       | Compare:
 
       | ```ruby
@@ -31,34 +33,15 @@ module Ducalis
       | 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}]
-
       | ```
-    MESSAGE
 
-    BLACK_LIST = %i(
-      options
-      args
-    ).freeze
+    MESSAGE
 
     def on_def(node)
-      _name, args, _body = *node
-      return unless default_options?(args)
+      return unless options_like_arg?(node)
       add_offense(node, :expression, OFFENSE)
     end
 
-    private
-
-    def_node_search :options_arg?, '(arg #blacklisted?)'
-    def_node_search :options_arg_with_default?, '(optarg #blacklisted? ...)'
-
-    def default_options?(args)
-      args.children.any? do |node|
-        options_arg?(node) || options_arg_with_default?(node)
-      end
-    end
-
-    def blacklisted?(name)
-      BLACK_LIST.include?(name)
-    end
+    def_node_search :options_like_arg?, '(${arg optarg}  ${:options :args} ...)'
   end
 end

data/lib/ducalis/cops/possible_tap.rb

@@ -7,6 +7,10 @@ module Ducalis
     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.
+      |
+    MESSAGE
+
+    DETAILS = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
       | [Related article](<http://seejohncode.com/2012/01/02/ruby-tap-that/>).
     MESSAGE
 

data/lib/ducalis/cops/preferable_methods.rb

@@ -7,11 +7,13 @@ module Ducalis
       | Prefer to use %<alternative>s method instead of %<original>s because of %<reason>s.
     MESSAGE
 
+    WHITE_LIST = %w(cache file params attrs options).freeze
+
     ALWAYS_TRUE = ->(_who, _what, _args) { true }
 
     DELETE_CHECK = lambda do |who, _what, args|
       !%i(sym str).include?(args.first && args.first.type) &&
-        args.count <= 1 && who.to_s !~ /file/
+        args.count <= 1 && !WHITE_LIST.any? { |regex| who.to_s.include?(regex) }
     end
 
     VALIDATE_CHECK = lambda do |_who, _what, args|

data/lib/ducalis/cops/private_instance_assign.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
 require 'rubocop'
+require 'ducalis/cops/extensions/type_resolving'
 
 module Ducalis
   class PrivateInstanceAssign < RuboCop::Cop::Cop
     include RuboCop::Cop::DefNode
+    prepend TypeResolving
+
     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
@@ -15,14 +18,8 @@ module Ducalis
 
     DETAILS = ADD_OFFENSE
 
-    def on_class(node)
-      _classdef_node, superclass, _body = *node
-      return if superclass.nil?
-      @triggered = superclass.loc.expression.source =~ /Controller/
-    end
-
     def on_ivasgn(node)
-      return unless triggered
+      return unless in_controller?
       return unless non_public?(node)
       return check_memo(node) if node.parent.type == :or_asgn
       add_offense(node, :expression, OFFENSE)
@@ -34,7 +31,5 @@ module Ducalis
       return if node.to_a.first.to_s.start_with?('@_')
       add_offense(node, :expression, [OFFENSE, ADD_OFFENSE].join(' '))
     end
-
-    attr_reader :triggered
   end
 end

data/lib/ducalis/cops/protected_scope_cop.rb

@@ -6,6 +6,9 @@ module Ducalis
   class ProtectedScopeCop < RuboCop::Cop::Cop
     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.
+    MESSAGE
+
+    DETAILS = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
       | Example:
 
       | ```ruby
@@ -13,6 +16,7 @@ module Ducalis
       | # better then
       | Employee.find(params[:id])
       | ```
+
     MESSAGE
 
     def on_send(node)

data/lib/ducalis/cops/public_send.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Ducalis
+  class PublicSend < RuboCop::Cop::Cop
+    OFFENSE = <<-MESSAGE.gsub(/^ +\|\s/, '').strip
+      | You should avoid of using `send`-like method in production code. You can rewrite it as a hash with lambdas and fetch necessary actions or rewrite it as a module which you can include in code.
+    MESSAGE
+
+    def on_send(node)
+      return unless send_call?(node)
+      add_offense(node, :expression, OFFENSE)
+    end
+
+    def_node_matcher :send_call?, '(send _ ${:send :public_send :__send__} ...)'
+  end
+end

data/lib/ducalis/cops/regex_cop.rb

@@ -5,13 +5,18 @@ require 'regexp-examples'
 
 module Ducalis
   class RegexCop < RuboCop::Cop::Cop
+    include RuboCop::Cop::DefNode
+
     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.
 
+      | Example:
+
       | ```ruby
       | CONST_NAME = %<constant>s # "%<example>s"
       | %<fixed_string>s
       | ```
+
     MESSAGE
 
     SELF_DESCRIPTIVE = %w(
@@ -34,22 +39,47 @@ module Ducalis
     DETAILS = "Available regexes are:
       #{SELF_DESCRIPTIVE.map { |name| "`#{name}`" }.join(', ')}"
 
-    def on_regexp(node)
-      return if node.parent.type == :casgn
-      return if SELF_DESCRIPTIVE.include?(node.source)
-      return if node.child_nodes.any? { |child_node| child_node.type == :begin }
-      add_offense(node, :expression, format(OFFENSE, present_node(node)))
+    DEFAULT_EXAMPLE = 'some_example'
+
+    def on_begin(node)
+      not_defined_regexes(node).each do |regex|
+        next if SELF_DESCRIPTIVE.include?(regex.source) || const_dynamic?(regex)
+        add_offense(regex, :expression, format(OFFENSE, present_node(regex)))
+      end
     end
 
     private
 
+    def_node_search :const_using, '(regexp $_ ... (regopt))'
+    def_node_search :const_definition, '(casgn ...)'
+
+    def not_defined_regexes(node)
+      const_using(node).reject do |regex|
+        defined_as_const?(regex, const_definition(node))
+      end.map(&:parent)
+    end
+
+    def defined_as_const?(regex, definitions)
+      definitions.any? { |node| const_using(node).any? { |use| use == regex } }
+    end
+
+    def const_dynamic?(node)
+      node.child_nodes.any?(&:begin_type?)
+    end
+
     def present_node(node)
       {
         constant: node.source,
         fixed_string: node.source_range.source_line
                           .sub(node.source, 'CONST_NAME').lstrip,
-        example: Regexp.new(node.to_a.first.to_a.first).examples.sample
+        example: regex_sample(node)
       }
     end
+
+    def regex_sample(node)
+      Regexp.new(node.to_a.first.to_a.first).examples.sample
+    rescue RegexpExamples::IllegalSyntaxError
+      DEFAULT_EXAMPLE
+    end
   end
 end