rubocop 0.75.1

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks whether the block parameters of a single-line
+      # method accepting a block match the names specified via configuration.
+      #
+      # For instance one can configure `reduce`(`inject`) to use |a, e| as
+      # parameters.
+      #
+      # Configuration option: Methods
+      # Should be set to use this cop. Array of hashes, where each key is the
+      # method name and value - array of argument names.
+      #
+      # @example Methods: [{reduce: %w[a b]}]
+      #   # bad
+      #   foo.reduce { |c, d| c + d }
+      #   foo.reduce { |_, _d| 1 }
+      #
+      #   # good
+      #   foo.reduce { |a, b| a + b }
+      #   foo.reduce { |a, _b| a }
+      #   foo.reduce { |a, (id, _)| a + id }
+      #   foo.reduce { true }
+      #
+      #   # good
+      #   foo.reduce do |c, d|
+      #     c + d
+      #   end
+      class SingleLineBlockParams < Cop
+        MSG = 'Name `%<method>s` block params `|%<params>s|`.'
+
+        def on_block(node)
+          return unless node.single_line?
+
+          return unless eligible_method?(node)
+          return unless eligible_arguments?(node)
+
+          return if args_match?(node.send_node.method_name, node.arguments)
+
+          add_offense(node.arguments)
+        end
+
+        private
+
+        def message(node)
+          method_name = node.parent.send_node.method_name
+          arguments   = target_args(method_name).join(', ')
+
+          format(MSG, method: method_name, params: arguments)
+        end
+
+        def eligible_arguments?(node)
+          node.arguments? && node.arguments.to_a.all?(&:arg_type?)
+        end
+
+        def eligible_method?(node)
+          node.send_node.receiver &&
+            method_names.include?(node.send_node.method_name)
+        end
+
+        def methods
+          cop_config['Methods']
+        end
+
+        def method_names
+          methods.map { |method| method_name(method).to_sym }
+        end
+
+        def method_name(method)
+          method.keys.first
+        end
+
+        def target_args(method_name)
+          method_name = method_name.to_s
+          method_hash = methods.find { |m| method_name(m) == method_name }
+          method_hash[method_name]
+        end
+
+        def args_match?(method_name, args)
+          actual_args = args.to_a.flat_map(&:to_a)
+
+          # Prepending an underscore to mark an unused parameter is allowed, so
+          # we remove any leading underscores before comparing.
+          actual_args_no_underscores = actual_args.map do |arg|
+            arg.to_s.sub(/^_+/, '')
+          end
+
+          actual_args_no_underscores == target_args(method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for single-line method definitions that contain a body.
+      # It will accept single-line methods with no body.
+      #
+      # @example
+      #   # bad
+      #   def some_method; body end
+      #   def link_to(url); {:name => url}; end
+      #   def @table.columns; super; end
+      #
+      #   # good
+      #   def self.resource_class=(klass); end
+      #   def @table.columns; end
+      #
+      # @example AllowIfMethodIsEmpty: true (default)
+      #   # good
+      #   def no_op; end
+      #
+      # @example AllowIfMethodIsEmpty: false
+      #   # bad
+      #   def no_op; end
+      #
+      class SingleLineMethods < Cop
+        include Alignment
+
+        MSG = 'Avoid single-line method definitions.'
+
+        def on_def(node)
+          return unless node.single_line?
+          return if allow_empty? && !node.body
+
+          add_offense(node)
+        end
+        alias on_defs on_def
+
+        def autocorrect(node)
+          lambda do |corrector|
+            each_part(node.body) do |part|
+              LineBreakCorrector.break_line_before(
+                range: part, node: node, corrector: corrector,
+                configured_width: configured_indentation_width
+              )
+            end
+
+            LineBreakCorrector.break_line_before(
+              range: node.loc.end, node: node, corrector: corrector,
+              indent_steps: 0, configured_width: configured_indentation_width
+            )
+
+            move_comment(node, corrector)
+          end
+        end
+
+        private
+
+        def allow_empty?
+          cop_config['AllowIfMethodIsEmpty']
+        end
+
+        def each_part(body)
+          return unless body
+
+          if body.begin_type?
+            body.each_child_node { |part| yield part.source_range }
+          else
+            yield body.source_range
+          end
+        end
+
+        def move_comment(node, corrector)
+          LineBreakCorrector.move_comment(
+            eol_comment: end_of_line_comment(node.source_range.line),
+            node: node, corrector: corrector
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      #
+      # This cop looks for uses of Perl-style global variables.
+      #
+      # @example EnforcedStyle: use_english_names (default)
+      #   # good
+      #   puts $LOAD_PATH
+      #   puts $LOADED_FEATURES
+      #   puts $PROGRAM_NAME
+      #   puts $ERROR_INFO
+      #   puts $ERROR_POSITION
+      #   puts $FIELD_SEPARATOR # or $FS
+      #   puts $OUTPUT_FIELD_SEPARATOR # or $OFS
+      #   puts $INPUT_RECORD_SEPARATOR # or $RS
+      #   puts $OUTPUT_RECORD_SEPARATOR # or $ORS
+      #   puts $INPUT_LINE_NUMBER # or $NR
+      #   puts $LAST_READ_LINE
+      #   puts $DEFAULT_OUTPUT
+      #   puts $DEFAULT_INPUT
+      #   puts $PROCESS_ID # or $PID
+      #   puts $CHILD_STATUS
+      #   puts $LAST_MATCH_INFO
+      #   puts $IGNORECASE
+      #   puts $ARGV # or ARGV
+      #   puts $MATCH
+      #   puts $PREMATCH
+      #   puts $POSTMATCH
+      #   puts $LAST_PAREN_MATCH
+      #
+      # @example EnforcedStyle: use_perl_names
+      #   # good
+      #   puts $:
+      #   puts $"
+      #   puts $0
+      #   puts $!
+      #   puts $@
+      #   puts $;
+      #   puts $,
+      #   puts $/
+      #   puts $\
+      #   puts $.
+      #   puts $_
+      #   puts $>
+      #   puts $<
+      #   puts $$
+      #   puts $?
+      #   puts $~
+      #   puts $=
+      #   puts $*
+      #   puts $&
+      #   puts $`
+      #   puts $'
+      #   puts $+
+      #
+      class SpecialGlobalVars < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG_BOTH = 'Prefer `%<prefer>s` from the stdlib \'English\' ' \
+        'module (don\'t forget to require it) or `%<regular>s` over ' \
+        '`%<global>s`.'
+        MSG_ENGLISH = 'Prefer `%<prefer>s` from the stdlib \'English\' ' \
+        'module (don\'t forget to require it) over `%<global>s`.'
+        MSG_REGULAR = 'Prefer `%<prefer>s` over `%<global>s`.'
+
+        ENGLISH_VARS = { # rubocop:disable Style/MutableConstant
+          :$: => [:$LOAD_PATH],
+          :$" => [:$LOADED_FEATURES],
+          :$0 => [:$PROGRAM_NAME],
+          :$! => [:$ERROR_INFO],
+          :$@ => [:$ERROR_POSITION],
+          :$; => %i[$FIELD_SEPARATOR $FS],
+          :$, => %i[$OUTPUT_FIELD_SEPARATOR $OFS],
+          :$/ => %i[$INPUT_RECORD_SEPARATOR $RS],
+          :$\ => %i[$OUTPUT_RECORD_SEPARATOR $ORS],
+          :$. => %i[$INPUT_LINE_NUMBER $NR],
+          :$_ => [:$LAST_READ_LINE],
+          :$> => [:$DEFAULT_OUTPUT],
+          :$< => [:$DEFAULT_INPUT],
+          :$$ => %i[$PROCESS_ID $PID],
+          :$? => [:$CHILD_STATUS],
+          :$~ => [:$LAST_MATCH_INFO],
+          :$= => [:$IGNORECASE],
+          :$* => %i[$ARGV ARGV],
+          :$& => [:$MATCH],
+          :$` => [:$PREMATCH],
+          :$' => [:$POSTMATCH],
+          :$+ => [:$LAST_PAREN_MATCH]
+        }
+
+        PERL_VARS =
+          Hash[ENGLISH_VARS.flat_map { |k, vs| vs.map { |v| [v, [k]] } }]
+
+        ENGLISH_VARS.merge!(
+          Hash[ENGLISH_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }]
+        )
+        PERL_VARS.merge!(
+          Hash[PERL_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }]
+        )
+        ENGLISH_VARS.each_value(&:freeze).freeze
+        PERL_VARS.each_value(&:freeze).freeze
+
+        # Anything *not* in this set is provided by the English library.
+        NON_ENGLISH_VARS = Set.new(%i[
+                                     $LOAD_PATH
+                                     $LOADED_FEATURES
+                                     $PROGRAM_NAME
+                                     ARGV
+                                   ]).freeze
+
+        def on_gvar(node)
+          global_var, = *node
+
+          return unless (preferred = preferred_names(global_var))
+
+          if preferred.include?(global_var)
+            correct_style_detected
+          else
+            opposite_style_detected
+            add_offense(node)
+          end
+        end
+
+        def message(node)
+          global_var, = *node
+
+          if style == :use_english_names
+            format_english_message(global_var)
+          else
+            format(MSG_REGULAR,
+                   prefer: preferred_names(global_var).first,
+                   global: global_var)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            global_var, = *node
+
+            while node.parent&.begin_type? &&
+                  node.parent.children.one?
+              node = node.parent
+            end
+
+            corrector.replace(node.source_range, replacement(node, global_var))
+          end
+        end
+
+        private
+
+        def format_english_message(global_var)
+          regular, english = ENGLISH_VARS[global_var].partition do |var|
+            NON_ENGLISH_VARS.include? var
+          end
+
+          format_message(english, regular, global_var)
+        end
+
+        def format_message(english, regular, global)
+          if !regular.empty? && !english.empty?
+            format(MSG_BOTH,
+                   prefer: format_list(english),
+                   regular: format_list(regular),
+                   global: global)
+          elsif !regular.empty?
+            format(MSG_REGULAR, prefer: format_list(regular), global: global)
+          elsif !english.empty?
+            format(MSG_ENGLISH, prefer: format_list(english), global: global)
+          else
+            raise 'Bug in SpecialGlobalVars - global var w/o preferred vars!'
+          end
+        end
+
+        # For now, we assume that lists are 2 items or less. Easy grammar!
+        def format_list(items)
+          items.join('` or `')
+        end
+
+        def replacement(node, global_var)
+          parent_type = node.parent&.type
+          preferred_name = preferred_names(global_var).first
+
+          unless %i[dstr xstr regexp].include?(parent_type)
+            return preferred_name.to_s
+          end
+
+          if style == :use_english_names
+            return english_name_replacement(preferred_name, node)
+          end
+
+          "##{preferred_name}"
+        end
+
+        def preferred_names(global)
+          if style == :use_english_names
+            ENGLISH_VARS[global]
+          else
+            PERL_VARS[global]
+          end
+        end
+
+        def english_name_replacement(preferred_name, node)
+          return "\#{#{preferred_name}}" if node.begin_type?
+
+          "{#{preferred_name}}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Check for parentheses around stabby lambda arguments.
+      # There are two different styles. Defaults to `require_parentheses`.
+      #
+      # @example EnforcedStyle: require_parentheses (default)
+      #   # bad
+      #   ->a,b,c { a + b + c }
+      #
+      #   # good
+      #   ->(a,b,c) { a + b + c}
+      #
+      # @example EnforcedStyle: require_no_parentheses
+      #   # bad
+      #   ->(a,b,c) { a + b + c }
+      #
+      #   # good
+      #   ->a,b,c { a + b + c}
+      class StabbyLambdaParentheses < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG_REQUIRE = 'Wrap stabby lambda arguments with parentheses.'
+        MSG_NO_REQUIRE = 'Do not wrap stabby lambda arguments ' \
+                         'with parentheses.'
+        def on_send(node)
+          return unless stabby_lambda_with_args?(node)
+          return unless redundant_parentheses?(node) ||
+                        missing_parentheses?(node)
+
+          add_offense(node.block_node.arguments)
+        end
+
+        def autocorrect(node)
+          if style == :require_parentheses
+            missing_parentheses_corrector(node)
+          elsif style == :require_no_parentheses
+            unwanted_parentheses_corrector(node)
+          end
+        end
+
+        private
+
+        def missing_parentheses?(node)
+          style == :require_parentheses && !parentheses?(node)
+        end
+
+        def redundant_parentheses?(node)
+          style == :require_no_parentheses && parentheses?(node)
+        end
+
+        def message(_node)
+          style == :require_parentheses ? MSG_REQUIRE : MSG_NO_REQUIRE
+        end
+
+        def missing_parentheses_corrector(node)
+          lambda do |corrector|
+            args_loc = node.loc.expression
+
+            corrector.insert_before(args_loc, '(')
+            corrector.insert_after(args_loc, ')')
+          end
+        end
+
+        def unwanted_parentheses_corrector(node)
+          lambda do |corrector|
+            args_loc = node.loc
+
+            corrector.replace(args_loc.begin, '')
+            corrector.remove(args_loc.end)
+          end
+        end
+
+        def stabby_lambda_with_args?(node)
+          node.lambda_literal? && node.block_node.arguments?
+        end
+
+        def parentheses?(node)
+          node.block_node.arguments.loc.begin
+        end
+      end
+    end
+  end
+end