rubbycop 0.49.0

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cop checks the . position in multi-line method calls.
+      class DotPosition < Cop
+        include ConfigurableEnforcedStyle
+
+        def on_send(node)
+          return unless node.dot?
+
+          if proper_dot_position?(node)
+            correct_style_detected
+          else
+            add_offense(node, :dot) { opposite_style_detected }
+          end
+        end
+
+        private
+
+        def message(_node)
+          'Place the . on the ' +
+            case style
+            when :leading
+              'next line, together with the method name.'
+            when :trailing
+              'previous line, together with the method call receiver.'
+            end
+        end
+
+        def proper_dot_position?(node)
+          receiver_line = node.receiver.source_range.end.line
+          selector_line = selector_range(node).line
+
+          # receiver and selector are on the same line
+          return true if selector_line == receiver_line
+
+          dot_line = node.loc.dot.line
+
+          # don't register an offense if there is a line comment between the
+          # dot and the selector otherwise, we might break the code while
+          # "correcting" it (even if there is just an extra blank line, treat
+          # it the same)
+          return true if line_between?(selector_line, dot_line)
+
+          correct_dot_position_style?(dot_line, selector_line)
+        end
+
+        def line_between?(first_line, second_line)
+          (first_line - second_line) > 1
+        end
+
+        def correct_dot_position_style?(dot_line, selector_line)
+          case style
+          when :leading then dot_line == selector_line
+          when :trailing then dot_line != selector_line
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(node.loc.dot)
+            case style
+            when :leading
+              corrector.insert_before(selector_range(node), '.')
+            when :trailing
+              corrector.insert_after(node.receiver.source_range, '.')
+            end
+          end
+        end
+
+        def selector_range(node)
+          if node.loc.selector
+            node.loc.selector
+          else
+            # l.(1) has no selector, so we use the opening parenthesis instead
+            node.loc.begin
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cops checks the alignment of else keywords. Normally they should
+      # be aligned with an if/unless/while/until/begin/def keyword, but there
+      # are special cases when they should follow the same rules as the
+      # alignment of end.
+      class ElseAlignment < Cop
+        include EndKeywordAlignment
+        include AutocorrectAlignment
+        include CheckAssignment
+
+        MSG = 'Align `%s` with `%s`.'.freeze
+
+        def on_if(node, base = nil)
+          return if ignored_node?(node)
+          return unless node.else? && begins_its_line?(node.loc.else)
+
+          check_alignment(base_range(node, base), node.loc.else)
+
+          else_branch = node.else_branch
+
+          return unless else_branch && else_branch.if_type? &&
+                        else_branch.elsif?
+
+          # If the `else` part is actually an `elsif`, we check the `elsif`
+          # node in case it contains an `else` within, because that `else`
+          # should have the same alignment (base).
+          on_if(else_branch, base)
+          # The `elsif` node will get an `on_if` call from the framework later,
+          # but we're done here, so we set it to ignored.
+          ignore_node(else_branch)
+        end
+
+        def on_rescue(node)
+          return unless node.loc.respond_to?(:else) && node.loc.else
+
+          parent = node.parent
+          parent = parent.parent if parent.ensure_type?
+          base = case parent.type
+                 when :def, :defs then base_for_method_definition(parent)
+                 when :kwbegin then parent.loc.begin
+                 else node.loc.keyword
+                 end
+          check_alignment(base, node.loc.else)
+        end
+
+        def on_case(node)
+          return unless node.else?
+
+          check_alignment(node.when_branches.last.loc.keyword, node.loc.else)
+        end
+
+        private
+
+        def base_range(node, base)
+          if base
+            base.source_range
+          else
+            lineage = [node, *node.each_ancestor(:if)]
+            lineage.find { |parent| parent.if? || parent.unless? }.loc.keyword
+          end
+        end
+
+        def base_for_method_definition(node)
+          parent = node.parent
+          if parent && parent.send_type?
+            parent.loc.selector # For example "private def ..."
+          else
+            node.loc.keyword
+          end
+        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
+
+          return unless rhs.if_type?
+
+          on_if(rhs, base)
+          ignore_node(rhs)
+        end
+
+        def check_alignment(base_range, else_range)
+          return unless begins_its_line?(else_range)
+
+          @column_delta = effective_column(base_range) - else_range.column
+          return if @column_delta.zero?
+
+          add_offense(else_range, else_range,
+                      format(MSG, else_range.source, base_range.source[/^\S*/]))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Checks for a newline after the final magic comment.
+      #
+      # @example
+      #   # good
+      #   # frozen_string_literal: true
+      #
+      #   # Some documentation for Person
+      #   class Person
+      #     # Some code
+      #   end
+      #
+      #   # bad
+      #   # frozen_string_literal: true
+      #   # Some documentation for Person
+      #   class Person
+      #     # Some code
+      #   end
+      class EmptyLineAfterMagicComment < Cop
+        MSG = 'Add an empty line after magic comments.'.freeze
+        BLANK_LINE = /\A\s*\z/
+
+        def investigate(source)
+          return unless source.ast &&
+                        (last_magic_comment = last_magic_comment(source))
+          return if source[last_magic_comment.loc.line] =~ BLANK_LINE
+
+          offending_range =
+            source_range(source.buffer, last_magic_comment.loc.line + 1, 0)
+
+          add_offense(offending_range, offending_range)
+        end
+
+        def autocorrect(token)
+          lambda do |corrector|
+            corrector.insert_before(token, "\n")
+          end
+        end
+
+        private
+
+        # Find the last magic comment in the source file.
+        #
+        # Take all comments that precede the first line of code, select the
+        # magic comments, and return the last magic comment in the file.
+        #
+        # @return [Parser::Source::Comment] if magic comments exist before code
+        # @return [nil] otherwise
+        def last_magic_comment(source)
+          source
+            .comments
+            .take_while { |comment| comment.loc.line < source.ast.loc.line }
+            .select     { |comment| MagicComment.parse(comment.text).any?  }
+            .last
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cop checks whether method definitions are
+      # separated by one empty line.
+      #
+      # `NumberOfEmptyLines` can be and integer (e.g. 1 by default) or
+      # an array (e.g. [1, 2]) to specificy a minimum and a maximum of
+      # empty lines.
+      #
+      # `AllowAdjacentOneLineDefs` can be used to configure is adjacent
+      # one line methods definitions are an offense
+      #
+      # @example
+      #
+      #   # bad
+      #   def a
+      #   end
+      #   def b
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #   def a
+      #   end
+      #
+      #   def b
+      #   end
+      class EmptyLineBetweenDefs < Cop
+        MSG = 'Use empty lines between method definitions.'.freeze
+
+        # We operate on `begin` nodes, instead of using `OnMethodDef`,
+        # so that we can walk over pairs of consecutive nodes and
+        # efficiently access a node's predecessor; #prev_node ends up
+        # doing a linear scan over siblings, so we don't want to call
+        # it on each def.
+        def on_begin(node)
+          node.children.each_cons(2) do |prev, n|
+            nodes = [prev, n]
+            check_defs(nodes) if nodes.all?(&method(:def_node?))
+          end
+        end
+
+        def check_defs(nodes)
+          return if blank_lines_between?(*nodes)
+          return if multiple_blank_lines_groups?(*nodes)
+          return if nodes.all?(&:single_line?) &&
+                    cop_config['AllowAdjacentOneLineDefs']
+
+          add_offense(nodes.last, :keyword)
+        end
+
+        private
+
+        def def_node?(node)
+          return unless node
+          node.def_type? || node.defs_type?
+        end
+
+        def multiple_blank_lines_groups?(first_def_node, second_def_node)
+          lines = lines_between_defs(first_def_node, second_def_node)
+          blank_start = lines.each_index.select { |i| lines[i].blank? }.max
+          non_blank_end = lines.each_index.reject { |i| lines[i].blank? }.min
+          return false if blank_start.nil? || non_blank_end.nil?
+          blank_start > non_blank_end
+        end
+
+        def blank_lines_between?(first_def_node, second_def_node)
+          count = blank_lines_count_between(first_def_node, second_def_node)
+          (minimum_empty_lines..maximum_empty_lines).cover?(count)
+        end
+
+        def blank_lines_count_between(first_def_node, second_def_node)
+          lines_between_defs(first_def_node, second_def_node).count(&:blank?)
+        end
+
+        def minimum_empty_lines
+          Array(cop_config['NumberOfEmptyLines']).first
+        end
+
+        def maximum_empty_lines
+          Array(cop_config['NumberOfEmptyLines']).last
+        end
+
+        def prev_node(node)
+          return nil unless node.sibling_index > 0
+
+          node.parent.children[node.sibling_index - 1]
+        end
+
+        def lines_between_defs(first_def_node, second_def_node)
+          line_range = def_end(first_def_node)..(def_start(second_def_node) - 2)
+
+          processed_source.lines[line_range]
+        end
+
+        def def_start(node)
+          node.loc.keyword.line
+        end
+
+        def def_end(node)
+          node.loc.end.line
+        end
+
+        def autocorrect(node)
+          prev_def = prev_node(node)
+
+          # finds position of first newline
+          end_pos = prev_def.loc.end.end_pos
+          source_buffer = prev_def.loc.end.source_buffer
+          newline_pos = source_buffer.source.index("\n", end_pos)
+
+          count = blank_lines_count_between(prev_def, node)
+
+          if count > maximum_empty_lines
+            autocorrect_remove_lines(newline_pos, count)
+          else
+            autocorrect_insert_lines(newline_pos, count)
+          end
+        end
+
+        def autocorrect_remove_lines(newline_pos, count)
+          difference = count - maximum_empty_lines
+          range_to_remove = range_between(newline_pos, newline_pos + difference)
+          lambda do |corrector|
+            corrector.remove(range_to_remove)
+          end
+        end
+
+        def autocorrect_insert_lines(newline_pos, count)
+          difference = minimum_empty_lines - count
+          where_to_insert = range_between(newline_pos, newline_pos + 1)
+          lambda do |corrector|
+            corrector.insert_after(where_to_insert, "\n" * difference)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cops checks for two or more consecutive blank lines.
+      class EmptyLines < Cop
+        MSG = 'Extra blank line detected.'.freeze
+        LINE_OFFSET = 2
+
+        def investigate(processed_source)
+          return if processed_source.tokens.empty?
+
+          lines = Set.new
+          processed_source.tokens.each do |token|
+            lines << token.pos.line
+          end
+
+          each_extra_empty_line(lines.sort) do |range|
+            add_offense(range, range)
+          end
+        end
+
+        def autocorrect(range)
+          ->(corrector) { corrector.remove(range) }
+        end
+
+        private
+
+        def each_extra_empty_line(lines)
+          prev_line = 1
+
+          lines.each do |cur_line|
+            if exceeds_line_offset?(cur_line - prev_line)
+              # we need to be wary of comments since they
+              # don't show up in the tokens
+              ((prev_line + 1)...cur_line).each do |line|
+                next unless previous_and_current_lines_empty?(line)
+
+                yield source_range(processed_source.buffer, line, 0)
+              end
+            end
+
+            prev_line = cur_line
+          end
+        end
+
+        def exceeds_line_offset?(line_diff)
+          line_diff > LINE_OFFSET
+        end
+
+        def previous_and_current_lines_empty?(line)
+          processed_source[line - 2].empty? && processed_source[line - 1].empty?
+        end
+      end
+    end
+  end
+end