rubbycop 0.49.0

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for multiple expressions placed on the same line.
+      # It also checks for lines terminated with a semicolon.
+      class Semicolon < Cop
+        MSG = 'Do not use semicolons to terminate expressions.'.freeze
+
+        def investigate(processed_source)
+          return unless processed_source.ast
+          @processed_source = processed_source
+
+          check_for_line_terminator_or_opener
+        end
+
+        def on_begin(node)
+          return if cop_config['AllowAsExpressionSeparator']
+          exprs = node.children
+
+          return if exprs.size < 2
+
+          # create a map matching lines to the number of expressions on them
+          exprs_lines = exprs.map { |e| e.source_range.line }
+          lines = exprs_lines.group_by { |i| i }
+
+          # every line with more than 1 expression on it is an offense
+          lines.each do |line, expr_on_line|
+            next unless expr_on_line.size > 1
+            # TODO: Find the correct position of the semicolon. We don't know
+            # if the first semicolon on the line is a separator of
+            # expressions. It's just a guess.
+            column = @processed_source[line - 1].index(';')
+            convention_on(line, column, false)
+          end
+        end
+
+        private
+
+        def check_for_line_terminator_or_opener
+          each_semicolon { |line, column| convention_on(line, column, true) }
+        end
+
+        def each_semicolon
+          tokens_for_lines.each do |line, tokens|
+            yield line, tokens.last.pos.column if tokens.last.type == :tSEMI
+            yield line, tokens.first.pos.column if tokens.first.type == :tSEMI
+          end
+        end
+
+        def tokens_for_lines
+          @processed_source.tokens.group_by { |token| token.pos.line }
+        end
+
+        def convention_on(line, column, autocorrect)
+          range = source_range(@processed_source.buffer, line, column)
+          # Don't attempt to autocorrect if semicolon is separating statements
+          # on the same line
+          add_offense(autocorrect ? range : nil, range)
+        end
+
+        def autocorrect(range)
+          return unless range
+          ->(corrector) { corrector.remove(range) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for the use of the send method.
+      class Send < Cop
+        MSG = 'Prefer `Object#__send__` or `Object#public_send` to ' \
+              '`send`.'.freeze
+
+        def_node_matcher :sending?, '(send _ :send ...)'
+
+        def on_send(node)
+          return unless sending?(node) && node.arguments?
+
+          add_offense(node, :selector)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for uses of `fail` and `raise`.
+      class SignalException < Cop
+        include ConfigurableEnforcedStyle
+
+        FAIL_MSG = 'Use `fail` instead of `raise` to signal exceptions.'.freeze
+        RAISE_MSG = 'Use `raise` instead of `fail` to ' \
+                    'rethrow exceptions.'.freeze
+
+        def_node_matcher :kernel_call?, '(send (const nil :Kernel) %1 ...)'
+        def_node_search :custom_fail_methods,
+                        '{(def :fail ...) (defs _ :fail ...)}'
+
+        def investigate(processed_source)
+          ast = processed_source.ast
+          @custom_fail_defined = ast && custom_fail_methods(ast).any?
+        end
+
+        def on_rescue(node)
+          return unless style == :semantic
+
+          begin_node, *rescue_nodes, _else_node = *node
+          check_scope(:raise, begin_node)
+
+          rescue_nodes.each do |rescue_node|
+            check_scope(:fail, rescue_node)
+            allow(:raise, rescue_node)
+          end
+        end
+
+        def on_send(node)
+          case style
+          when :semantic
+            check_send(:raise, node) unless ignored_node?(node)
+          when :only_raise
+            return if @custom_fail_defined
+            check_send(:fail, node)
+          when :only_fail
+            check_send(:raise, node)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            name =
+              case style
+              when :semantic
+                command_or_kernel_call?(:raise, node) ? 'fail' : 'raise'
+              when :only_raise then 'raise'
+              when :only_fail then 'fail'
+              end
+
+            corrector.replace(node.loc.selector, name)
+          end
+        end
+
+        private
+
+        def message(method_name)
+          case style
+          when :semantic
+            method_name == :fail ? RAISE_MSG : FAIL_MSG
+          when :only_raise
+            'Always use `raise` to signal exceptions.'
+          when :only_fail
+            'Always use `fail` to signal exceptions.'
+          end
+        end
+
+        def check_scope(method_name, node)
+          return unless node
+
+          each_command_or_kernel_call(method_name, node) do |send_node|
+            next if ignored_node?(send_node)
+
+            add_offense(send_node, :selector, message(method_name))
+            ignore_node(send_node)
+          end
+        end
+
+        def check_send(method_name, node)
+          return unless node && command_or_kernel_call?(method_name, node)
+
+          add_offense(node, :selector, message(method_name))
+        end
+
+        def command_or_kernel_call?(name, node)
+          node.command?(name) || kernel_call?(node, name)
+        end
+
+        def allow(method_name, node)
+          each_command_or_kernel_call(method_name, node) do |send_node|
+            ignore_node(send_node)
+          end
+        end
+
+        def each_command_or_kernel_call(method_name, node)
+          on_node(:send, node, :rescue) do |send_node|
+            yield send_node if command_or_kernel_call?(method_name, send_node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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.
+      class SingleLineBlockParams < Cop
+        def on_block(node)
+          # we care only for single line blocks
+          return unless block_length(node).zero?
+
+          method_node, args_node, _body_node = *node
+          receiver, method_name, _method_args = *method_node
+
+          # discard other scenarios
+          return unless receiver
+          return unless method_names.include?(method_name)
+
+          args = *args_node
+
+          return if args.empty?
+          # discard cases with argument destructuring
+          return true unless args.all?(&:arg_type?)
+          return if args_match?(method_name, args)
+
+          add_offense(args_node, :expression, message(method_name))
+        end
+
+        private
+
+        def message(method_name)
+          args = target_args(method_name).join(', ')
+          "Name `#{method_name}` block params `|#{args}|`."
+        end
+
+        def methods
+          cop_config['Methods']
+        end
+
+        def method_names
+          methods.map { |e| e.keys.first.to_sym }
+        end
+
+        def target_args(method_name)
+          method_name = method_name.to_s
+          method_hash = methods.find { |m| m.keys.first == method_name }
+          method_hash[method_name]
+        end
+
+        def args_match?(method_name, args)
+          actual_args = args.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/rubbycop/cop/style/single_line_methods.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for single-line method definitions.
+      # It can optionally accept single-line methods with no body.
+      class SingleLineMethods < Cop
+        include AutocorrectAlignment
+        include OnMethodDef
+
+        MSG = 'Avoid single-line method definitions.'.freeze
+
+        def allow_empty?
+          cop_config['AllowIfMethodIsEmpty']
+        end
+
+        private
+
+        def on_method_def(node, _method_name, _args, body)
+          start_line = node.loc.keyword.line
+          end_line = node.loc.end.line
+
+          empty_body = body.nil?
+          return unless start_line == end_line && !(allow_empty? && empty_body)
+
+          @body = body
+          add_offense(node, :expression)
+        end
+
+        def autocorrect(node)
+          body = @body
+
+          lambda do |corrector|
+            each_part(body) do |part|
+              break_line_before(part, node, corrector, 1)
+            end
+
+            break_line_before(node.loc.end, node, corrector, 0)
+
+            eol_comment = end_of_line_comment(node.source_range.line)
+            move_comment(eol_comment, node, corrector) if eol_comment
+          end
+        end
+
+        def end_of_line_comment(line)
+          processed_source.comments.find { |c| c.loc.line == line }
+        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 break_line_before(range, node, corrector, indent_steps)
+          corrector.insert_before(
+            range,
+            "\n" + ' ' * (node.loc.keyword.column +
+                          indent_steps * configured_indentation_width)
+          )
+        end
+
+        def move_comment(eol_comment, node, corrector)
+          text = eol_comment.loc.expression.source
+          corrector.insert_before(node.source_range,
+                                  text + "\n" + (' ' * node.loc.keyword.column))
+          corrector.remove(eol_comment.loc.expression)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop looks for uses of Perl-style global variables.
+      class SpecialGlobalVars < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG_BOTH = 'Prefer `%s` from the stdlib \'English\' module ' \
+        '(don\'t forget to require it), or `%s` over `%s`.'.freeze
+        MSG_ENGLISH = 'Prefer `%s` from the stdlib \'English\' module ' \
+        '(don\'t forget to require it) over `%s`.'.freeze
+        MSG_REGULAR = 'Prefer `%s` over `%s`.'.freeze
+
+        ENGLISH_VARS = { # rubbycop: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 { |_, v| v.freeze }.freeze
+        PERL_VARS.each { |_, v| v.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, :expression)
+          end
+        end
+
+        def message(node)
+          global_var, = *node
+
+          if style == :use_english_names
+            format_english_message(global_var)
+          else
+            format(MSG_REGULAR, preferred_names(global_var).first, global_var)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            global_var, = *node
+
+            while node.parent && 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_var)
+          if !regular.empty? && !english.empty?
+            format(MSG_BOTH, format_list(english), format_list(regular),
+                   global_var)
+          elsif !regular.empty?
+            format(MSG_REGULAR, format_list(regular), global_var)
+          elsif !english.empty?
+            format(MSG_ENGLISH, format_list(english), global_var)
+          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 && 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