rubocop 0.87.1

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of consistent method names
+      # from the Enumerable module.
+      #
+      # Unfortunately we cannot actually know if a method is from
+      # Enumerable or not (static analysis limitation), so this cop
+      # can yield some false positives.
+      #
+      # You can customize the mapping from undesired method to desired method.
+      #
+      # e.g. to use `detect` over `find`:
+      #
+      #   Style/CollectionMethods:
+      #     PreferredMethods:
+      #       find: detect
+      #
+      # The default mapping for `PreferredMethods` behaves as follows.
+      #
+      # @example
+      #   # bad
+      #   items.collect
+      #   items.collect!
+      #   items.inject
+      #   items.detect
+      #   items.find_all
+      #   items.member?
+      #
+      #   # good
+      #   items.map
+      #   items.map!
+      #   items.reduce
+      #   items.find
+      #   items.select
+      #   items.include?
+      #
+      class CollectionMethods < Cop
+        include MethodPreference
+
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
+
+        def on_block(node)
+          check_method_node(node.send_node)
+        end
+
+        def on_send(node)
+          return unless node.arguments.one? &&
+                        node.first_argument.block_pass_type?
+
+          check_method_node(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.selector,
+                              preferred_method(node.loc.selector.source))
+          end
+        end
+
+        private
+
+        def message(node)
+          format(MSG,
+                 prefer: preferred_method(node.method_name),
+                 current: node.method_name)
+        end
+
+        def check_method_node(node)
+          return unless preferred_methods[node.method_name]
+
+          add_offense(node, location: :selector)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for methods invoked via the :: operator instead
+      # of the . operator (like FileUtils::rmdir instead of FileUtils.rmdir).
+      #
+      # @example
+      #   # bad
+      #   Timeout::timeout(500) { do_something }
+      #   FileUtils::rmdir(dir)
+      #   Marshal::dump(obj)
+      #
+      #   # good
+      #   Timeout.timeout(500) { do_something }
+      #   FileUtils.rmdir(dir)
+      #   Marshal.dump(obj)
+      #
+      class ColonMethodCall < Cop
+        MSG = 'Do not use `::` for method calls.'
+
+        def_node_matcher :java_type_node?, <<~PATTERN
+          (send
+            (const nil? :Java) _)
+        PATTERN
+
+        def self.autocorrect_incompatible_with
+          [RedundantSelf]
+        end
+
+        def on_send(node)
+          # ignore Java interop code like Java::int
+          return if java_type_node?(node)
+
+          return unless node.receiver && node.double_colon?
+          return if node.camel_case_method?
+
+          add_offense(node, location: :dot)
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node.loc.dot, '.') }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for class methods that are defined using the `::`
+      # operator instead of the `.` operator.
+      #
+      # @example
+      #   # bad
+      #   class Foo
+      #     def self::bar
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def self.bar
+      #     end
+      #   end
+      #
+      class ColonMethodDefinition < Cop
+        MSG = 'Do not use `::` for defining class methods.'
+
+        def on_defs(node)
+          return unless node.loc.operator.source == '::'
+
+          add_offense(node, location: :operator)
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node.loc.operator, '.') }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces using `` or %x around command literals.
+      #
+      # @example EnforcedStyle: backticks (default)
+      #   # bad
+      #   folders = %x(find . -type d).split
+      #
+      #   # bad
+      #   %x(
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   )
+      #
+      #   # good
+      #   folders = `find . -type d`.split
+      #
+      #   # good
+      #   `
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   `
+      #
+      # @example EnforcedStyle: mixed
+      #   # bad
+      #   folders = %x(find . -type d).split
+      #
+      #   # bad
+      #   `
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   `
+      #
+      #   # good
+      #   folders = `find . -type d`.split
+      #
+      #   # good
+      #   %x(
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   )
+      #
+      # @example EnforcedStyle: percent_x
+      #   # bad
+      #   folders = `find . -type d`.split
+      #
+      #   # bad
+      #   `
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   `
+      #
+      #   # good
+      #   folders = %x(find . -type d).split
+      #
+      #   # good
+      #   %x(
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   )
+      #
+      # @example AllowInnerBackticks: false (default)
+      #   # If `false`, the cop will always recommend using `%x` if one or more
+      #   # backticks are found in the command string.
+      #
+      #   # bad
+      #   `echo \`ls\``
+      #
+      #   # good
+      #   %x(echo `ls`)
+      #
+      # @example AllowInnerBackticks: true
+      #   # good
+      #   `echo \`ls\``
+      class CommandLiteral < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG_USE_BACKTICKS = 'Use backticks around command string.'
+        MSG_USE_PERCENT_X = 'Use `%x` around command string.'
+
+        def on_xstr(node)
+          return if node.heredoc?
+
+          if backtick_literal?(node)
+            check_backtick_literal(node)
+          else
+            check_percent_x_literal(node)
+          end
+        end
+
+        def autocorrect(node)
+          return if contains_backtick?(node)
+
+          replacement = if backtick_literal?(node)
+                          ['%x', ''].zip(preferred_delimiter).map(&:join)
+                        else
+                          %w[` `]
+                        end
+
+          lambda do |corrector|
+            corrector.replace(node.loc.begin, replacement.first)
+            corrector.replace(node.loc.end, replacement.last)
+          end
+        end
+
+        private
+
+        def check_backtick_literal(node)
+          return if allowed_backtick_literal?(node)
+
+          add_offense(node)
+        end
+
+        def check_percent_x_literal(node)
+          return if allowed_percent_x_literal?(node)
+
+          add_offense(node)
+        end
+
+        def message(node)
+          backtick_literal?(node) ? MSG_USE_PERCENT_X : MSG_USE_BACKTICKS
+        end
+
+        def allowed_backtick_literal?(node)
+          case style
+          when :backticks
+            !contains_disallowed_backtick?(node)
+          when :mixed
+            node.single_line? && !contains_disallowed_backtick?(node)
+          end
+        end
+
+        def allowed_percent_x_literal?(node)
+          case style
+          when :backticks
+            contains_disallowed_backtick?(node)
+          when :mixed
+            node.multiline? || contains_disallowed_backtick?(node)
+          when :percent_x
+            true
+          end
+        end
+
+        def contains_disallowed_backtick?(node)
+          !allow_inner_backticks? && contains_backtick?(node)
+        end
+
+        def allow_inner_backticks?
+          cop_config['AllowInnerBackticks']
+        end
+
+        def contains_backtick?(node)
+          /`/.match?(node_body(node))
+        end
+
+        def node_body(node)
+          loc = node.loc
+          loc.expression.source[loc.begin.length...-loc.end.length]
+        end
+
+        def backtick_literal?(node)
+          node.loc.begin.source == '`'
+        end
+
+        def preferred_delimiter
+          (command_delimiter || default_delimiter).split(//)
+        end
+
+        def command_delimiter
+          preferred_delimiters_config['%x']
+        end
+
+        def default_delimiter
+          preferred_delimiters_config['default']
+        end
+
+        def preferred_delimiters_config
+          config.for_cop('Style/PercentLiteralDelimiters') \
+            ['PreferredDelimiters']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks that comment annotation keywords are written according
+      # to guidelines.
+      #
+      # @example
+      #   # bad
+      #   # TODO make better
+      #
+      #   # good
+      #   # TODO: make better
+      #
+      #   # bad
+      #   # TODO:make better
+      #
+      #   # good
+      #   # TODO: make better
+      #
+      #   # bad
+      #   # fixme: does not work
+      #
+      #   # good
+      #   # FIXME: does not work
+      #
+      #   # bad
+      #   # Optimize does not work
+      #
+      #   # good
+      #   # OPTIMIZE: does not work
+      class CommentAnnotation < Cop
+        include AnnotationComment
+        include RangeHelp
+
+        MSG = 'Annotation keywords like `%<keyword>s` should be all ' \
+              'upper case, followed by a colon, and a space, ' \
+              'then a note describing the problem.'
+        MISSING_NOTE = 'Annotation comment, with keyword `%<keyword>s`, ' \
+                       'is missing a note.'
+
+        def investigate(processed_source)
+          processed_source.comments.each_with_index do |comment, index|
+            next unless first_comment_line?(processed_source.comments, index) ||
+                        inline_comment?(comment)
+
+            margin, first_word, colon, space, note = split_comment(comment)
+            next unless annotation?(comment) &&
+                        !correct_annotation?(first_word, colon, space, note)
+
+            add_offense(
+              comment,
+              location: annotation_range(comment, margin,
+                                         first_word, colon, space),
+              message: format(note ? MSG : MISSING_NOTE, keyword: first_word)
+            )
+          end
+        end
+
+        def autocorrect(comment)
+          margin, first_word, colon, space, note = split_comment(comment)
+          return if note.nil?
+
+          range = annotation_range(comment, margin, first_word, colon, space)
+
+          ->(corrector) { corrector.replace(range, "#{first_word.upcase}: ") }
+        end
+
+        private
+
+        def first_comment_line?(comments, index)
+          index.zero? ||
+            comments[index - 1].loc.line < comments[index].loc.line - 1
+        end
+
+        def inline_comment?(comment)
+          !comment_line?(comment.loc.expression.source_line)
+        end
+
+        def annotation_range(comment, margin, first_word, colon, space)
+          start = comment.loc.expression.begin_pos + margin.length
+          length = concat_length(first_word, colon, space)
+          range_between(start, start + length)
+        end
+
+        def concat_length(*args)
+          args.reduce(0) { |acc, elem| acc + elem.to_s.length }
+        end
+
+        def correct_annotation?(first_word, colon, space, note)
+          keyword?(first_word) && (colon && space && note || !colon && !note)
+        end
+      end
+    end
+  end
+end