rubocop 0.75.1

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

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for usage of comparison operators (`==`,
+      # `>`, `<`) to test numbers as zero, positive, or negative.
+      # These can be replaced by their respective predicate methods.
+      # The cop can also be configured to do the reverse.
+      #
+      # The cop disregards `#nonzero?` as it its value is truthy or falsey,
+      # but not `true` and `false`, and thus not always interchangeable with
+      # `!= 0`.
+      #
+      # The cop ignores comparisons to global variables, since they are often
+      # populated with objects which can be compared with integers, but are
+      # not themselves `Integer` polymorphic.
+      #
+      # @example EnforcedStyle: predicate (default)
+      #   # bad
+      #
+      #   foo == 0
+      #   0 > foo
+      #   bar.baz > 0
+      #
+      #   # good
+      #
+      #   foo.zero?
+      #   foo.negative?
+      #   bar.baz.positive?
+      #
+      # @example EnforcedStyle: comparison
+      #   # bad
+      #
+      #   foo.zero?
+      #   foo.negative?
+      #   bar.baz.positive?
+      #
+      #   # good
+      #
+      #   foo == 0
+      #   0 > foo
+      #   bar.baz > 0
+      class NumericPredicate < Cop
+        include ConfigurableEnforcedStyle
+        include IgnoredMethods
+
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+
+        REPLACEMENTS = {
+          'zero?' => '==',
+          'positive?' => '>',
+          'negative?' => '<'
+        }.freeze
+
+        def on_send(node)
+          return if node.each_ancestor(:send, :block).any? do |ancestor|
+            ignored_method?(ancestor.method_name)
+          end
+
+          numeric, replacement = check(node)
+
+          return unless numeric
+
+          add_offense(node,
+                      message: format(MSG,
+                                      prefer: replacement,
+                                      current: node.source))
+        end
+
+        def autocorrect(node)
+          _, replacement = check(node)
+
+          lambda do |corrector|
+            corrector.replace(node.loc.expression, replacement)
+          end
+        end
+
+        private
+
+        def check(node)
+          numeric, operator =
+            if style == :predicate
+              comparison(node) || inverted_comparison(node, &invert)
+            else
+              predicate(node)
+            end
+
+          return unless numeric && operator
+
+          [numeric, replacement(numeric, operator)]
+        end
+
+        def replacement(numeric, operation)
+          if style == :predicate
+            [parenthesized_source(numeric),
+             REPLACEMENTS.invert[operation.to_s]].join('.')
+          else
+            [numeric.source, REPLACEMENTS[operation.to_s], 0].join(' ')
+          end
+        end
+
+        def parenthesized_source(node)
+          if require_parentheses?(node)
+            "(#{node.source})"
+          else
+            node.source
+          end
+        end
+
+        def require_parentheses?(node)
+          node.send_type? && node.binary_operation? && !node.parenthesized?
+        end
+
+        def invert
+          lambda do |comparison, numeric|
+            comparison = { :> => :<, :< => :> }[comparison] || comparison
+
+            [numeric, comparison]
+          end
+        end
+
+        def_node_matcher :predicate, <<~PATTERN
+          (send $(...) ${:zero? :positive? :negative?})
+        PATTERN
+
+        def_node_matcher :comparison, <<~PATTERN
+          (send [$(...) !gvar_type?] ${:== :> :<} (int 0))
+        PATTERN
+
+        def_node_matcher :inverted_comparison, <<~PATTERN
+          (send (int 0) ${:== :> :<} [$(...) !gvar_type?])
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # TODO: Make configurable.
+      # Checks for uses of if/then/else/end on a single line.
+      #
+      # @example
+      #   # bad
+      #   if foo then boo else doo end
+      #   unless foo then boo else goo end
+      #
+      #   # good
+      #   foo ? boo : doo
+      #   boo if foo
+      #   if foo then boo end
+      #
+      #   # good
+      #   if foo
+      #     boo
+      #   else
+      #     doo
+      #   end
+      class OneLineConditional < Cop
+        include OnNormalIfUnless
+
+        MSG = 'Favor the ternary operator (`?:`) ' \
+              'over `%<keyword>s/then/else/end` constructs.'
+
+        def on_normal_if_unless(node)
+          return unless node.single_line? && node.else_branch
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, replacement(node))
+          end
+        end
+
+        private
+
+        def message(node)
+          format(MSG, keyword: node.keyword)
+        end
+
+        def replacement(node)
+          return to_ternary(node) unless node.parent
+
+          if %i[and or].include?(node.parent.type)
+            return "(#{to_ternary(node)})"
+          end
+
+          if node.parent.send_type? && node.parent.operator_method?
+            return "(#{to_ternary(node)})"
+          end
+
+          to_ternary(node)
+        end
+
+        def to_ternary(node)
+          condition, if_branch, else_branch = *node
+
+          "#{expr_replacement(condition)} ? " \
+            "#{expr_replacement(if_branch)} : " \
+            "#{expr_replacement(else_branch)}"
+        end
+
+        def expr_replacement(node)
+          return 'nil' if node.nil?
+
+          requires_parentheses?(node) ? "(#{node.source})" : node.source
+        end
+
+        def requires_parentheses?(node)
+          return true if %i[and or if].include?(node.type)
+          return true if node.assignment?
+          return true if method_call_with_changed_precedence?(node)
+
+          keyword_with_changed_precedence?(node)
+        end
+
+        def method_call_with_changed_precedence?(node)
+          return false unless node.send_type? && node.arguments?
+          return false if node.parenthesized_call?
+
+          !node.operator_method?
+        end
+
+        def keyword_with_changed_precedence?(node)
+          return false unless node.keyword?
+          return true if node.prefix_not?
+
+          node.arguments? && !node.parenthesized_call?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for options hashes and discourages them if the
+      # current Ruby version supports keyword arguments.
+      #
+      # @example
+      #
+      #   # bad
+      #   def fry(options = {})
+      #     temperature = options.fetch(:temperature, 300)
+      #     # ...
+      #   end
+      #
+      #
+      #   # good
+      #   def fry(temperature: 300)
+      #     # ...
+      #   end
+      class OptionHash < Cop
+        MSG = 'Prefer keyword arguments to options hashes.'
+
+        def_node_matcher :option_hash, <<~PATTERN
+          (args ... $(optarg [#suspicious_name? _] (hash)))
+        PATTERN
+
+        def on_args(node)
+          return if super_used?(node)
+          return if whitelist.include?(node.parent.method_name.to_s)
+
+          option_hash(node) do |options|
+            add_offense(options)
+          end
+        end
+
+        private
+
+        def whitelist
+          cop_config['Whitelist'] || []
+        end
+
+        def suspicious_name?(arg_name)
+          cop_config.key?('SuspiciousParamNames') &&
+            cop_config['SuspiciousParamNames'].include?(arg_name.to_s)
+        end
+
+        def super_used?(node)
+          node.parent.each_node(:zsuper).any?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for optional arguments to methods
+      # that do not come at the end of the argument list
+      #
+      # @example
+      #   # bad
+      #   def foo(a = 1, b, c)
+      #   end
+      #
+      #   # good
+      #   def baz(a, b, c = 1)
+      #   end
+      #
+      #   def foobar(a = 1, b = 2, c = 3)
+      #   end
+      class OptionalArguments < Cop
+        MSG = 'Optional arguments should appear at the end ' \
+              'of the argument list.'
+
+        def on_def(node)
+          each_misplaced_optional_arg(node.arguments) do |argument|
+            add_offense(argument)
+          end
+        end
+
+        private
+
+        def each_misplaced_optional_arg(arguments)
+          optarg_positions, arg_positions = argument_positions(arguments)
+          return if optarg_positions.empty? || arg_positions.empty?
+
+          optarg_positions.each do |optarg_position|
+            # there can only be one group of optional arguments
+            break if optarg_position > arg_positions.max
+
+            yield arguments[optarg_position]
+          end
+        end
+
+        def argument_positions(arguments)
+          optarg_positions = []
+          arg_positions = []
+
+          arguments.each_with_index do |argument, index|
+            optarg_positions << index if argument.optarg_type?
+            arg_positions << index if argument.arg_type?
+          end
+
+          [optarg_positions, arg_positions]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for potential usage of the `||=` operator.
+      #
+      # @example
+      #   # bad
+      #   name = name ? name : 'Bozhidar'
+      #
+      #   # bad
+      #   name = if name
+      #            name
+      #          else
+      #            'Bozhidar'
+      #          end
+      #
+      #   # bad
+      #   unless name
+      #     name = 'Bozhidar'
+      #   end
+      #
+      #   # bad
+      #   name = 'Bozhidar' unless name
+      #
+      #   # good - set name to 'Bozhidar', only if it's nil or false
+      #   name ||= 'Bozhidar'
+      class OrAssignment < Cop
+        MSG = 'Use the double pipe equals operator `||=` instead.'
+
+        def_node_matcher :ternary_assignment?, <<~PATTERN
+          ({lvasgn ivasgn cvasgn gvasgn} _var
+            (if
+              ({lvar ivar cvar gvar} _var)
+              ({lvar ivar cvar gvar} _var)
+              _))
+        PATTERN
+
+        def_node_matcher :unless_assignment?, <<~PATTERN
+          (if
+            ({lvar ivar cvar gvar} _var) nil?
+            ({lvasgn ivasgn cvasgn gvasgn} _var
+              _))
+        PATTERN
+
+        def on_if(node)
+          return unless unless_assignment?(node)
+
+          add_offense(node)
+        end
+
+        def on_lvasgn(node)
+          return unless ternary_assignment?(node)
+
+          add_offense(node)
+        end
+
+        alias on_ivasgn on_lvasgn
+        alias on_cvasgn on_lvasgn
+        alias on_gvasgn on_lvasgn
+
+        def autocorrect(node)
+          if ternary_assignment?(node)
+            variable, default = take_variable_and_default_from_ternary(node)
+          else
+            variable, default = take_variable_and_default_from_unless(node)
+          end
+
+          lambda do |corrector|
+            corrector.replace(node.source_range,
+                              "#{variable} ||= #{default.source}")
+          end
+        end
+
+        private
+
+        def take_variable_and_default_from_ternary(node)
+          variable, if_statement = *node
+          [variable, if_statement.else_branch]
+        end
+
+        def take_variable_and_default_from_unless(node)
+          if node.if_branch
+            variable, default = *node.if_branch
+          else
+            variable, default = *node.else_branch
+          end
+
+          [variable, default]
+        end
+      end
+    end
+  end
+end