rubocop 0.87.1

data/lib/rubocop/cop/style/constant_visibility.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks that constants defined in classes and modules have
+      # an explicit visibility declaration. By default, Ruby makes all class-
+      # and module constants public, which litters the public API of the
+      # class or module. Explicitly declaring a visibility makes intent more
+      # clear, and prevents outside actors from touching private state.
+      #
+      # @example
+      #
+      #   # bad
+      #   class Foo
+      #     BAR = 42
+      #     BAZ = 43
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     BAR = 42
+      #     private_constant :BAR
+      #
+      #     BAZ = 43
+      #     public_constant :BAZ
+      #   end
+      #
+      class ConstantVisibility < Cop
+        MSG = 'Explicitly make `%<constant_name>s` public or private using ' \
+              'either `#public_constant` or `#private_constant`.'
+
+        def on_casgn(node)
+          return unless class_or_module_scope?(node)
+          return if visibility_declaration?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def message(node)
+          _namespace, constant_name, _value = *node
+
+          format(MSG, constant_name: constant_name)
+        end
+
+        def class_or_module_scope?(node)
+          return false unless node.parent
+
+          case node.parent.type
+          when :begin
+            class_or_module_scope?(node.parent)
+          when :class, :module
+            true
+          end
+        end
+
+        def visibility_declaration?(node)
+          _namespace, constant_name, _value = *node
+
+          node.parent.each_child_node(:send).any? do |child|
+            visibility_declaration_for?(child, constant_name)
+          end
+        end
+
+        def_node_matcher :visibility_declaration_for?, <<~PATTERN
+          (send nil? {:public_constant :private_constant} ({sym str} #match_name?(%1)))
+        PATTERN
+
+        def match_name?(name, constant_name)
+          name.to_sym == constant_name.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/copyright.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Check that a copyright notice was given in each source file.
+      #
+      # The default regexp for an acceptable copyright notice can be found in
+      # config/default.yml. The default can be changed as follows:
+      #
+      #  Style/Copyright:
+      #    Notice: '^Copyright (\(c\) )?2\d{3} Acme Inc'
+      #
+      # This regex string is treated as an unanchored regex. For each file
+      # that RuboCop scans, a comment that matches this regex must be found or
+      # an offense is reported.
+      #
+      class Copyright < Cop
+        include RangeHelp
+
+        MSG = 'Include a copyright notice matching /%<notice>s/ before ' \
+              'any code.'
+        AUTOCORRECT_EMPTY_WARNING = 'An AutocorrectNotice must be defined in ' \
+                                    'your RuboCop config'
+
+        def investigate(processed_source)
+          return if notice.empty?
+          return if notice_found?(processed_source)
+
+          range = source_range(processed_source.buffer, 1, 0)
+          add_offense(insert_notice_before(processed_source),
+                      location: range, message: format(MSG, notice: notice))
+        end
+
+        def autocorrect(token)
+          verify_autocorrect_notice!
+
+          lambda do |corrector|
+            range = token.nil? ? range_between(0, 0) : token.pos
+            corrector.insert_before(range, "#{autocorrect_notice}\n")
+          end
+        end
+
+        private
+
+        def notice
+          cop_config['Notice']
+        end
+
+        def autocorrect_notice
+          cop_config['AutocorrectNotice']
+        end
+
+        def verify_autocorrect_notice!
+          raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?
+
+          regex = Regexp.new(notice)
+          return if autocorrect_notice&.match?(regex)
+
+          raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must " \
+                         "match Notice /#{notice}/"
+        end
+
+        def insert_notice_before(processed_source)
+          token_index = 0
+          token_index += 1 if shebang_token?(processed_source, token_index)
+          token_index += 1 if encoding_token?(processed_source, token_index)
+          processed_source.tokens[token_index]
+        end
+
+        def shebang_token?(processed_source, token_index)
+          return false if token_index >= processed_source.tokens.size
+
+          token = processed_source.tokens[token_index]
+          token.comment? && /^#!.*$/.match?(token.text)
+        end
+
+        def encoding_token?(processed_source, token_index)
+          return false if token_index >= processed_source.tokens.size
+
+          token = processed_source.tokens[token_index]
+          token.comment? && /^#.*coding\s?[:=]\s?(?:UTF|utf)-8/.match?(token.text)
+        end
+
+        def notice_found?(processed_source)
+          notice_found = false
+          notice_regexp = Regexp.new(notice)
+          processed_source.each_token do |token|
+            break unless token.comment?
+
+            notice_found = notice_regexp.match?(token.text)
+            break if notice_found
+          end
+          notice_found
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/date_time.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for consistent usage of the `DateTime` class over the
+      # `Time` class. This cop is disabled by default since these classes,
+      # although highly overlapping, have particularities that make them not
+      # replaceable in certain situations when dealing with multiple timezones
+      # and/or DST.
+      #
+      # @example
+      #
+      #   # bad - uses `DateTime` for current time
+      #   DateTime.now
+      #
+      #   # good - uses `Time` for current time
+      #   Time.now
+      #
+      #   # bad - uses `DateTime` for modern date
+      #   DateTime.iso8601('2016-06-29')
+      #
+      #   # good - uses `Time` for modern date
+      #   Time.iso8601('2016-06-29')
+      #
+      #   # good - uses `DateTime` with start argument for historical date
+      #   DateTime.iso8601('1751-04-23', Date::ENGLAND)
+      #
+      # @example AllowCoercion: false (default)
+      #
+      #   # bad - coerces to `DateTime`
+      #   something.to_datetime
+      #
+      #   # good - coerces to `Time`
+      #   something.to_time
+      #
+      # @example AllowCoercion: true
+      #
+      #   # good
+      #   something.to_datetime
+      #
+      #   # good
+      #   something.to_time
+      class DateTime < Cop
+        CLASS_MSG = 'Prefer Time over DateTime.'
+        COERCION_MSG = 'Do not use #to_datetime.'
+
+        def_node_matcher :date_time?, <<~PATTERN
+          (send (const {nil? (cbase)} :DateTime) ...)
+        PATTERN
+
+        def_node_matcher :historic_date?, <<~PATTERN
+          (send _ _ _ (const (const {nil? (cbase)} :Date) _))
+        PATTERN
+
+        def_node_matcher :to_datetime?, <<~PATTERN
+          (send _ :to_datetime)
+        PATTERN
+
+        def on_send(node)
+          return unless date_time?(node) ||
+                        (to_datetime?(node) && disallow_coercion?)
+          return if historic_date?(node)
+
+          message = to_datetime?(node) ? COERCION_MSG : CLASS_MSG
+          add_offense(node, message: message)
+        end
+
+        private
+
+        def disallow_coercion?
+          !cop_config['AllowCoercion']
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/def_with_parentheses.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for parentheses in the definition of a method,
+      # that does not take any arguments. Both instance and
+      # class/singleton methods are checked.
+      #
+      # @example
+      #
+      #   # bad
+      #   def foo()
+      #     # does a thing
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     # does a thing
+      #   end
+      #
+      #   # also good
+      #   def foo() does_a_thing end
+      #
+      # @example
+      #
+      #   # bad
+      #   def Baz.foo()
+      #     # does a thing
+      #   end
+      #
+      #   # good
+      #   def Baz.foo
+      #     # does a thing
+      #   end
+      class DefWithParentheses < Cop
+        MSG = "Omit the parentheses in defs when the method doesn't accept " \
+              'any arguments.'
+
+        def on_def(node)
+          return if node.single_line?
+          return unless !node.arguments? && node.arguments.loc.begin
+
+          add_offense(node.arguments, location: :begin)
+        end
+        alias on_defs on_def
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(node.loc.begin)
+            corrector.remove(node.loc.end)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/dir.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where the `#__dir__` method can replace more
+      # complex constructs to retrieve a canonicalized absolute path to the
+      # current file.
+      #
+      # @example
+      #   # bad
+      #   path = File.expand_path(File.dirname(__FILE__))
+      #
+      #   # bad
+      #   path = File.dirname(File.realpath(__FILE__))
+      #
+      #   # good
+      #   path = __dir__
+      class Dir < Cop
+        MSG = 'Use `__dir__` to get an absolute path to the current ' \
+              "file's directory."
+
+        def_node_matcher :dir_replacement?, <<~PATTERN
+          {(send (const {nil? cbase} :File) :expand_path (send (const {nil? cbase} :File) :dirname  #file_keyword?))
+           (send (const {nil? cbase} :File) :dirname     (send (const {nil? cbase} :File) :realpath #file_keyword?))}
+        PATTERN
+
+        def on_send(node)
+          dir_replacement?(node) do
+            add_offense(node)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, '__dir__')
+          end
+        end
+
+        private
+
+        def file_keyword?(node)
+          node.str_type? && node.source_range.is?('__FILE__')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/RedundantCopDisableDirective
+
+module RuboCop
+  module Cop
+    module Style
+      # Detects comments to enable/disable RuboCop.
+      # This is useful if want to make sure that every RuboCop error gets fixed
+      # and not quickly disabled with a comment.
+      #
+      # @example
+      #   # bad
+      #   # rubocop:disable Metrics/AbcSize
+      #   def f
+      #   end
+      #   # rubocop:enable Metrics/AbcSize
+      #
+      #   # good
+      #   def fixed_method_name_and_no_rubocop_comments
+      #   end
+      #
+      class DisableCopsWithinSourceCodeDirective < Cop
+        # rubocop:enable Lint/RedundantCopDisableDirective
+        MSG = 'Comment to disable/enable RuboCop.'
+
+        def investigate(processed_source)
+          processed_source.comments.each do |comment|
+            next unless rubocop_directive_comment?(comment)
+
+            add_offense(comment)
+          end
+        end
+
+        def autocorrect(comment)
+          lambda do |corrector|
+            corrector.replace(comment, '')
+          end
+        end
+
+        private
+
+        def rubocop_directive_comment?(comment)
+          CommentConfig::COMMENT_DIRECTIVE_REGEXP.match?(comment.text)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/documentation.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for missing top-level documentation of classes and
+      # modules. Classes with no body are exempt from the check and so are
+      # namespace modules - modules that have nothing in their bodies except
+      # classes, other modules, constant definitions or constant visibility
+      # declarations.
+      #
+      # The documentation requirement is annulled if the class or module has
+      # a "#:nodoc:" comment next to it. Likewise, "#:nodoc: all" does the
+      # same for all its children.
+      #
+      # @example
+      #   # bad
+      #   class Person
+      #     # ...
+      #   end
+      #
+      #   module Math
+      #   end
+      #
+      #   # good
+      #   # Description/Explanation of Person class
+      #   class Person
+      #     # ...
+      #   end
+      #
+      #   # allowed
+      #     # Class without body
+      #     class Person
+      #     end
+      #
+      #     # Namespace - A namespace can be a class or a module
+      #     # Containing a class
+      #     module Namespace
+      #       # Description/Explanation of Person class
+      #       class Person
+      #         # ...
+      #       end
+      #     end
+      #
+      #     # Containing constant visibility declaration
+      #     module Namespace
+      #       class Private
+      #       end
+      #
+      #       private_constant :Private
+      #     end
+      #
+      #     # Containing constant definition
+      #     module Namespace
+      #       Public = Class.new
+      #     end
+      #
+      class Documentation < Cop
+        include DocumentationComment
+
+        MSG = 'Missing top-level %<type>s documentation comment.'
+
+        def_node_matcher :constant_definition?, '{class module casgn}'
+        def_node_search :outer_module, '(const (const nil? _) _)'
+        def_node_matcher :constant_visibility_declaration?, <<~PATTERN
+          (send nil? {:public_constant :private_constant} ({sym str} _))
+        PATTERN
+
+        def on_class(node)
+          return unless node.body
+
+          check(node, node.body, :class)
+        end
+
+        def on_module(node)
+          check(node, node.body, :module)
+        end
+
+        private
+
+        def check(node, body, type)
+          return if namespace?(body)
+          return if documentation_comment?(node) || nodoc_comment?(node)
+          return if compact_namespace?(node) &&
+                    nodoc_comment?(outer_module(node).first)
+
+          add_offense(node,
+                      location: :keyword,
+                      message: format(MSG, type: type))
+        end
+
+        def namespace?(node)
+          return false unless node
+
+          if node.begin_type?
+            node.children.all?(&method(:constant_declaration?))
+          else
+            constant_definition?(node)
+          end
+        end
+
+        def constant_declaration?(node)
+          constant_definition?(node) || constant_visibility_declaration?(node)
+        end
+
+        def compact_namespace?(node)
+          /::/.match?(node.loc.name.source)
+        end
+
+        # First checks if the :nodoc: comment is associated with the
+        # class/module. Unless the element is tagged with :nodoc:, the search
+        # proceeds to check its ancestors for :nodoc: all.
+        # Note: How end-of-line comments are associated with code changed in
+        # parser-2.2.0.4.
+        def nodoc_comment?(node, require_all = false)
+          return false unless node&.children&.first
+
+          nodoc = nodoc(node)
+
+          return true if same_line?(nodoc, node) && nodoc?(nodoc, require_all)
+
+          nodoc_comment?(node.parent, true)
+        end
+
+        def nodoc?(comment, require_all = false)
+          /^#\s*:nodoc:#{"\s+all\s*$" if require_all}/.match?(comment.text)
+        end
+
+        def nodoc(node)
+          processed_source.ast_with_comments[node.children.first].first
+        end
+      end
+    end
+  end
+end