rubbycop 0.49.0

data/lib/rubbycop/cop/corrector.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # This class takes a source buffer and rewrite its source
+    # based on the different correction rules supplied.
+    #
+    # Important!
+    # The nodes modified by the corrections should be part of the
+    # AST of the source_buffer.
+    class Corrector
+      #
+      # @param source_buffer [Parser::Source::Buffer]
+      # @param corrections [Array(#call)]
+      #   Array of Objects that respond to #call. They will receive the
+      #   corrector itself and should use its method to modify the source.
+      #
+      # @example
+      #
+      #   class AndOrCorrector
+      #     def initialize(node)
+      #       @node = node
+      #     end
+      #
+      #     def call(corrector)
+      #       replacement = (@node.type == :and ? '&&' : '||')
+      #       corrector.replace(@node.loc.operator, replacement)
+      #     end
+      #   end
+      #
+      #   corrections = [AndOrCorrector.new(node)]
+      #   corrector = Corrector.new(source_buffer, corrections)
+      def initialize(source_buffer, corrections = [])
+        @source_buffer = source_buffer
+        @corrections = corrections
+        @source_rewriter = Parser::Source::Rewriter.new(source_buffer)
+
+        @diagnostics = []
+        # Don't print warnings to stderr if corrections conflict with each other
+        @source_rewriter.diagnostics.consumer = lambda do |diagnostic|
+          @diagnostics << diagnostic
+        end
+      end
+
+      attr_reader :corrections, :diagnostics
+
+      # Does the actual rewrite and returns string corresponding to
+      # the rewritten source.
+      #
+      # @return [String]
+      def rewrite
+        # rubbycop:disable Lint/HandleExceptions
+        @corrections.each do |correction|
+          begin
+            @source_rewriter.transaction do
+              correction.call(self)
+            end
+          rescue ::Parser::ClobberingError
+          end
+        end
+        # rubbycop:enable Lint/HandleExceptions
+
+        @source_rewriter.process
+      end
+
+      # Removes the source range.
+      #
+      # @param [Parser::Source::Range] range
+      def remove(range)
+        @source_rewriter.remove(range)
+      end
+
+      # Inserts new code before the given source range.
+      #
+      # @param [Parser::Source::Range] range
+      # @param [String] content
+      def insert_before(range, content)
+        @source_rewriter.insert_before(range, content)
+      end
+
+      # Inserts new code after the given source range.
+      #
+      # @param [Parser::Source::Range] range
+      # @param [String] content
+      def insert_after(range, content)
+        @source_rewriter.insert_after(range, content)
+      end
+
+      # Replaces the code of the source range `range` with `content`.
+      #
+      # @param [Parser::Source::Range] range
+      # @param [String] content
+      def replace(range, content)
+        @source_rewriter.replace(range, content)
+      end
+
+      # Removes `size` characters prior to the source range.
+      #
+      # @param [Parser::Source::Range] range
+      # @param [Integer] size
+      def remove_preceding(range, size)
+        to_remove = Parser::Source::Range.new(range.source_buffer,
+                                              range.begin_pos - size,
+                                              range.begin_pos)
+        @source_rewriter.remove(to_remove)
+      end
+
+      # Removes `size` characters from the beginning of the given range.
+      # If `size` is greater than the size of `range`, the removed region can
+      # overrun the end of `range`.
+      #
+      # @param [Parser::Source::Range] range
+      # @param [Integer] size
+      def remove_leading(range, size)
+        to_remove = Parser::Source::Range.new(range.source_buffer,
+                                              range.begin_pos,
+                                              range.begin_pos + size)
+        @source_rewriter.remove(to_remove)
+      end
+
+      # Removes `size` characters from the end of the given range.
+      # If `size` is greater than the size of `range`, the removed region can
+      # overrun the beginning of `range`.
+      #
+      # @param [Parser::Source::Range] range
+      # @param [Integer] size
+      def remove_trailing(range, size)
+        to_remove = Parser::Source::Range.new(range.source_buffer,
+                                              range.end_pos - size,
+                                              range.end_pos)
+        @source_rewriter.remove(to_remove)
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/force.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # A scaffold for concrete forces.
+    class Force
+      attr_reader :cops
+
+      def self.all
+        @all ||= []
+      end
+
+      def self.inherited(subclass)
+        all << subclass
+      end
+
+      def self.force_name
+        name.split('::').last
+      end
+
+      def initialize(cops)
+        @cops = cops
+      end
+
+      def name
+        self.class.force_name
+      end
+
+      def run_hook(method_name, *args)
+        cops.each do |cop|
+          next unless cop.respond_to?(method_name)
+          cop.send(method_name, *args)
+        end
+      end
+
+      def investigate(_processed_source)
+        # Do custom processing and invoke #run_hook at arbitrary timing.
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/ignored_node.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Handles adding and checking ignored nodes.
+    module IgnoredNode
+      def ignore_node(node)
+        ignored_nodes << node
+      end
+
+      def part_of_ignored_node?(node)
+        ignored_nodes.map(&:loc).any? do |ignored_loc|
+          if ignored_loc.expression.begin_pos > node.source_range.begin_pos
+            next false
+          end
+
+          ignored_end_pos = if ignored_loc.respond_to?(:heredoc_body)
+                              ignored_loc.heredoc_end.end_pos
+                            else
+                              ignored_loc.expression.end_pos
+                            end
+          ignored_end_pos >= node.source_range.end_pos
+        end
+      end
+
+      def ignored_node?(node)
+        # Same object found in array?
+        ignored_nodes.any? { |n| n.equal?(node) }
+      end
+
+      private
+
+      def ignored_nodes
+        @ignored_nodes ||= []
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/layout/access_modifier_indentation.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Modifiers should be indented as deep as method definitions, or as deep
+      # as the class/module keyword, depending on configuration.
+      #
+      # @example
+      #   # EnforcedStyle: indent (default)
+      #
+      #   # bad
+      #   class Plumbus
+      #   private
+      #     def smooth; end
+      #   end
+      #
+      #   # good
+      #   class Plumbus
+      #     private
+      #     def smooth; end
+      #   end
+      #
+      #   # EnforcedStyle: outdent
+      #
+      #   # bad
+      #   class Plumbus
+      #     private
+      #     def smooth; end
+      #   end
+      #
+      #   # good
+      #   class Plumbus
+      #   private
+      #     def smooth; end
+      #   end
+      class AccessModifierIndentation < Cop
+        include AutocorrectAlignment
+        include ConfigurableEnforcedStyle
+        include AccessModifierNode
+
+        MSG = '%s access modifiers like `%s`.'.freeze
+
+        def on_class(node)
+          _name, _base_class, body = *node
+          check_body(body, node)
+        end
+
+        def on_sclass(node)
+          _name, body = *node
+          check_body(body, node)
+        end
+
+        def on_module(node)
+          _name, body = *node
+          check_body(body, node)
+        end
+
+        def on_block(node)
+          _method, _args, body = *node
+          check_body(body, node) if node.class_constructor?
+        end
+
+        private
+
+        def check_body(body, node)
+          return if body.nil? # Empty class etc.
+
+          modifiers = body.each_child_node.select { |c| modifier_node?(c) }
+          class_column = node.source_range.column
+
+          modifiers.each { |modifier| check_modifier(modifier, class_column) }
+        end
+
+        def check_modifier(send_node, class_start_col)
+          access_modifier_start_col = send_node.source_range.column
+          offset = access_modifier_start_col - class_start_col
+
+          @column_delta = expected_indent_offset - offset
+          if @column_delta.zero?
+            correct_style_detected
+          else
+            add_offense(send_node, :expression) do
+              if offset == unexpected_indent_offset
+                opposite_style_detected
+              else
+                unrecognized_style_detected
+              end
+            end
+          end
+        end
+
+        def message(node)
+          format(MSG, style.capitalize, node.loc.selector.source)
+        end
+
+        def expected_indent_offset
+          style == :outdent ? 0 : configured_indentation_width
+        end
+
+        # An offset that is not expected, but correct if the configuration is
+        # changed.
+        def unexpected_indent_offset
+          configured_indentation_width - expected_indent_offset
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/layout/align_array.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Here we check if the elements of a multi-line array literal are
+      # aligned.
+      #
+      # @example
+      #   # bad
+      #   a = [1, 2, 3
+      #     4, 5, 6]
+      #   array = ['run',
+      #        'forrest',
+      #        'run']
+      #
+      #   # good
+      #   a = [1, 2, 3
+      #        4, 5, 6]
+      #   a = ['run',
+      #        'forrest',
+      #        'run']
+      class AlignArray < Cop
+        include AutocorrectAlignment
+
+        MSG = 'Align the elements of an array literal if they span more ' \
+              'than one line.'.freeze
+
+        def on_array(node)
+          check_alignment(node.children)
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/layout/align_hash.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Check that the keys, separators, and values of a multi-line hash
+      # literal are aligned according to configuration. The configuration
+      # options are:
+      #
+      #   - key (left align keys)
+      #   - separator (align hash rockets and colons, right align keys)
+      #   - table (left align keys, hash rockets, and values)
+      #
+      # The treatment of hashes passed as the last argument to a method call
+      # can also be configured. The options are:
+      #
+      #   - always_inspect
+      #   - always_ignore
+      #   - ignore_implicit (without curly braces)
+      #   - ignore_explicit (with curly braces)
+      #
+      # @example
+      #
+      #   # EnforcedHashRocketStyle: key (default)
+      #   # EnforcedColonStyle: key (default)
+      #
+      #   # good
+      #   {
+      #     foo: bar,
+      #     ba: baz
+      #   }
+      #   {
+      #     :foo => bar,
+      #     :ba => baz
+      #   }
+      #
+      #   # bad
+      #   {
+      #     foo: bar,
+      #      ba: baz
+      #   }
+      #   {
+      #     :foo => bar,
+      #      :ba => baz
+      #   }
+      #
+      # @example
+      #
+      #   # EnforcedHashRocketStyle: separator
+      #   # EnforcedColonStyle: separator
+      #
+      #   #good
+      #   {
+      #     foo: bar,
+      #      ba: baz
+      #   }
+      #   {
+      #     :foo => bar,
+      #      :ba => baz
+      #   }
+      #
+      #   #bad
+      #   {
+      #     foo: bar,
+      #     ba: baz
+      #   }
+      #   {
+      #     :foo => bar,
+      #     :ba => baz
+      #   }
+      #   {
+      #     :foo => bar,
+      #     :ba  => baz
+      #   }
+      #
+      # @example
+      #
+      #   # EnforcedHashRocketStyle: table
+      #   # EnforcedColonStyle: table
+      #
+      #   #good
+      #   {
+      #     foo: bar,
+      #     ba:  baz
+      #   }
+      #   {
+      #     :foo => bar,
+      #     :ba  => baz
+      #   }
+      #
+      #   #bad
+      #   {
+      #     foo: bar,
+      #     ba: baz
+      #   }
+      #   {
+      #     :foo => bar,
+      #      :ba => baz
+      #   }
+      class AlignHash < Cop
+        include HashAlignment
+
+        MSG = 'Align the elements of a hash literal if they span more than ' \
+              'one line.'.freeze
+
+        def on_send(node)
+          return if double_splat?(node)
+
+          last_argument = node.last_argument
+
+          return unless last_argument.hash_type? &&
+                        ignore_hash_argument?(last_argument)
+
+          ignore_node(last_argument)
+        end
+
+        def on_hash(node)
+          return if ignored_node?(node)
+          return if node.pairs.empty? || node.single_line?
+
+          return unless alignment_for_hash_rockets.checkable_layout?(node) &&
+                        alignment_for_colons.checkable_layout?(node)
+
+          check_pairs(node)
+        end
+
+        private
+
+        attr_accessor :column_deltas
+
+        def double_splat?(node)
+          node.children.last.is_a?(Symbol)
+        end
+
+        def check_pairs(node)
+          first_pair = node.pairs.first
+          self.column_deltas = alignment_for(first_pair)
+                               .deltas_for_first_pair(first_pair, node)
+          add_offense(first_pair, :expression) unless good_alignment?
+
+          node.children.each do |current|
+            self.column_deltas = alignment_for(current)
+                                 .deltas(first_pair, current)
+            add_offense(current, :expression) unless good_alignment?
+          end
+        end
+
+        def ignore_hash_argument?(node)
+          case cop_config['EnforcedLastArgumentHashStyle']
+          when 'always_inspect'  then false
+          when 'always_ignore'   then true
+          when 'ignore_explicit' then node.braces?
+          when 'ignore_implicit' then !node.braces?
+          end
+        end
+
+        def alignment_for(pair)
+          if pair.hash_rocket?
+            alignment_for_hash_rockets
+          else
+            alignment_for_colons
+          end
+        end
+
+        def alignment_for_hash_rockets
+          @alignment_for_hash_rockets ||=
+            new_alignment('EnforcedHashRocketStyle')
+        end
+
+        def alignment_for_colons
+          @alignment_for_colons ||=
+            new_alignment('EnforcedColonStyle')
+        end
+
+        def autocorrect(node)
+          # We can't use the instance variable inside the lambda. That would
+          # just give each lambda the same reference and they would all get the
+          # last value of each. A local variable fixes the problem.
+          key_delta = column_deltas[:key] || 0
+
+          if !node.value
+            correct_no_value(key_delta, node.source_range)
+          else
+            correct_key_value(key_delta, node.key.source_range,
+                              node.value.source_range,
+                              node.loc.operator)
+          end
+        end
+
+        def correct_no_value(key_delta, key)
+          ->(corrector) { adjust(corrector, key_delta, key) }
+        end
+
+        def correct_key_value(key_delta, key, value, separator)
+          # We can't use the instance variable inside the lambda. That would
+          # just give each lambda the same reference and they would all get the
+          # last value of each. Some local variables fix the problem.
+          separator_delta = column_deltas[:separator] || 0
+          value_delta     = column_deltas[:value] || 0
+
+          key_column = key.column
+          key_delta = -key_column if key_delta < -key_column
+
+          lambda do |corrector|
+            adjust(corrector, key_delta, key)
+            adjust(corrector, separator_delta, separator)
+            adjust(corrector, value_delta, value)
+          end
+        end
+
+        def new_alignment(key)
+          case cop_config[key]
+          when 'key'       then KeyAlignment.new
+          when 'table'     then TableAlignment.new
+          when 'separator' then SeparatorAlignment.new
+          else raise "Unknown #{key}: #{cop_config[key]}"
+          end
+        end
+
+        def adjust(corrector, delta, range)
+          if delta > 0
+            corrector.insert_before(range, ' ' * delta)
+          elsif delta < 0
+            range = range_between(range.begin_pos - delta.abs, range.begin_pos)
+            corrector.remove(range)
+          end
+        end
+
+        def good_alignment?
+          column_deltas.values.all?(&:zero?)
+        end
+      end
+    end
+  end
+end