rubocop 0.75.1

data/lib/rubocop/cop/layout/empty_lines_around_module_body.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks if empty lines around the bodies of modules match
+      # the configuration.
+      #
+      # @example EnforcedStyle: empty_lines
+      #   # good
+      #
+      #   module Foo
+      #
+      #     def bar
+      #       # ...
+      #     end
+      #
+      #   end
+      #
+      # @example EnforcedStyle: empty_lines_except_namespace
+      #   # good
+      #
+      #   module Foo
+      #     module Bar
+      #
+      #       # ...
+      #
+      #     end
+      #   end
+      #
+      # @example EnforcedStyle: empty_lines_special
+      #   # good
+      #   module Foo
+      #
+      #     def bar; end
+      #
+      #   end
+      #
+      # @example EnforcedStyle: no_empty_lines (default)
+      #   # good
+      #
+      #   module Foo
+      #     def bar
+      #       # ...
+      #     end
+      #   end
+      class EmptyLinesAroundModuleBody < Cop
+        include EmptyLinesAroundBody
+
+        KIND = 'module'
+
+        def on_module(node)
+          check(node, node.body)
+        end
+
+        def autocorrect(node)
+          EmptyLineCorrector.correct(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/end_alignment.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks whether the end keywords are aligned properly.
+      #
+      # Three modes are supported through the `EnforcedStyleAlignWith`
+      # configuration parameter:
+      #
+      # If it's set to `keyword` (which is the default), the `end`
+      # shall be aligned with the start of the keyword (if, class, etc.).
+      #
+      # If it's set to `variable` the `end` shall be aligned with the
+      # left-hand-side of the variable assignment, if there is one.
+      #
+      # If it's set to `start_of_line`, the `end` shall be aligned with the
+      # start of the line where the matching keyword appears.
+      #
+      # @example EnforcedStyleAlignWith: keyword (default)
+      #   # bad
+      #
+      #   variable = if true
+      #       end
+      #
+      #   # good
+      #
+      #   variable = if true
+      #              end
+      #
+      #   variable =
+      #     if true
+      #     end
+      #
+      # @example EnforcedStyleAlignWith: variable
+      #   # bad
+      #
+      #   variable = if true
+      #       end
+      #
+      #   # good
+      #
+      #   variable = if true
+      #   end
+      #
+      #   variable =
+      #     if true
+      #     end
+      #
+      # @example EnforcedStyleAlignWith: start_of_line
+      #   # bad
+      #
+      #   variable = if true
+      #       end
+      #
+      #   puts(if true
+      #        end)
+      #
+      #   # good
+      #
+      #   variable = if true
+      #   end
+      #
+      #   puts(if true
+      #   end)
+      #
+      #   variable =
+      #     if true
+      #     end
+      class EndAlignment < Cop
+        include CheckAssignment
+        include EndKeywordAlignment
+        include RangeHelp
+
+        def on_class(node)
+          check_other_alignment(node)
+        end
+
+        def on_module(node)
+          check_other_alignment(node)
+        end
+
+        def on_if(node)
+          check_other_alignment(node) unless node.ternary?
+        end
+
+        def on_while(node)
+          check_other_alignment(node)
+        end
+
+        def on_until(node)
+          check_other_alignment(node)
+        end
+
+        def on_case(node)
+          if node.argument?
+            check_asgn_alignment(node.parent, node)
+          else
+            check_other_alignment(node)
+          end
+        end
+
+        def autocorrect(node)
+          AlignmentCorrector.align_end(processed_source,
+                                       node,
+                                       alignment_node(node))
+        end
+
+        private
+
+        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 if it's an if/unless/while/until.
+          return unless (rhs = first_part_of_call_chain(rhs))
+          return unless rhs.conditional?
+          return if rhs.if_type? && rhs.ternary?
+
+          check_asgn_alignment(node, rhs)
+        end
+
+        def check_asgn_alignment(outer_node, inner_node)
+          align_with = {
+            keyword: inner_node.loc.keyword,
+            start_of_line: start_line_range(inner_node),
+            variable: asgn_variable_align_with(outer_node, inner_node)
+          }
+
+          check_end_kw_alignment(inner_node, align_with)
+          ignore_node(inner_node)
+        end
+
+        def asgn_variable_align_with(outer_node, inner_node)
+          expr = outer_node.source_range
+
+          if !line_break_before_keyword?(expr, inner_node)
+            range_between(expr.begin_pos, inner_node.loc.keyword.end_pos)
+          else
+            inner_node.loc.keyword
+          end
+        end
+
+        def check_other_alignment(node)
+          align_with = {
+            keyword: node.loc.keyword,
+            variable: node.loc.keyword,
+            start_of_line: start_line_range(node)
+          }
+          check_end_kw_alignment(node, align_with)
+        end
+
+        def alignment_node(node)
+          if style == :keyword
+            node
+          elsif style == :variable
+            alignment_node_for_variable_style(node)
+          else
+            start_line_range(node)
+          end
+        end
+
+        def alignment_node_for_variable_style(node)
+          return node.parent if node.case_type? && node.argument?
+
+          assignment = node.ancestors.find(&:assignment_or_similar?)
+          if assignment && !line_break_before_keyword?(assignment.source_range,
+                                                       node)
+            assignment
+          else
+            # Fall back to 'keyword' style if this node is not on the RHS of an
+            # assignment, or if it is but there's a line break between LHS and
+            # RHS.
+            node
+          end
+        end
+
+        def start_line_range(node)
+          expr   = node.source_range
+          buffer = expr.source_buffer
+          source = buffer.source_line(expr.line)
+          range  = buffer.line_range(expr.line)
+
+          range_between(range.begin_pos + (source =~ /\S/),
+                        range.begin_pos + (source =~ /\s*\z/))
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/end_of_line.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks for Windows-style line endings in the source code.
+      #
+      # @example EnforcedStyle: native (default)
+      #   # The `native` style means that CR+LF (Carriage Return + Line Feed) is
+      #   # enforced on Windows, and LF is enforced on other platforms.
+      #
+      #   # bad
+      #   puts 'Hello' # Return character is LF on Windows.
+      #   puts 'Hello' # Return character is CR+LF on other than Windows.
+      #
+      #   # good
+      #   puts 'Hello' # Return character is CR+LF on Windows.
+      #   puts 'Hello' # Return character is LF on other than Windows.
+      #
+      # @example EnforcedStyle: lf
+      #   # The `lf` style means that LF (Line Feed) is enforced on
+      #   # all platforms.
+      #
+      #   # bad
+      #   puts 'Hello' # Return character is CR+LF on all platfoms.
+      #
+      #   # good
+      #   puts 'Hello' # Return character is LF on all platfoms.
+      #
+      # @example EnforcedStyle: crlf
+      #   # The `crlf` style means that CR+LF (Carriage Return + Line Feed) is
+      #   # enforced on all platforms.
+      #
+      #   # bad
+      #   puts 'Hello' # Return character is LF on all platfoms.
+      #
+      #   # good
+      #   puts 'Hello' # Return character is CR+LF on all platfoms.
+      #
+      class EndOfLine < Cop
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        MSG_DETECTED = 'Carriage return character detected.'
+        MSG_MISSING = 'Carriage return character missing.'
+
+        def investigate(processed_source)
+          last_token = processed_source.tokens.last
+          last_line =
+            last_token ? last_token.line : processed_source.lines.length
+
+          processed_source.raw_source.each_line.with_index do |line, index|
+            break if index >= last_line
+
+            msg = offense_message(line)
+            next unless msg
+            next if unimportant_missing_cr?(index, last_line, line)
+
+            range =
+              source_range(processed_source.buffer, index + 1, 0, line.length)
+            add_offense(nil, location: range, message: msg)
+            # Usually there will be carriage return characters on all or none
+            # of the lines in a file, so we report only one offense.
+            break
+          end
+        end
+
+        # If there is no LF on the last line, we don't care if there's no CR.
+        def unimportant_missing_cr?(index, last_line, line)
+          style == :crlf && index == last_line - 1 && line !~ /\n$/
+        end
+
+        def offense_message(line)
+          effective_style = if style == :native
+                              Platform.windows? ? :crlf : :lf
+                            else
+                              style
+                            end
+          case effective_style
+          when :lf then MSG_DETECTED if line =~ /\r$/
+          else MSG_MISSING if line !~ /\r$/
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/extra_spacing.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks for extra/unnecessary whitespace.
+      #
+      # @example
+      #
+      #   # good if AllowForAlignment is true
+      #   name      = "RuboCop"
+      #   # Some comment and an empty line
+      #
+      #   website  += "/rubocop-hq/rubocop" unless cond
+      #   puts        "rubocop"          if     debug
+      #
+      #   # bad for any configuration
+      #   set_app("RuboCop")
+      #   website  = "https://github.com/rubocop-hq/rubocop"
+      #
+      #   # good only if AllowBeforeTrailingComments is true
+      #   object.method(arg)  # this is a comment
+      #
+      #   # good even if AllowBeforeTrailingComments is false or not set
+      #   object.method(arg) # this is a comment
+      #
+      #   # good with either AllowBeforeTrailingComments or AllowForAlignment
+      #   object.method(arg)         # this is a comment
+      #   another_object.method(arg) # this is another comment
+      #   some_object.method(arg)    # this is some comment
+      class ExtraSpacing < Cop
+        include PrecedingFollowingAlignment
+        include RangeHelp
+
+        MSG_UNNECESSARY = 'Unnecessary spacing detected.'
+        MSG_UNALIGNED_ASGN = '`=` is not aligned with the %<location>s ' \
+                             'assignment.'
+
+        def investigate(processed_source)
+          return if processed_source.blank?
+
+          @corrected = Set.new if force_equal_sign_alignment?
+
+          processed_source.tokens.each_cons(2) do |token1, token2|
+            check_tokens(processed_source.ast, token1, token2)
+          end
+        end
+
+        def autocorrect(range)
+          lambda do |corrector|
+            if range.source.end_with?('=')
+              align_equal_signs(range, corrector)
+            else
+              corrector.remove(range)
+            end
+          end
+        end
+
+        private
+
+        def check_tokens(ast, token1, token2)
+          return if token2.type == :tNL
+
+          if force_equal_sign_alignment? && assignment_tokens.include?(token2)
+            check_assignment(token2)
+          else
+            check_other(token1, token2, ast)
+          end
+        end
+
+        def check_assignment(token)
+          return unless aligned_with_preceding_assignment(token) == :no
+
+          message = format(MSG_UNALIGNED_ASGN, location: 'preceding')
+          add_offense(token.pos, location: token.pos, message: message)
+        end
+
+        def check_other(token1, token2, ast)
+          return false if allow_for_trailing_comments? &&
+                          token2.text.start_with?('#')
+
+          extra_space_range(token1, token2) do |range|
+            next if ignored_range?(ast, range.begin_pos)
+
+            add_offense(range, location: range, message: MSG_UNNECESSARY)
+          end
+        end
+
+        def extra_space_range(token1, token2)
+          return if token1.line != token2.line
+
+          start_pos = token1.end_pos
+          end_pos = token2.begin_pos - 1
+          return if end_pos <= start_pos
+
+          return if allow_for_alignment? && aligned_tok?(token2)
+
+          yield range_between(start_pos, end_pos)
+        end
+
+        def aligned_tok?(token)
+          if token.comment?
+            aligned_comments?(token)
+          else
+            aligned_with_something?(token.pos)
+          end
+        end
+
+        def ignored_range?(ast, start_pos)
+          ignored_ranges(ast).any? { |r| r.include?(start_pos) }
+        end
+
+        # Returns an array of ranges that should not be reported. It's the
+        # extra spaces between the keys and values in a multiline hash,
+        # since those are handled by the Style/AlignHash cop.
+        def ignored_ranges(ast)
+          return [] unless ast
+
+          @ignored_ranges ||= on_node(:pair, ast).map do |pair|
+            next if pair.parent.single_line?
+
+            key, value = *pair
+            key.source_range.end_pos...value.source_range.begin_pos
+          end.compact
+        end
+
+        def aligned_comments?(comment_token)
+          ix = processed_source.comments.index do |comment|
+            comment.loc.expression.begin_pos == comment_token.begin_pos
+          end
+          aligned_with_previous_comment?(ix) || aligned_with_next_comment?(ix)
+        end
+
+        def aligned_with_previous_comment?(index)
+          index.positive? && comment_column(index - 1) == comment_column(index)
+        end
+
+        def aligned_with_next_comment?(index)
+          index < processed_source.comments.length - 1 &&
+            comment_column(index + 1) == comment_column(index)
+        end
+
+        def comment_column(index)
+          processed_source.comments[index].loc.column
+        end
+
+        def force_equal_sign_alignment?
+          cop_config['ForceEqualSignAlignment']
+        end
+
+        def align_equal_signs(range, corrector)
+          lines  = all_relevant_assignment_lines(range.line)
+          tokens = assignment_tokens.select { |t| lines.include?(t.line) }
+
+          columns  = tokens.map { |t| align_column(t) }
+          align_to = columns.max
+
+          tokens.each { |token| align_equal_sign(corrector, token, align_to) }
+        end
+
+        def align_equal_sign(corrector, token, align_to)
+          return unless @corrected.add?(token)
+
+          diff = align_to - token.pos.last_column
+
+          if diff.positive?
+            corrector.insert_before(token.pos, ' ' * diff)
+          elsif diff.negative?
+            corrector.remove_preceding(token.pos, -diff)
+          end
+        end
+
+        def all_relevant_assignment_lines(line_number)
+          last_line_number = processed_source.lines.size
+
+          (
+            relevant_assignment_lines(line_number.downto(1)) +
+            relevant_assignment_lines(line_number.upto(last_line_number))
+          )
+            .uniq
+            .sort
+        end
+
+        def align_column(asgn_token)
+          # if we removed unneeded spaces from the beginning of this =,
+          # what column would it end from?
+          line    = processed_source.lines[asgn_token.line - 1]
+          leading = line[0...asgn_token.column]
+          spaces  = leading.size - (leading =~ / *\Z/)
+          asgn_token.pos.last_column - spaces + 1
+        end
+
+        def allow_for_trailing_comments?
+          cop_config['AllowBeforeTrailingComments']
+        end
+      end
+    end
+  end
+end