rubbycop 0.49.0

data/lib/rubbycop/cop/style/constant_name.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks whether constant names are written using
+      # SCREAMING_SNAKE_CASE.
+      #
+      # To avoid false positives, it ignores cases in which we cannot know
+      # for certain the type of value that would be assigned to a constant.
+      class ConstantName < Cop
+        MSG = 'Use SCREAMING_SNAKE_CASE for constants.'.freeze
+        SNAKE_CASE = /^[\dA-Z_]+$/
+
+        def on_casgn(node)
+          _scope, const_name, value = *node
+
+          # We cannot know the result of method calls like
+          # NewClass = something_that_returns_a_class
+          # It's also ok to assign a class constant another class constant
+          # SomeClass = SomeOtherClass
+          return if value && %i[send block const].include?(value.type)
+
+          add_offense(node, :name) if const_name !~ SNAKE_CASE
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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 RubbyCop scans, a comment that matches this regex must be found or
+      # an offense is reported.
+      #
+      class Copyright < Cop
+        AUTOCORRECT_EMPTY_WARNING = 'An AutocorrectNotice must be defined in' \
+                                    'your RubbyCop config'.freeze
+
+        def message
+          "Include a copyright notice matching /#{notice}/" \
+          'before any code.'
+        end
+
+        def notice
+          cop_config['Notice']
+        end
+
+        def autocorrect_notice
+          cop_config['AutocorrectNotice']
+        end
+
+        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), range, message)
+        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.type == :tCOMMENT && 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.type == :tCOMMENT &&
+            token.text =~ /^#.*coding\s?[:=]\s?(?:UTF|utf)-8/
+        end
+
+        def notice_found?(processed_source)
+          notice_found = false
+          notice_regexp = Regexp.new(notice)
+          processed_source.tokens.each do |token|
+            break unless token.type == :tCOMMENT
+            notice_found = !(token.text =~ notice_regexp).nil?
+            break if notice_found
+          end
+          notice_found
+        end
+
+        def autocorrect(token)
+          raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?
+          regex = Regexp.new(notice)
+          unless autocorrect_notice =~ regex
+            raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must " \
+                           "match Notice /#{notice}/"
+          end
+
+          lambda do |corrector|
+            range = token.nil? ? range_between(0, 0) : token.pos
+            corrector.insert_before(range, "#{autocorrect_notice}\n")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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.
+      class DefWithParentheses < Cop
+        include OnMethodDef
+
+        MSG = "Omit the parentheses in defs when the method doesn't accept " \
+              'any arguments.'.freeze
+
+        def on_method_def(node, _method_name, args, _body)
+          return if node.single_line?
+          return unless args.children.empty? && args.loc.begin
+
+          add_offense(args, :begin)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(node.loc.begin)
+            corrector.remove(node.loc.end)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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, or constant definitions.
+      #
+      # 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.
+      class Documentation < Cop
+        include DocumentationComment
+
+        MSG = 'Missing top-level %s documentation comment.'.freeze
+
+        def_node_matcher :constant_definition?, '{class module casgn}'
+
+        def on_class(node)
+          _, _, body = *node
+
+          return unless body
+
+          check(node, body, :class)
+        end
+
+        def on_module(node)
+          _, body = *node
+
+          check(node, body, :module)
+        end
+
+        private
+
+        def check(node, body, type)
+          return if namespace?(body)
+          return if documentation_comment?(node) || nodoc_comment?(node)
+
+          add_offense(node, :keyword, format(MSG, type))
+        end
+
+        def namespace?(node)
+          return false unless node
+
+          if node.begin_type?
+            node.children.all? { |child| constant_definition?(child) }
+          else
+            constant_definition?(node)
+          end
+        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 && 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)
+          comment.text =~ /^#\s*:nodoc:#{"\s+all\s*$" if require_all}/
+        end
+
+        def nodoc(node)
+          processed_source.ast_with_comments[node.children.first].first
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/style/documentation_method.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for missing documentation comment for public methods.
+      # It can optionally be configured to also require documentation for
+      # non-public methods.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   class Foo
+      #     def bar
+      #       puts baz
+      #     end
+      #   end
+      #
+      #   module Foo
+      #     def bar
+      #       puts baz
+      #     end
+      #   end
+      #
+      #   def foo.bar
+      #     puts baz
+      #   end
+      #
+      #   # good
+      #
+      #   class Foo
+      #     # Documentation
+      #     def bar
+      #       puts baz
+      #     end
+      #   end
+      #
+      #   module Foo
+      #     # Documentation
+      #     def bar
+      #       puts baz
+      #     end
+      #   end
+      #
+      #   # Documentation
+      #   def foo.bar
+      #     puts baz
+      #   end
+      class DocumentationMethod < Cop
+        include DocumentationComment
+        include OnMethodDef
+        include DefNode
+
+        MSG = 'Missing method documentation comment.'.freeze
+
+        def on_def(node)
+          check(node)
+        end
+
+        def on_method_def(node, *)
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          return if non_public?(node) && !require_for_non_public_methods?
+          return if documentation_comment?(node)
+
+          add_offense(node, :expression, MSG)
+        end
+
+        def require_for_non_public_methods?
+          cop_config['RequireForNonPublicMethods']
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/style/double_negation.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for uses of double negation (!!) to convert something
+      # to a boolean value. As this is both cryptic and usually redundant, it
+      # should be avoided.
+      #
+      # @example
+      #
+      #   # bad
+      #   !!something
+      #
+      #   # good
+      #   !something.nil?
+      #
+      # Please, note that when something is a boolean value
+      # !!something and !something.nil? are not the same thing.
+      # As you're unlikely to write code that can accept values of any type
+      # this is rarely a problem in practice.
+      class DoubleNegation < Cop
+        MSG = 'Avoid the use of double negation (`!!`).'.freeze
+
+        def_node_matcher :double_negative?, '(send (send _ :!) :!)'
+
+        def on_send(node)
+          return unless double_negative?(node) && node.keyword_bang?
+
+          add_offense(node, :selector)
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/style/each_for_simple_loop.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for loops which iterate a constant number of times,
+      # using a Range literal and `#each`. This can be done more readably using
+      # `Integer#times`.
+      #
+      # This check only applies if the block takes no parameters.
+      #
+      # @example
+      #   @bad
+      #   (1..5).each { }
+      #
+      #   @good
+      #   5.times { }
+      #
+      # @example
+      #   @bad
+      #   (0...10).each {}
+      #
+      #   @good
+      #   10.times {}
+      class EachForSimpleLoop < Cop
+        MSG = 'Use `Integer#times` for a simple loop which iterates a fixed ' \
+              'number of times.'.freeze
+
+        def on_block(node)
+          return unless offending_each_range(node)
+
+          send_node, = *node
+          range = send_node.receiver.source_range.join(send_node.loc.selector)
+
+          add_offense(node, range)
+        end
+
+        private
+
+        def autocorrect(node)
+          lambda do |corrector|
+            range_type, min, max = offending_each_range(node)
+
+            max += 1 if range_type == :irange
+
+            corrector.replace(node.children.first.source_range,
+                              "#{max - min}.times")
+          end
+        end
+
+        def_node_matcher :offending_each_range, <<-PATTERN
+          (block (send (begin (${irange erange} (int $_) (int $_))) :each) (args) ...)
+        PATTERN
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/style/each_with_object.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop looks for inject / reduce calls where the passed in object is
+      # returned at the end and so could be replaced by each_with_object without
+      # the need to return the object at the end.
+      #
+      # However, we can't replace with each_with_object if the accumulator
+      # parameter is assigned to within the block.
+      #
+      # @example
+      #   # bad
+      #   [1, 2].inject({}) { |a, e| a[e] = e; a }
+      #
+      #   # good
+      #   [1, 2].each_with_object({}) { |e, a| a[e] = e }
+      class EachWithObject < Cop
+        MSG = 'Use `each_with_object` instead of `%s`.'.freeze
+        METHODS = %i[inject reduce].freeze
+
+        def_node_matcher :each_with_object_candidate?, <<-PATTERN
+          (block $(send _ {:inject :reduce} _) $_ $_)
+        PATTERN
+
+        def on_block(node)
+          each_with_object_candidate?(node) do |method, args, body|
+            _, method_name, method_arg = *method
+            return if simple_method_arg?(method_arg)
+
+            return_value = return_value(body)
+            return unless return_value
+            return unless first_argument_returned?(args, return_value)
+            return if accumulator_param_assigned_to?(body, args)
+
+            add_offense(node, method.loc.selector, format(MSG, method_name))
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            method, args, body = *node
+            corrector.replace(method.loc.selector, 'each_with_object')
+            first_arg, second_arg = *args
+            corrector.replace(first_arg.loc.expression, second_arg.source)
+            corrector.replace(second_arg.loc.expression, first_arg.source)
+
+            return_value = return_value(body)
+            corrector.remove(return_value.loc.expression)
+          end
+        end
+
+        private
+
+        def simple_method_arg?(method_arg)
+          method_arg && method_arg.basic_literal?
+        end
+
+        # if the accumulator parameter is assigned to in the block,
+        # then we can't convert to each_with_object
+        def accumulator_param_assigned_to?(body, args)
+          first_arg, = *args
+          accumulator_var, = *first_arg
+
+          body.each_descendant.any? do |n|
+            next unless n.assignment?
+
+            lhs, _rhs = *n
+            lhs.equal?(accumulator_var)
+          end
+        end
+
+        def return_value(body)
+          return unless body
+
+          return_value = body.begin_type? ? body.children.last : body
+          return_value if return_value && return_value.lvar_type?
+        end
+
+        def first_argument_returned?(args, return_value)
+          first_arg, = *args
+          accumulator_var, = *first_arg
+          return_var, = *return_value
+
+          accumulator_var == return_var
+        end
+      end
+    end
+  end
+end