rubbycop 0.49.0

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cops checks for inconsistent indentation.
+      #
+      # @example
+      #
+      #   class A
+      #     def test
+      #       puts 'hello'
+      #        puts 'world'
+      #     end
+      #   end
+      class IndentationConsistency < Cop
+        include AutocorrectAlignment
+        include AccessModifierNode
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Inconsistent indentation detected.'.freeze
+
+        def on_begin(node)
+          check(node)
+        end
+
+        def on_kwbegin(node)
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          children_to_check = [[]]
+          node.children.each do |child|
+            # Modifier nodes have special indentation and will be checked by
+            # the AccessModifierIndentation cop. This cop uses them as dividers
+            # in rails mode. Then consistency is checked only within each
+            # section delimited by a modifier node.
+            if modifier_node?(child)
+              children_to_check << [] if style == :rails
+            else
+              children_to_check.last << child
+            end
+          end
+          children_to_check.each { |group| check_alignment(group) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cops checks for indentation that doesn't use the specified number
+      # of spaces.
+      #
+      # See also the IndentationConsistency cop which is the companion to this
+      # one.
+      #
+      # @example
+      #   # bad, Width: 2
+      #   class A
+      #    def test
+      #     puts 'hello'
+      #    end
+      #   end
+      #
+      #   # bad, Width: 2,
+      #          IgnoredPatterns:
+      #            - '^\s*module'
+      #   module A
+      #   class B
+      #     def test
+      #     puts 'hello'
+      #     end
+      #   end
+      #   end
+      #
+      #   # good, Width: 2
+      #   class A
+      #     def test
+      #       puts 'hello'
+      #     end
+      #   end
+      #
+      #   # good, Width: 2,
+      #           IgnoredPatterns:
+      #             - '^\s*module'
+      #   module A
+      #   class B
+      #     def test
+      #       puts 'hello'
+      #     end
+      #   end
+      #   end
+      class IndentationWidth < Cop # rubbycop:disable Metrics/ClassLength
+        include EndKeywordAlignment
+        include AutocorrectAlignment
+        include OnMethodDef
+        include CheckAssignment
+        include AccessModifierNode
+        include IgnoredPattern
+
+        SPECIAL_MODIFIERS = %w[private protected].freeze
+
+        def on_rescue(node)
+          _begin_node, *_rescue_nodes, else_node = *node
+          check_indentation(node.loc.else, else_node)
+        end
+
+        def on_ensure(node)
+          check_indentation(node.loc.keyword, node.body)
+        end
+
+        alias on_resbody on_ensure
+        alias on_for     on_ensure
+
+        def on_kwbegin(node)
+          # Check indentation against end keyword but only if it's first on its
+          # line.
+          return unless begins_its_line?(node.loc.end)
+          check_indentation(node.loc.end, node.children.first)
+        end
+
+        def on_block(node)
+          _method, _args, body = *node
+          # Check body against end/} indentation. Checking against variable
+          # assignments, etc, would be more difficult. The end/} must be at the
+          # beginning of its line.
+          loc = node.loc
+          return unless begins_its_line?(loc.end)
+
+          check_indentation(loc.end, body)
+          return unless indentation_consistency_style == 'rails'
+
+          check_members(loc.end, [body])
+        end
+
+        def on_module(node)
+          _module_name, *members = *node
+          check_members(node.loc.keyword, members)
+        end
+
+        def on_class(node)
+          _class_name, _base_class, *members = *node
+          check_members(node.loc.keyword, members)
+        end
+
+        def on_send(node)
+          super
+          return unless modifier_and_def_on_same_line?(node)
+
+          *_, body = *node.first_argument
+
+          def_end_config = config.for_cop('Lint/DefEndAlignment')
+          style = def_end_config['EnforcedStyleAlignWith'] || 'start_of_line'
+          base = style == 'def' ? node.first_argument : node
+
+          check_indentation(base.source_range, body)
+          ignore_node(node.first_argument)
+        end
+
+        def on_method_def(node, _method_name, _args, body)
+          check_indentation(node.loc.keyword, body) unless ignored_node?(node)
+        end
+
+        def on_while(node, base = node)
+          return if ignored_node?(node)
+
+          return unless node.single_line_condition?
+
+          check_indentation(base.loc, node.body)
+        end
+
+        alias on_until on_while
+
+        def on_case(case_node)
+          case_node.each_when do |when_node|
+            check_indentation(when_node.loc.keyword, when_node.body)
+          end
+
+          check_indentation(case_node.when_branches.last.loc.keyword,
+                            case_node.else_branch)
+        end
+
+        def on_if(node, base = node)
+          return if ignored_node?(node) || !node.body
+          return if node.ternary? || node.modifier_form?
+
+          check_if(node, node.body, node.else_branch, base.loc)
+        end
+
+        private
+
+        def check_members(base, members)
+          check_indentation(base, members.first)
+
+          return unless members.any? && members.first.begin_type?
+          return unless indentation_consistency_style == 'rails'
+
+          each_member(members) do |member, previous_modifier|
+            check_indentation(previous_modifier, member,
+                              indentation_consistency_style)
+          end
+        end
+
+        def each_member(members)
+          previous_modifier = nil
+          members.first.children.each do |member|
+            if special_modifier?(member)
+              previous_modifier = member
+            elsif previous_modifier
+              yield member, previous_modifier.source_range
+              previous_modifier = nil
+            end
+          end
+        end
+
+        def special_modifier?(node)
+          modifier_node?(node) && SPECIAL_MODIFIERS.include?(node.source)
+        end
+
+        def indentation_consistency_style
+          config.for_cop('Layout/IndentationConsistency')['EnforcedStyle']
+        end
+
+        def check_assignment(node, rhs)
+          # If there are method calls chained to the right hand side of the
+          # assignment, we let rhs be the receiver of those method calls before
+          # we check its indentation.
+          rhs = first_part_of_call_chain(rhs)
+          return unless rhs
+
+          end_config = config.for_cop('Lint/EndAlignment')
+          style = end_config['EnforcedStyleAlignWith'] || 'keyword'
+          base = variable_alignment?(node.loc, rhs, style.to_sym) ? node : rhs
+
+          case rhs.type
+          when :if            then on_if(rhs, base)
+          when :while, :until then on_while(rhs, base)
+          else                     return
+          end
+
+          ignore_node(rhs)
+        end
+
+        def check_if(node, body, else_clause, base_loc)
+          return if node.ternary?
+
+          check_indentation(base_loc, body)
+          return unless else_clause
+
+          # If the else clause is an elsif, it will get its own on_if call so
+          # we don't need to process it here.
+          return if else_clause.if_type? && else_clause.elsif?
+
+          check_indentation(node.loc.else, else_clause)
+        end
+
+        def check_indentation(base_loc, body_node, style = 'normal')
+          return unless indentation_to_check?(base_loc, body_node)
+
+          indentation = body_node.loc.column - effective_column(base_loc)
+          @column_delta = configured_indentation_width - indentation
+          return if @column_delta.zero?
+
+          offense(body_node, indentation, style)
+        end
+
+        def offense(body_node, indentation, style)
+          # This cop only auto-corrects the first statement in a def body, for
+          # example.
+          if body_node.begin_type? && !parentheses?(body_node)
+            body_node = body_node.children.first
+          end
+
+          # Since autocorrect changes a number of lines, and not only the line
+          # where the reported offending range is, we avoid auto-correction if
+          # this cop has already found other offenses is the same
+          # range. Otherwise, two corrections can interfere with each other,
+          # resulting in corrupted code.
+          node = if autocorrect? && other_offense_in_same_range?(body_node)
+                   nil
+                 else
+                   body_node
+                 end
+
+          indentation_name = style == 'normal' ? '' : "#{style} "
+          add_offense(node, offending_range(body_node, indentation),
+                      format("Use #{configured_indentation_width} (not %d) " \
+                             "spaces for #{indentation_name}indentation.",
+                             indentation))
+        end
+
+        # Returns true if the given node is within another node that has
+        # already been marked for auto-correction by this cop.
+        def other_offense_in_same_range?(node)
+          expr = node.source_range
+          @offense_ranges ||= []
+
+          return true if @offense_ranges.any? { |r| within?(expr, r) }
+
+          @offense_ranges << expr
+          false
+        end
+
+        def indentation_to_check?(base_loc, body_node)
+          return false if skip_check?(base_loc, body_node)
+
+          if %i[rescue ensure].include?(body_node.type)
+            block_body, = *body_node
+            return unless block_body
+          end
+
+          true
+        end
+
+        def skip_check?(base_loc, body_node)
+          return true if ignored_line?(base_loc)
+          return true unless body_node
+
+          # Don't check if expression is on same line as "then" keyword, etc.
+          return true if body_node.loc.line == base_loc.line
+
+          return true if starts_with_access_modifier?(body_node)
+
+          # Don't check indentation if the line doesn't start with the body.
+          # For example, lines like "else do_something".
+          first_char_pos_on_line = body_node.source_range.source_line =~ /\S/
+          return true unless body_node.loc.column == first_char_pos_on_line
+        end
+
+        def offending_range(body_node, indentation)
+          expr = body_node.source_range
+          begin_pos = expr.begin_pos
+          ind = expr.begin_pos - indentation
+          pos = indentation >= 0 ? ind..begin_pos : begin_pos..ind
+          range_between(pos.begin, pos.end)
+        end
+
+        def starts_with_access_modifier?(body_node)
+          body_node.begin_type? && modifier_node?(body_node.children.first)
+        end
+
+        def configured_indentation_width
+          cop_config['Width']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cops checks for indentation of the first non-blank non-comment
+      # line in a file.
+      class InitialIndentation < Cop
+        MSG = 'Indentation of first line in file detected.'.freeze
+
+        def investigate(_processed_source)
+          token = first_token
+          space_before(token) { |space| add_offense(space, token.pos) }
+        end
+
+        def autocorrect(range)
+          ->(corrector) { corrector.remove(range) }
+        end
+
+        private
+
+        def first_token
+          processed_source.tokens.find { |t| !t.text.start_with?('#') }
+        end
+
+        def space_before(token)
+          return unless token
+          return if token.pos.column.zero?
+
+          token_with_space =
+            range_with_surrounding_space(token.pos, :left, false)
+          # If the file starts with a byte order mark (BOM), the column can be
+          # non-zero, but then we find out here if there's no space to the left
+          # of the first token.
+          return if token_with_space == token.pos
+
+          yield range_between(token_with_space.begin_pos, token.pos.begin_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cop checks whether comments have a leading space
+      # after the # denoting the start of the comment. The
+      # leading space is not required for some RDoc special syntax,
+      # like #++, #--, #:nodoc, etc. Neither is it required for
+      # =begin/=end comments.
+      class LeadingCommentSpace < Cop
+        MSG = 'Missing space after #.'.freeze
+
+        def investigate(processed_source)
+          processed_source.comments.each do |comment|
+            next unless comment.text =~ /\A#+[^#\s=:+-]/
+            next if comment.text.start_with?('#!') && comment.loc.line == 1
+
+            # in config.ru files, if the first line starts with #\ it is treated
+            # as options (e.g. `#\ -p 8765` sets the request port to 8765)
+            next if comment.text.start_with?('#\\') && comment.loc.line == 1 &&
+                    config_ru?(processed_source.buffer.name)
+
+            add_offense(comment, :expression)
+          end
+        end
+
+        def autocorrect(comment)
+          expr = comment.loc.expression
+          b = expr.begin_pos
+          hash_mark = range_between(b, b + 1)
+          ->(corrector) { corrector.insert_after(hash_mark, ' ') }
+        end
+
+        private
+
+        def config_ru?(file_path)
+          File.basename(file_path).eql?('config.ru')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cop checks that the closing brace in an array literal is either
+      # on the same line as the last array element, or a new line.
+      #
+      # When using the `symmetrical` (default) style:
+      #
+      # If an array's opening brace is on the same line as the first element
+      # of the array, then the closing brace should be on the same line as
+      # the last element of the array.
+      #
+      # If an array's opening brace is on the line above the first element
+      # of the array, then the closing brace should be on the line below
+      # the last element of the array.
+      #
+      # When using the `new_line` style:
+      #
+      # The closing brace of a multi-line array literal must be on the line
+      # after the last element of the array.
+      #
+      # When using the `same_line` style:
+      #
+      # The closing brace of a multi-line array literal must be on the same
+      # line as the last element of the array.
+      #
+      # @example
+      #
+      #     # symmetrical: bad
+      #     # new_line: good
+      #     # same_line: bad
+      #     [ :a,
+      #       :b
+      #     ]
+      #
+      #     # symmetrical: bad
+      #     # new_line: bad
+      #     # same_line: good
+      #     [
+      #       :a,
+      #       :b ]
+      #
+      #     # symmetrical: good
+      #     # new_line: bad
+      #     # same_line: good
+      #     [ :a,
+      #       :b ]
+      #
+      #     # symmetrical: good
+      #     # new_line: good
+      #     # same_line: bad
+      #     [
+      #       :a,
+      #       :b
+      #     ]
+      class MultilineArrayBraceLayout < Cop
+        include MultilineLiteralBraceLayout
+
+        SAME_LINE_MESSAGE = 'Closing array brace must be on the same line as ' \
+          'the last array element when opening brace is on the same line as ' \
+          'the first array element.'.freeze
+
+        NEW_LINE_MESSAGE = 'Closing array brace must be on the line after ' \
+          'the last array element when opening brace is on a separate line ' \
+          'from the first array element.'.freeze
+
+        ALWAYS_NEW_LINE_MESSAGE = 'Closing array brace must be on the line ' \
+          'after the last array element.'.freeze
+
+        ALWAYS_SAME_LINE_MESSAGE = 'Closing array brace must be on the same ' \
+          'line as teh last array element.'.freeze
+
+        def on_array(node)
+          check_brace_layout(node)
+        end
+      end
+    end
+  end
+end