rubocop 0.75.1

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks for indentation of the first non-blank non-comment
+      # line in a file.
+      #
+      # @example
+      #   # bad
+      #      class A
+      #        def foo; end
+      #      end
+      #
+      #   # good
+      #   class A
+      #     def foo; end
+      #   end
+      #
+      class InitialIndentation < Cop
+        include RangeHelp
+
+        MSG = 'Indentation of first line in file detected.'
+
+        def investigate(_processed_source)
+          space_before(first_token) do |space|
+            add_offense(space, location: first_token.pos)
+          end
+        end
+
+        def autocorrect(range)
+          ->(corrector) { corrector.remove(range) }
+        end
+
+        private
+
+        def first_token
+          processed_source.find_token { |t| !t.text.start_with?('#') }
+        end
+
+        def space_before(token)
+          return unless token
+          return if token.column.zero?
+
+          space_range =
+            range_with_surrounding_space(range: token.pos,
+                                         side: :left,
+                                         newlines: 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 space_range == token.pos
+
+          yield range_between(space_range.begin_pos, token.begin_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks for unnecessary leading blank lines at the beginning
+      # of a file.
+      #
+      # @example
+      #
+      #   # bad
+      #   # (start of file)
+      #
+      #   class Foo
+      #   end
+      #
+      #   # bad
+      #   # (start of file)
+      #
+      #   # a comment
+      #
+      #   # good
+      #   # (start of file)
+      #   class Foo
+      #   end
+      #
+      #   # good
+      #   # (start of file)
+      #   # a comment
+      class LeadingBlankLines < Cop
+        MSG = 'Unnecessary blank line at the beginning of the source.'
+
+        def investigate(processed_source)
+          token = processed_source.tokens[0]
+          return unless token && token.line > 1
+
+          add_offense(processed_source.tokens[0],
+                      location: processed_source.tokens[0].pos)
+        end
+
+        def autocorrect(node)
+          range = Parser::Source::Range.new(processed_source.buffer,
+                                            0,
+                                            node.begin_pos)
+
+          lambda do |corrector|
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  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`, `=begin`- and `=end` comments, "shebang" directives,
+      # or rackup options.
+      #
+      # @example
+      #
+      #   # bad
+      #   #Some comment
+      #
+      #   # good
+      #   # Some comment
+      #
+      # @example AllowDoxygenCommentStyle: false (default)
+      #
+      #   # bad
+      #
+      #   #**
+      #   # Some comment
+      #   # Another line of comment
+      #   #*
+      #
+      # @example AllowDoxygenCommentStyle: true
+      #
+      #   # good
+      #
+      #   #**
+      #   # Some comment
+      #   # Another line of comment
+      #   #*
+      #
+      class LeadingCommentSpace < Cop
+        include RangeHelp
+
+        MSG = 'Missing space after `#`.'
+
+        def investigate(processed_source)
+          processed_source.each_comment do |comment|
+            next unless comment.text =~ /\A#+[^#\s=:+-]/
+            next if comment.loc.line == 1 && allowed_on_first_line?(comment)
+            next if allow_doxygen_comment? && doxygen_comment_style?(comment)
+
+            add_offense(comment)
+          end
+        end
+
+        def autocorrect(comment)
+          expr = comment.loc.expression
+          hash_mark = range_between(expr.begin_pos, expr.begin_pos + 1)
+
+          ->(corrector) { corrector.insert_after(hash_mark, ' ') }
+        end
+
+        private
+
+        def allowed_on_first_line?(comment)
+          shebang?(comment) || rackup_config_file? && rackup_options?(comment)
+        end
+
+        def shebang?(comment)
+          comment.text.start_with?('#!')
+        end
+
+        def rackup_options?(comment)
+          comment.text.start_with?('#\\')
+        end
+
+        def rackup_config_file?
+          File.basename(processed_source.file_path).eql?('config.ru')
+        end
+
+        def allow_doxygen_comment?
+          cop_config['AllowDoxygenCommentStyle']
+        end
+
+        def doxygen_comment_style?(comment)
+          comment.text.start_with?('#*')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module RuboCop
+  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 on 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 EnforcedStyle: symmetrical (default)
+      #     # bad
+      #     [ :a,
+      #       :b
+      #     ]
+      #
+      #     # bad
+      #     [
+      #       :a,
+      #       :b ]
+      #
+      #     # good
+      #     [ :a,
+      #       :b ]
+      #
+      #     # good
+      #     [
+      #       :a,
+      #       :b
+      #     ]
+      #
+      # @example EnforcedStyle: new_line
+      #     # bad
+      #     [
+      #       :a,
+      #       :b ]
+      #
+      #     # bad
+      #     [ :a,
+      #       :b ]
+      #
+      #     # good
+      #     [ :a,
+      #       :b
+      #     ]
+      #
+      #     # good
+      #     [
+      #       :a,
+      #       :b
+      #     ]
+      #
+      # @example EnforcedStyle: same_line
+      #     # bad
+      #     [ :a,
+      #       :b
+      #     ]
+      #
+      #     # bad
+      #     [
+      #       :a,
+      #       :b
+      #     ]
+      #
+      #     # good
+      #     [
+      #       :a,
+      #       :b ]
+      #
+      #     # good
+      #     [ :a,
+      #       :b ]
+      class MultilineArrayBraceLayout < Cop
+        include MultilineLiteralBraceLayout
+
+        SAME_LINE_MESSAGE = 'The closing array brace must be on the same ' \
+          'line as the last array element when the opening brace is on the ' \
+          'same line as the first array element.'
+
+        NEW_LINE_MESSAGE = 'The closing array brace must be on the line ' \
+          'after the last array element when the opening brace is on a ' \
+          'separate line from the first array element.'
+
+        ALWAYS_NEW_LINE_MESSAGE = 'The closing array brace must be on the ' \
+          'line after the last array element.'
+
+        ALWAYS_SAME_LINE_MESSAGE = 'The closing array brace must be on the ' \
+          'same line as the last array element.'
+
+        def on_array(node)
+          check_brace_layout(node)
+        end
+
+        def autocorrect(node)
+          MultilineLiteralBraceCorrector.new(node, processed_source)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop ensures that each item in a multi-line array
+      # starts on a separate line.
+      #
+      # @example
+      #
+      #   # bad
+      #   [
+      #     a, b,
+      #     c
+      #   ]
+      #
+      #   # good
+      #   [
+      #     a,
+      #     b,
+      #     c
+      #   ]
+      class MultilineArrayLineBreaks < Cop
+        include MultilineElementLineBreaks
+
+        MSG = 'Each item in a multi-line array must start ' \
+          'on a separate line.'
+
+        def on_array(node)
+          check_line_breaks(node, node.children)
+        end
+
+        def autocorrect(node)
+          EmptyLineCorrector.insert_before(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks whether the multiline assignments have a newline
+      # after the assignment operator.
+      #
+      # @example EnforcedStyle: new_line (default)
+      #   # bad
+      #   foo = if expression
+      #     'bar'
+      #   end
+      #
+      #   # good
+      #   foo =
+      #     if expression
+      #       'bar'
+      #     end
+      #
+      #   # good
+      #   foo =
+      #     begin
+      #       compute
+      #     rescue => e
+      #       nil
+      #     end
+      #
+      # @example EnforcedStyle: same_line
+      #   # good
+      #   foo = if expression
+      #     'bar'
+      #   end
+      class MultilineAssignmentLayout < Cop
+        include CheckAssignment
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        NEW_LINE_OFFENSE = 'Right hand side of multi-line assignment is on ' \
+          'the same line as the assignment operator `=`.'
+
+        SAME_LINE_OFFENSE = 'Right hand side of multi-line assignment is not ' \
+          'on the same line as the assignment operator `=`.'
+
+        def check_assignment(node, rhs)
+          return if node.send_type?
+          return unless rhs
+          return unless supported_types.include?(rhs.type)
+          return if rhs.first_line == rhs.last_line
+
+          check_by_enforced_style(node, rhs)
+        end
+
+        def check_by_enforced_style(node, rhs)
+          case style
+          when :new_line
+            check_new_line_offense(node, rhs)
+          when :same_line
+            check_same_line_offense(node, rhs)
+          end
+        end
+
+        def check_new_line_offense(node, rhs)
+          return unless node.loc.operator.line == rhs.first_line
+
+          add_offense(node, message: NEW_LINE_OFFENSE)
+        end
+
+        def check_same_line_offense(node, rhs)
+          return unless node.loc.operator.line != rhs.first_line
+
+          add_offense(node, message: SAME_LINE_OFFENSE)
+        end
+
+        def autocorrect(node)
+          case style
+          when :new_line
+            ->(corrector) { corrector.insert_after(node.loc.operator, "\n") }
+          when :same_line
+            range = range_between(node.loc.operator.end_pos,
+                                  extract_rhs(node).source_range.begin_pos)
+
+            ->(corrector) { corrector.replace(range, ' ') }
+          end
+        end
+
+        private
+
+        def supported_types
+          @supported_types ||= cop_config['SupportedTypes'].map(&:to_sym)
+        end
+      end
+    end
+  end
+end