rubocop 0.75.1

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for trailing inline comments.
+      #
+      # @example
+      #
+      #   # good
+      #   foo.each do |f|
+      #     # Standalone comment
+      #     f.bar
+      #   end
+      #
+      #   # bad
+      #   foo.each do |f|
+      #     f.bar # Trailing inline comment
+      #   end
+      class InlineComment < Cop
+        MSG = 'Avoid trailing inline comments.'
+
+        def investigate(processed_source)
+          processed_source.each_comment do |comment|
+            next if comment_line?(processed_source[comment.loc.line - 1]) ||
+                    comment.text.match(/\A# rubocop:(enable|disable)/)
+
+            add_offense(comment)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop check for usages of not (`not` or `!`) called on a method
+      # when an inverse of that method can be used instead.
+      # Methods that can be inverted by a not (`not` or `!`) should be defined
+      # in `InverseMethods`
+      # Methods that are inverted by inverting the return
+      # of the block that is passed to the method should be defined in
+      # `InverseBlocks`
+      #
+      # @example
+      #   # bad
+      #   !foo.none?
+      #   !foo.any? { |f| f.even? }
+      #   !foo.blank?
+      #   !(foo == bar)
+      #   foo.select { |f| !f.even? }
+      #   foo.reject { |f| f != 7 }
+      #
+      #   # good
+      #   foo.none?
+      #   foo.blank?
+      #   foo.any? { |f| f.even? }
+      #   foo != bar
+      #   foo == bar
+      #   !!('foo' =~ /^\w+$/)
+      #   !(foo.class < Numeric) # Checking class hierarchy is allowed
+      #   # Blocks with guard clauses are ignored:
+      #   foo.select do |f|
+      #     next if f.zero?
+      #     f != 1
+      #   end
+      class InverseMethods < Cop
+        include IgnoredNode
+        include RangeHelp
+
+        MSG = 'Use `%<inverse>s` instead of inverting `%<method>s`.'
+        CLASS_COMPARISON_METHODS = %i[<= >= < >].freeze
+        EQUALITY_METHODS = %i[== != =~ !~ <= >= < >].freeze
+        NEGATED_EQUALITY_METHODS = %i[!= !~].freeze
+        CAMEL_CASE = /[A-Z]+[a-z]+/.freeze
+
+        def self.autocorrect_incompatible_with
+          [Style::Not]
+        end
+
+        def_node_matcher :inverse_candidate?, <<~PATTERN
+          {
+            (send $(send $(...) $_ $...) :!)
+            (send (block $(send $(...) $_) $...) :!)
+            (send (begin $(send $(...) $_ $...)) :!)
+          }
+        PATTERN
+
+        def_node_matcher :inverse_block?, <<~PATTERN
+          (block $(send (...) $_) ... { $(send ... :!)
+                                        $(send (...) {:!= :!~} ...)
+                                        (begin ... $(send ... :!))
+                                        (begin ... $(send (...) {:!= :!~} ...))
+                                      })
+        PATTERN
+
+        def on_send(node)
+          return if part_of_ignored_node?(node)
+
+          inverse_candidate?(node) do |_method_call, lhs, method, rhs|
+            return unless inverse_methods.key?(method)
+            return if possible_class_hierarchy_check?(lhs, rhs, method)
+            return if negated?(node)
+
+            add_offense(node,
+                        message: format(MSG, method: method,
+                                             inverse: inverse_methods[method]))
+          end
+        end
+
+        def on_block(node)
+          inverse_block?(node) do |_method_call, method, block|
+            return unless inverse_blocks.key?(method)
+            return if negated?(node) && negated?(node.parent)
+            return if node.each_node(:next).any?
+
+            # Inverse method offenses inside of the block of an inverse method
+            # offense, such as `y.reject { |key, _value| !(key =~ /c\d/) }`,
+            # can cause auto-correction to apply improper corrections.
+            ignore_node(block)
+            add_offense(node,
+                        message: format(MSG, method: method,
+                                             inverse: inverse_blocks[method]))
+          end
+        end
+
+        def autocorrect(node)
+          method_call, _lhs, method, _rhs = inverse_candidate?(node)
+
+          if method_call && method
+            lambda do |corrector|
+              corrector.remove(not_to_receiver(node, method_call))
+              corrector.replace(method_call.loc.selector,
+                                inverse_methods[method].to_s)
+
+              if EQUALITY_METHODS.include?(method)
+                corrector.remove(end_parentheses(node, method_call))
+              end
+            end
+          else
+            correct_inverse_block(node)
+          end
+        end
+
+        def correct_inverse_block(node)
+          method_call, method, block = inverse_block?(node)
+
+          lambda do |corrector|
+            corrector.replace(method_call.loc.selector,
+                              inverse_blocks[method].to_s)
+            correct_inverse_selector(block, corrector)
+          end
+        end
+
+        def correct_inverse_selector(block, corrector)
+          selector = block.loc.selector.source
+
+          if NEGATED_EQUALITY_METHODS.include?(selector.to_sym)
+            selector[0] = '='
+            corrector.replace(block.loc.selector, selector)
+          else
+            if block.loc.dot
+              range = dot_range(block.loc)
+              corrector.remove(range)
+            end
+
+            corrector.remove(block.loc.selector)
+          end
+        end
+
+        private
+
+        def inverse_methods
+          @inverse_methods ||= cop_config['InverseMethods']
+                               .merge(cop_config['InverseMethods'].invert)
+        end
+
+        def inverse_blocks
+          @inverse_blocks ||= cop_config['InverseBlocks']
+                              .merge(cop_config['InverseBlocks'].invert)
+        end
+
+        def negated?(node)
+          node.parent.respond_to?(:method?) && node.parent.method?(:!)
+        end
+
+        def not_to_receiver(node, method_call)
+          Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                    node.loc.selector.begin_pos,
+                                    method_call.loc.expression.begin_pos)
+        end
+
+        def end_parentheses(node, method_call)
+          Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                    method_call.loc.expression.end_pos,
+                                    node.loc.expression.end_pos)
+        end
+
+        # When comparing classes, `!(Integer < Numeric)` is not the same as
+        # `Integer > Numeric`.
+        def possible_class_hierarchy_check?(lhs, rhs, method)
+          CLASS_COMPARISON_METHODS.include?(method) &&
+            (camel_case_constant?(lhs) ||
+             (rhs.size == 1 &&
+              camel_case_constant?(rhs.first)))
+        end
+
+        def camel_case_constant?(node)
+          node.const_type? && node.source =~ CAMEL_CASE
+        end
+
+        def dot_range(loc)
+          range_between(loc.dot.begin_pos, loc.expression.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'resolv'
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for hardcoded IP addresses, which can make code
+      # brittle. IP addresses are likely to need to be changed when code
+      # is deployed to a different server or environment, which may break
+      # a deployment if forgotten. Prefer setting IP addresses in ENV or
+      # other configuration.
+      #
+      # @example
+      #
+      #   # bad
+      #   ip_address = '127.59.241.29'
+      #
+      #   # good
+      #   ip_address = ENV['DEPLOYMENT_IP_ADDRESS']
+      class IpAddresses < Cop
+        include StringHelp
+
+        IPV6_MAX_SIZE = 45 # IPv4-mapped IPv6 is the longest
+        MSG = 'Do not hardcode IP addresses.'
+
+        def offense?(node)
+          contents = node.source[1...-1]
+          return false if contents.empty?
+
+          return false if whitelist.include?(contents.downcase)
+
+          # To try to avoid doing two regex checks on every string,
+          # shortcut out if the string does not look like an IP address
+          return false unless could_be_ip?(contents)
+
+          contents =~ ::Resolv::IPv4::Regex || contents =~ ::Resolv::IPv6::Regex
+        end
+
+        # Dummy implementation of method in ConfigurableEnforcedStyle that is
+        # called from StringHelp.
+        def opposite_style_detected; end
+
+        # Dummy implementation of method in ConfigurableEnforcedStyle that is
+        # called from StringHelp.
+        def correct_style_detected; end
+
+        private
+
+        def whitelist
+          whitelist = cop_config['Whitelist']
+          Array(whitelist).map(&:downcase)
+        end
+
+        def could_be_ip?(str)
+          # If the string is too long, it can't be an IP
+          return false if too_long?(str)
+
+          # If the string doesn't start with a colon or hexadecimal char,
+          # we know it's not an IP address
+          starts_with_hex_or_colon?(str)
+        end
+
+        def too_long?(str)
+          str.size > IPV6_MAX_SIZE
+        end
+
+        def starts_with_hex_or_colon?(str)
+          first_char = str[0].ord
+          (48..58).cover?(first_char) || (65..70).cover?(first_char) ||
+            (97..102).cover?(first_char)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop (by default) checks for uses of the lambda literal syntax for
+      # single line lambdas, and the method call syntax for multiline lambdas.
+      # It is configurable to enforce one of the styles for both single line
+      # and multiline lambdas as well.
+      #
+      # @example EnforcedStyle: line_count_dependent (default)
+      #   # bad
+      #   f = lambda { |x| x }
+      #   f = ->(x) do
+      #         x
+      #       end
+      #
+      #   # good
+      #   f = ->(x) { x }
+      #   f = lambda do |x|
+      #         x
+      #       end
+      #
+      # @example EnforcedStyle: lambda
+      #   # bad
+      #   f = ->(x) { x }
+      #   f = ->(x) do
+      #         x
+      #       end
+      #
+      #   # good
+      #   f = lambda { |x| x }
+      #   f = lambda do |x|
+      #         x
+      #       end
+      #
+      # @example EnforcedStyle: literal
+      #   # bad
+      #   f = lambda { |x| x }
+      #   f = lambda do |x|
+      #         x
+      #       end
+      #
+      #   # good
+      #   f = ->(x) { x }
+      #   f = ->(x) do
+      #         x
+      #       end
+      class Lambda < Cop
+        include ConfigurableEnforcedStyle
+
+        LITERAL_MESSAGE = 'Use the `-> { ... }` lambda literal syntax for ' \
+                          '%<modifier>s lambdas.'
+        METHOD_MESSAGE = 'Use the `lambda` method for %<modifier>s ' \
+                         'lambdas.'
+
+        OFFENDING_SELECTORS = {
+          style: {
+            lambda: { single_line: '->', multiline: '->' },
+            literal: { single_line: 'lambda', multiline: 'lambda' },
+            line_count_dependent: { single_line: 'lambda', multiline: '->' }
+          }
+        }.freeze
+
+        def on_block(node)
+          return unless node.lambda?
+
+          selector = node.send_node.source
+
+          return unless offending_selector?(node, selector)
+
+          add_offense(node,
+                      location: node.send_node.source_range,
+                      message: message(node, selector))
+        end
+
+        def autocorrect(node)
+          if node.send_node.source == 'lambda'
+            lambda do |corrector|
+              autocorrect_method_to_literal(corrector, node)
+            end
+          else
+            LambdaLiteralToMethodCorrector.new(node)
+          end
+        end
+
+        private
+
+        def offending_selector?(node, selector)
+          lines = node.multiline? ? :multiline : :single_line
+
+          selector == OFFENDING_SELECTORS[:style][style][lines]
+        end
+
+        def message(node, selector)
+          message = selector == '->' ? METHOD_MESSAGE : LITERAL_MESSAGE
+
+          format(message, modifier: message_line_modifier(node))
+        end
+
+        def message_line_modifier(node)
+          case style
+          when :line_count_dependent
+            node.multiline? ? 'multiline' : 'single line'
+          else
+            'all'
+          end
+        end
+
+        def autocorrect_method_to_literal(corrector, node)
+          corrector.replace(node.send_node.source_range, '->')
+
+          return unless node.arguments?
+
+          arg_str = "(#{lambda_arg_string(node.arguments)})"
+
+          corrector.insert_after(node.send_node.source_range, arg_str)
+          corrector.remove(arguments_with_whitespace(node))
+        end
+
+        def arguments_with_whitespace(node)
+          node.loc.begin.end.join(node.arguments.loc.end)
+        end
+
+        def lambda_arg_string(args)
+          args.children.map(&:source).join(', ')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for use of the lambda.(args) syntax.
+      #
+      # @example EnforcedStyle: call (default)
+      #  # bad
+      #  lambda.(x, y)
+      #
+      #  # good
+      #  lambda.call(x, y)
+      #
+      # @example EnforcedStyle: braces
+      #  # bad
+      #  lambda.call(x, y)
+      #
+      #  # good
+      #  lambda.(x, y)
+      class LambdaCall < Cop
+        include ConfigurableEnforcedStyle
+
+        def on_send(node)
+          return unless node.receiver && node.method?(:call)
+
+          if offense?(node)
+            add_offense(node) { opposite_style_detected }
+          else
+            correct_style_detected
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if explicit_style?
+              receiver = node.receiver.source
+              replacement = node.source.sub("#{receiver}.", "#{receiver}.call")
+
+              corrector.replace(node.source_range, replacement)
+            else
+              add_parentheses(node, corrector) unless node.parenthesized?
+              corrector.remove(node.loc.selector)
+            end
+          end
+        end
+
+        private
+
+        def offense?(node)
+          explicit_style? && node.implicit_call? ||
+            implicit_style? && !node.implicit_call?
+        end
+
+        def add_parentheses(node, corrector)
+          if node.arguments.empty?
+            corrector.insert_after(node.source_range, '()')
+          else
+            corrector.replace(args_begin(node), '(')
+            corrector.insert_after(args_end(node), ')')
+          end
+        end
+
+        def args_begin(node)
+          loc = node.loc
+          selector =
+            node.super_type? || node.yield_type? ? loc.keyword : loc.selector
+          selector.end.resize(1)
+        end
+
+        def args_end(node)
+          node.loc.expression.end
+        end
+
+        def message(_node)
+          if explicit_style?
+            'Prefer the use of `lambda.call(...)` over `lambda.(...)`.'
+          else
+            'Prefer the use of `lambda.(...)` over `lambda.call(...)`.'
+          end
+        end
+
+        def implicit_style?
+          style == :braces
+        end
+
+        def explicit_style?
+          style == :call
+        end
+      end
+    end
+  end
+end