rubbycop 0.49.0

data/lib/rubbycop/cop/mixin/statement_modifier.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for modifier cops.
+    module StatementModifier
+      def single_line_as_modifier?(node)
+        return false if non_eligible_node?(node) ||
+                        non_eligible_body?(node.body) ||
+                        non_eligible_condition?(node.condition)
+
+        modifier_fits_on_single_line?(node)
+      end
+
+      def non_eligible_node?(node)
+        line_count(node) > 3 ||
+          !node.modifier_form? && commented?(node.loc.end)
+      end
+
+      def non_eligible_body?(body)
+        empty_body?(body) || body.begin_type? || commented?(body.source_range)
+      end
+
+      def non_eligible_condition?(condition)
+        condition.each_node.any?(&:lvasgn_type?)
+      end
+
+      def modifier_fits_on_single_line?(node)
+        modifier_length = length_in_modifier_form(node, node.condition,
+                                                  body_length(node.body))
+
+        modifier_length <= max_line_length
+      end
+
+      def length_in_modifier_form(node, cond, body_length)
+        indentation = node.loc.keyword.column
+        kw_length = node.loc.keyword.size
+        cond_length = cond.source_range.size
+        space = 1
+        indentation + body_length + space + kw_length + space + cond_length
+      end
+
+      def max_line_length
+        cop_config['MaxLineLength'] ||
+          config.for_cop('Metrics/LineLength')['Max']
+      end
+
+      def line_count(node)
+        node.source.lines.grep(/\S/).size
+      end
+
+      def empty_body?(body)
+        !body || body_length(body).zero?
+      end
+
+      def body_length(body)
+        body.source_range ? body.source_range.size : 0
+      end
+
+      def commented?(source)
+        comment_lines.include?(source.line)
+      end
+
+      def comment_lines
+        @comment_lines ||= processed_source.comments.map { |c| c.location.line }
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/mixin/string_help.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Classes that include this module just implement functions to determine
+    # what is an offense and how to do auto-correction. They get help with
+    # adding offenses for the faulty string nodes, and with filtering out
+    # nodes.
+    module StringHelp
+      def on_str(node)
+        # Constants like __FILE__ are handled as strings,
+        # but don't respond to begin.
+        return unless node.loc.respond_to?(:begin) && node.loc.begin
+        return if part_of_ignored_node?(node)
+
+        if offense?(node)
+          add_offense(node, :expression) { opposite_style_detected }
+        else
+          correct_style_detected
+        end
+      end
+
+      def on_regexp(node)
+        ignore_node(node)
+      end
+
+      def inside_interpolation?(node)
+        # A :begin node inside a :dstr node is an interpolation.
+        node.ancestors.drop_while { |a| !a.begin_type? }.any?(&:dstr_type?)
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/mixin/string_literals_help.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for cops checking single/double quotes.
+    module StringLiteralsHelp
+      include StringHelp
+
+      def wrong_quotes?(node)
+        src = node.source
+        return false if src.start_with?('%', '?')
+        if style == :single_quotes
+          !double_quotes_required?(src)
+        else
+          src !~ /" | \\ | \#(@|\{)/x
+        end
+      end
+
+      def autocorrect(node)
+        return if node.dstr_type?
+
+        lambda do |corrector|
+          str = node.str_content
+          if style == :single_quotes
+            corrector.replace(node.source_range, to_string_literal(str))
+          else
+            corrector.replace(node.source_range, str.inspect)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/mixin/surrounding_space.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for checking surrounding space.
+    module SurroundingSpace
+      def space_between?(t1, _t2)
+        # Check if the range between the tokens starts with a space. It can
+        # contain other characters, e.g. a unary plus, but it must start with
+        # space.
+        t1.pos.source_buffer.source.match(/\G\s/, t1.pos.end_pos)
+      end
+
+      def index_of_first_token(node)
+        range = node.source_range
+        token_table[range.line][range.column]
+      end
+
+      def index_of_last_token(node)
+        range = node.source_range
+        table_row = token_table[range.last_line]
+        (0...range.last_column).reverse_each do |c|
+          ix = table_row[c]
+          return ix if ix
+        end
+      end
+
+      def token_table
+        @token_table ||= begin
+          table = {}
+          @processed_source.tokens.each_with_index do |t, ix|
+            table[t.pos.line] ||= {}
+            table[t.pos.line][t.pos.column] = ix
+          end
+          table
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/mixin/target_rails_version.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for checking target rails version.
+    module TargetRailsVersion
+      def minimum_target_rails_version(version)
+        @minimum_target_rails_version = version
+      end
+
+      def support_target_rails_version?(version)
+        @minimum_target_rails_version <= version
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/mixin/target_ruby_version.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for checking target ruby version.
+    module TargetRubyVersion
+      def minimum_target_ruby_version(version)
+        @minimum_target_ruby_version = version
+      end
+
+      def support_target_ruby_version?(version)
+        @minimum_target_ruby_version <= version
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/mixin/too_many_lines.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for checking for too many lines.
+    module TooManyLines
+      include ConfigurableMax
+      include CodeLength
+
+      MSG = '%s has too many lines. [%d/%d]'.freeze
+
+      private
+
+      def message(length, max_length)
+        format(MSG, cop_label, length, max_length)
+      end
+
+      def code_length(node)
+        body = extract_body(node)
+        lines = body && body.source.lines || []
+
+        lines.count { |line| !irrelevant_line(line) }
+      end
+
+      def extract_body(node)
+        case node.type
+        when :block, :def
+          _receiver_or_method, _args, body = *node
+        when :defs
+          _self, _method, _args, body = *node
+        else
+          body = node
+        end
+
+        body
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/mixin/trailing_comma.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common methods shared by Style/TrailingCommaInArguments and
+    # Style/TrailingCommaInLiteral
+    module TrailingComma
+      include ConfigurableEnforcedStyle
+
+      MSG = '%s comma after the last %s'.freeze
+
+      def style_parameter_name
+        'EnforcedStyleForMultiline'
+      end
+
+      def check(node, items, kind, begin_pos, end_pos)
+        after_last_item = range_between(begin_pos, end_pos)
+
+        return if heredoc?(after_last_item.source)
+
+        comma_offset = after_last_item.source =~ /,/
+
+        if comma_offset && !inside_comment?(after_last_item, comma_offset)
+          check_comma(node, kind, after_last_item.begin_pos + comma_offset)
+        elsif should_have_comma?(style, node)
+          put_comma(node, items, kind)
+        end
+      end
+
+      def check_comma(node, kind, comma_pos)
+        return if should_have_comma?(style, node)
+
+        avoid_comma(kind, comma_pos, extra_avoid_comma_info)
+      end
+
+      def extra_avoid_comma_info
+        case style
+        when :comma
+          ', unless each item is on its own line'
+        when :consistent_comma
+          ', unless items are split onto multiple lines'
+        else
+          ''
+        end
+      end
+
+      def should_have_comma?(style, node)
+        case style
+        when :comma
+          multiline?(node) && no_elements_on_same_line?(node)
+        when :consistent_comma
+          multiline?(node)
+        else
+          false
+        end
+      end
+
+      def inside_comment?(range, comma_offset)
+        processed_source.comments.any? do |comment|
+          comment_offset = comment.loc.expression.begin_pos - range.begin_pos
+          comment_offset >= 0 && comment_offset < comma_offset
+        end
+      end
+
+      def heredoc?(source_after_last_item)
+        source_after_last_item =~ /\w/
+      end
+
+      # Returns true if the node has round/square/curly brackets.
+      def brackets?(node)
+        node.loc.end
+      end
+
+      # Returns true if the round/square/curly brackets of the given node are
+      # on different lines, and each item within is on its own line, and the
+      # closing bracket is on its own line.
+      def multiline?(node)
+        # No need to process anything if the whole node is not multiline
+        # Without the 2nd check, Foo.new({}) is considered multiline, which
+        # it should not be. Essentially, if there are no elements, the
+        # expression can not be multiline.
+        return false unless node.multiline?
+
+        items = elements(node).map(&:source_range)
+        return false if items.empty?
+        items << node.loc.begin << node.loc.end
+        (items.map(&:first_line) + items.map(&:last_line)).uniq.size > 1
+      end
+
+      def elements(node)
+        return node.children unless node.send_type?
+
+        _receiver, _method_name, *args = *node
+        args.flat_map do |a|
+          # For each argument, if it is a multi-line hash without braces,
+          # then promote the hash elements to method arguments
+          # for the purpose of determining multi-line-ness.
+          if a.hash_type? && a.multiline? && !a.braces?
+            a.children
+          else
+            a
+          end
+        end
+      end
+
+      def no_elements_on_same_line?(node)
+        items = elements(node).map(&:source_range)
+        items << node.loc.end
+        items.each_cons(2).none? { |a, b| on_same_line?(a, b) }
+      end
+
+      def on_same_line?(a, b)
+        a.last_line == b.line
+      end
+
+      def avoid_comma(kind, comma_begin_pos, extra_info)
+        range = range_between(comma_begin_pos, comma_begin_pos + 1)
+        article = kind =~ /array/ ? 'an' : 'a'
+        add_offense(range, range,
+                    format(MSG, 'Avoid', format(kind, article)) +
+                    "#{extra_info}.")
+      end
+
+      def put_comma(node, items, kind)
+        return if avoid_autocorrect?(elements(node))
+
+        last_item = items.last
+        return if last_item.block_pass_type?
+
+        range = autocorrect_range(last_item)
+
+        add_offense(range, range,
+                    format(MSG, 'Put a', format(kind, 'a multiline') + '.'))
+      end
+
+      def autocorrect_range(item)
+        expr = item.source_range
+        ix = expr.source.rindex("\n") || 0
+        ix += expr.source[ix..-1] =~ /\S/
+
+        range_between(expr.begin_pos + ix, expr.end_pos)
+      end
+
+      # By default, there's no reason to avoid auto-correct.
+      def avoid_autocorrect?(_)
+        false
+      end
+
+      def autocorrect(range)
+        return unless range
+
+        lambda do |corrector|
+          case range.source
+          when ',' then corrector.remove(range)
+          else          corrector.insert_after(range, ',')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/mixin/unused_argument.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # Common functionality for cops handling unused arguments.
+      module UnusedArgument
+        def join_force?(force_class)
+          force_class == VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          scope.variables.each_value do |variable|
+            check_argument(variable)
+          end
+        end
+
+        def check_argument(variable)
+          return if variable.should_be_unused?
+          return if variable.referenced?
+
+          message = message(variable)
+          add_offense(variable.declaration_node, :name, message)
+        end
+
+        def autocorrect(node)
+          return if %i[kwarg kwoptarg].include?(node.type)
+
+          if node.blockarg_type?
+            lambda do |corrector|
+              range = range_with_surrounding_space(node.source_range, :left)
+              range = range_with_surrounding_comma(range, :left)
+              corrector.remove(range)
+            end
+          else
+            ->(corrector) { corrector.insert_before(node.loc.name, '_') }
+          end
+        end
+      end
+    end
+  end
+end