rubbycop 0.49.0

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Access modifiers should be surrounded by blank lines.
+      class EmptyLinesAroundAccessModifier < Cop
+        include AccessModifierNode
+
+        MSG_AFTER = 'Keep a blank line after `%s`.'.freeze
+        MSG_BEFORE_AND_AFTER = 'Keep a blank line before and after `%s`.'.freeze
+
+        def on_send(node)
+          return unless modifier_node?(node)
+
+          return if empty_lines_around?(node)
+
+          add_offense(node, :expression)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            send_line = node.loc.line
+            previous_line = processed_source[send_line - 2]
+            next_line = processed_source[send_line]
+            line = range_by_whole_lines(node.source_range)
+
+            unless previous_line_empty?(previous_line)
+              corrector.insert_before(line, "\n")
+            end
+
+            unless next_line_empty?(next_line)
+              corrector.insert_after(line, "\n")
+            end
+          end
+        end
+
+        private
+
+        def previous_line_ignoring_comments(processed_source, send_line)
+          processed_source[0..send_line - 2].reverse.find do |line|
+            !comment_line?(line)
+          end
+        end
+
+        def previous_line_empty?(previous_line)
+          block_start?(previous_line) ||
+            class_def?(previous_line) ||
+            previous_line.blank?
+        end
+
+        def next_line_empty?(next_line)
+          body_end?(next_line) || next_line.blank?
+        end
+
+        def empty_lines_around?(node)
+          send_line = node.loc.line
+          previous_line = previous_line_ignoring_comments(processed_source,
+                                                          send_line)
+          next_line = processed_source[send_line]
+
+          previous_line_empty?(previous_line) && next_line_empty?(next_line)
+        end
+
+        def class_def?(line)
+          line =~ /^\s*(class|module)/
+        end
+
+        def block_start?(line)
+          line.match(/ (do|{)( \|.*?\|)?\s?$/)
+        end
+
+        def body_end?(line)
+          line =~ /^\s*end/
+        end
+
+        def message(node)
+          previous_line = processed_source[node.loc.line - 2]
+
+          if block_start?(previous_line) ||
+             class_def?(previous_line)
+            format(MSG_AFTER, node.loc.selector.source)
+          else
+            format(MSG_BEFORE_AND_AFTER, node.loc.selector.source)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cops checks if empty lines exist around the bodies of begin-end
+      # blocks.
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   begin
+      #     ...
+      #   end
+      #
+      #   # bad
+      #
+      #   begin
+      #
+      #     ...
+      #
+      #   end
+      class EmptyLinesAroundBeginBody < Cop
+        include EmptyLinesAroundBody
+
+        KIND = '`begin`'.freeze
+
+        def on_kwbegin(node)
+          check(node, nil)
+        end
+
+        private
+
+        def style
+          :no_empty_lines
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cops checks if empty lines around the bodies of blocks match
+      # the configuration.
+      #
+      # @example
+      #
+      #   # EnforcedStyle: empty_lines
+      #
+      #   # good
+      #
+      #   foo do |bar|
+      #
+      #     ...
+      #
+      #   end
+      #
+      #   # EnforcedStyle: no_empty_lines
+      #
+      #   # good
+      #
+      #   foo do |bar|
+      #     ...
+      #   end
+      class EmptyLinesAroundBlockBody < Cop
+        include EmptyLinesAroundBody
+
+        KIND = 'block'.freeze
+
+        def on_block(node)
+          _send, _args, body = *node
+
+          check(node, body)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cops checks if empty lines around the bodies of classes match
+      # the configuration.
+      #
+      # @example
+      #
+      #   EnforcedStyle: empty_lines
+      #
+      #   # good
+      #
+      #   class Foo
+      #
+      #      def bar
+      #        ...
+      #      end
+      #
+      #   end
+      class EmptyLinesAroundClassBody < Cop
+        include EmptyLinesAroundBody
+
+        KIND = 'class'.freeze
+
+        def on_class(node)
+          _name, _superclass, body = *node
+          check(node, body)
+        end
+
+        def on_sclass(node)
+          _obj, body = *node
+          check(node, body)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cops checks if empty lines exist around the bodies of `begin`
+      # sections. This cop doesn't check empty lines at `begin` body
+      # beginning/end and around method definition body.
+      # `Style/EmptyLinesAroundBeginBody` or `Style/EmptyLinesAroundMethodBody`
+      # can be used for this purpose.
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   begin
+      #     do_something
+      #   rescue
+      #     do_something2
+      #   else
+      #     do_something3
+      #   ensure
+      #     do_something4
+      #   end
+      #
+      #   # good
+      #
+      #   def foo
+      #     do_something
+      #   rescue
+      #     do_something2
+      #   end
+      #
+      #   # bad
+      #
+      #   begin
+      #     do_something
+      #
+      #   rescue
+      #
+      #     do_something2
+      #
+      #   else
+      #
+      #     do_something3
+      #
+      #   ensure
+      #
+      #     do_something4
+      #   end
+      #
+      #   # bad
+      #
+      #   def foo
+      #     do_something
+      #
+      #   rescue
+      #
+      #     do_something2
+      #   end
+      class EmptyLinesAroundExceptionHandlingKeywords < Cop
+        include EmptyLinesAroundBody
+        include OnMethodDef
+
+        MSG = 'Extra empty line detected %s the `%s`.'.freeze
+
+        def on_method_def(_node, _method_name, _args, body)
+          check_body(body)
+        end
+
+        def on_kwbegin(node)
+          body, = *node
+          check_body(body)
+        end
+
+        private
+
+        def check_body(node)
+          locations = keyword_locations(node)
+          locations.each do |loc|
+            line = loc.line
+            keyword = loc.source
+            # below the keyword
+            check_line(style, line, format(MSG, 'after', keyword), &:empty?)
+            # above the keyword
+            check_line(style,
+                       line - 2,
+                       format(MSG, 'before', keyword),
+                       &:empty?)
+          end
+        end
+
+        def style
+          :no_empty_lines
+        end
+
+        def keyword_locations(node)
+          return [] unless node
+          case node.type
+          when :rescue
+            keyword_locations_in_rescue(node)
+          when :ensure
+            keyword_locations_in_ensure(node)
+          else
+            []
+          end
+        end
+
+        def keyword_locations_in_rescue(node)
+          _begin_body, *resbodies, _else_body = *node
+          [
+            node.loc.else,
+            *resbodies.map { |body| body.loc.keyword }
+          ].compact
+        end
+
+        def keyword_locations_in_ensure(node)
+          ensure_body, = *node
+          [
+            node.loc.keyword,
+            *keyword_locations(ensure_body)
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cops checks if empty lines exist around the bodies of methods.
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def foo
+      #     ...
+      #   end
+      #
+      #   # bad
+      #
+      #   def bar
+      #
+      #     ...
+      #
+      #   end
+      class EmptyLinesAroundMethodBody < Cop
+        include EmptyLinesAroundBody
+        include OnMethodDef
+
+        KIND = 'method'.freeze
+
+        def on_method_def(node, _method_name, _args, body)
+          check(node, body)
+        end
+
+        private
+
+        def style
+          :no_empty_lines
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cops checks if empty lines around the bodies of modules match
+      # the configuration.
+      #
+      # @example
+      #
+      #   EnforcedStyle: empty_lines
+      #
+      #   # good
+      #
+      #   module Foo
+      #
+      #     def bar
+      #       ...
+      #     end
+      #
+      #   end
+      #
+      #   EnforcedStyle: no_empty_lines
+      #
+      #   # good
+      #
+      #   module Foo
+      #     def bar
+      #       ...
+      #     end
+      #   end
+      class EmptyLinesAroundModuleBody < Cop
+        include EmptyLinesAroundBody
+
+        KIND = 'module'.freeze
+
+        def on_module(node)
+          _name, body = *node
+          check(node, body)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cop checks for Windows-style line endings in the source code.
+      class EndOfLine < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG_DETECTED = 'Carriage return character detected.'.freeze
+        MSG_MISSING = 'Carriage return character missing.'.freeze
+
+        def investigate(processed_source)
+          last_token = processed_source.tokens.last
+          last_line =
+            last_token ? last_token.pos.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, range, 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