yoshiki 11.0.0.pre.12 → 11.0.0.pre.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7880f8dd34e18f32da07f286fdabfecfad92b70f420a0cc11f4a69768b84980d
-  data.tar.gz: 6a11267e9a64df75b2708935076400fdb6898ef5872a262ec04edc9ae0971dc8
+  metadata.gz: 35fa2afafcdcf1908eb5090d37ab33868394bc5bd449e14bcb24015d4bedb038
+  data.tar.gz: e70d04d068aa8805eb5c01cad47cfa7225d93d7b9a2a1e9828ee24ed11ccb5e3
 SHA512:
-  metadata.gz: d458f79d7411fc843cf6bd3518f02a251b1d27a4492323739fd430358391b93fc8d04f00103e7068f00016cea41ff3486db707b5c19ece209872485f9f70d7d8
-  data.tar.gz: 328635ca21159c25ed41674d1aac844495168d4ba19306cc28d264d981d292594e578a87d6f037380893d519a21cebf01d2515bf540e8a48353ce41adbe7f438
+  metadata.gz: 9737edb1d4b3c105116cdfe2e94fecca8e4f201fb8604db9044e518181dff395f0d518261b6e45dcb5c3d97e44e4b51037c80f3ed06fa6dd032d1b501a2320d8
+  data.tar.gz: 4c37de5c3f6523515590690317d2c32d7427ea5717a02ff69ed682022658976d512da303da5a754f15a9d9f795120d17a761f92061c2f89ebad9e82c07b9a773

data/.yoshiki-ruby.yml

@@ -185,6 +185,12 @@ Style/TrailingUnderscoreVariable:
 
 Yoshiki/Layout/EmptyLineBeforeComment:
   Enabled: true
+Yoshiki/Layout/EmptyLineAroundMultilineAssignment:
+  Enabled: true
+Yoshiki/Layout/EmptyLineAroundMultilineBlock:
+  Enabled: true
+Yoshiki/Layout/EmptyLineAroundMultilineConditional:
+  Enabled: true
 Yoshiki/Layout/HangingKeywordArguments:
   Enabled: true
   MinKeywords: 2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    yoshiki (11.0.0.pre.12)
+    yoshiki (11.0.0.pre.13)
       rubocop (= 1.89.0)
       rubocop-performance (= 1.26.1)
       rubocop-rake (= 0.7.1)

data/lib/rubocop/cop/yoshiki/empty_line_around_multiline_statement/paragraph.rb

@@ -0,0 +1,81 @@
+module RuboCop
+  module Cop
+    module Yoshiki
+      module EmptyLineAroundMultilineStatement
+        # Classifies begin-sequence statements that should be their own paragraph.
+        module Paragraph
+
+          BLOCK_TYPES       = %i[block numblock itblock].freeze
+          CONDITIONAL_TYPES = %i[if case case_match while until for kwbegin].freeze
+          BODY_TYPES        = (BLOCK_TYPES + CONDITIONAL_TYPES).freeze
+
+        private
+
+          def statement_in_sequence? node
+            parent = node.parent
+            parent&.begin_type? || parent&.kwbegin_type?
+          end
+
+          def paragraph_statement? node
+            statement_in_sequence?(node) && (
+              assignment_paragraph?(node) ||
+              block_paragraph?(node) ||
+              conditional_paragraph?(node)
+            )
+          end
+
+          def assignment_paragraph? node
+            rhs = assignment_rhs(node)
+            rhs && bodyish?(rhs)
+          end
+
+          def block_paragraph? node
+            BLOCK_TYPES.include?(node.type) && node.multiline?
+          end
+
+          def conditional_paragraph? node
+            return false unless CONDITIONAL_TYPES.include?(node.type)
+            return false if skip_form?(node)
+
+            node.multiline?
+          end
+
+          def assignment_rhs node
+            if node.call_type?
+              return unless node.assignment_method? && node.loc.operator
+
+              node.last_argument
+            elsif node.assignment?
+              node.expression
+            end
+          end
+
+          def bodyish? node
+            return true if heredoc?(node)
+            return false unless BODY_TYPES.include?(node.type)
+            return false if skip_form?(node)
+
+            node.multiline?
+          end
+
+          def skip_form? node
+            return true if node.if_type? && node.ternary?
+            return true if node.respond_to?(:modifier_form?) && node.modifier_form?
+
+            false
+          end
+
+          def heredoc? node
+            node.each_node.any? { heredoc_end_line(it) }
+          end
+
+          def heredoc_end_line node
+            loc = node.loc
+            loc.heredoc_end.line if loc.respond_to?(:heredoc_end) && loc.heredoc_end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/yoshiki/empty_line_around_multiline_statement.rb

@@ -0,0 +1,94 @@
+require_relative 'empty_line_around_multiline_statement/paragraph'
+
+module RuboCop
+  module Cop
+    module Yoshiki
+      # Shared "paragraph" isolation for multiline assignment / block /
+      # conditional statements that sit next to siblings.
+      #
+      # ExtraSpacing owns `=` padding. After a blank splits an alignment
+      # group, ForceEqualSignAlignment stops stretching neighbors.
+      module EmptyLineAroundMultilineStatement
+
+        include RangeHelp
+        include Paragraph
+
+      private
+
+        def check_empty_lines_around node
+          return unless statement_in_sequence?(node)
+
+          check_blank_before(node)
+          check_blank_after(node)
+        end
+
+        def check_blank_before node
+          return unless node.left_sibling
+          return if glued_to_left_sibling?(node)
+          return if blank_line?(node.first_line - 1)
+          return if processed_source.comment_at_line(node.first_line - 1)
+
+          add_offense(before_range(node), message: self.class::MSG_BEFORE) do |corrector|
+            corrector.insert_before(line_begin(node.first_line), "\n")
+          end
+        end
+
+        def check_blank_after node
+          sibling = node.right_sibling
+          return unless sibling
+          return if paragraph_statement?(sibling)
+          return if glued_to_right_sibling?(node, sibling)
+
+          last = last_physical_line(node)
+          return if blank_line?(last + 1)
+          return if processed_source.comment_at_line(last + 1)
+
+          add_offense(after_range(node), message: self.class::MSG_AFTER) do |corrector|
+            corrector.insert_after(whole_line(last), "\n")
+          end
+        end
+
+        def glued_to_left_sibling? node
+          last_physical_line(node.left_sibling) == node.first_line
+        end
+
+        def glued_to_right_sibling? node, sibling
+          last_physical_line(node) == sibling.first_line
+        end
+
+        def last_physical_line node
+          ends = node.each_node.filter_map { heredoc_end_line(it) }
+          [ node.last_line, *ends ].max
+        end
+
+        def blank_line? lineno
+          return true if lineno < 1
+
+          line = processed_source.lines[lineno - 1]
+          line.nil? || line.strip.empty?
+        end
+
+        def before_range node
+          node.source_range.begin
+        end
+
+        def after_range node
+          loc  = node.loc
+          last = last_physical_line(node)
+          return loc.end if loc.respond_to?(:end) && loc.end && loc.end.line == last
+
+          whole_line(last)
+        end
+
+        def line_begin lineno
+          source_range(processed_source.buffer, lineno, 0)
+        end
+
+        def whole_line lineno
+          range_by_whole_lines(line_begin(lineno))
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/cop/yoshiki/layout/empty_line_around_multiline_assignment.rb

@@ -0,0 +1,72 @@
+module RuboCop
+  module Cop
+    module Yoshiki
+      module Layout
+        # Isolates a multiline assignment from neighboring statements with a
+        # blank line. "Multiline" here means the RHS is a body (block, heredoc,
+        # `if` / `case` / `begin`, …), not a hanging call or array/hash wrap.
+        #
+        # Setter sends (`spec.description =`) count. A `do`/`end` that is the
+        # whole statement (not assigned) is Yoshiki/Layout/EmptyLineAroundMultilineBlock.
+        # A sibling `if`/`case` is Yoshiki/Layout/EmptyLineAroundMultilineConditional.
+        #
+        # Layout/ExtraSpacing (ForceEqualSignAlignment) pads `=` in a group;
+        # a blank line splits that group.
+        #
+        # @example
+        #   # bad
+        #   spec.summary     = 'short'
+        #   spec.description = <<~DESC
+        #     long
+        #   DESC
+        #
+        #   # good
+        #   spec.summary = 'short'
+        #
+        #   spec.description = <<~DESC
+        #     long
+        #   DESC
+        #
+        # @example
+        #   # bad
+        #   store   = []
+        #   protect = lambda do |chunk|
+        #     store << chunk
+        #   end
+        #   text = source
+        #
+        #   # good
+        #   store = []
+        #
+        #   protect = lambda do |chunk|
+        #     store << chunk
+        #   end
+        #
+        #   text = source
+        class EmptyLineAroundMultilineAssignment < Base
+
+          include CheckAssignment
+          include EmptyLineAroundMultilineStatement
+          extend AutoCorrector
+
+          MSG_BEFORE = 'Add a blank line before this multiline assignment.'.freeze
+          MSG_AFTER  = 'Add a blank line after this multiline assignment.'.freeze
+
+          def check_assignment node, rhs
+            return if node.call_type? && !assignment_call?(node)
+            return unless bodyish?(rhs)
+
+            check_empty_lines_around(node)
+          end
+
+        private
+
+          def assignment_call? node
+            node.assignment_method? && node.loc.operator
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/yoshiki/layout/empty_line_around_multiline_block.rb

@@ -0,0 +1,51 @@
+module RuboCop
+  module Cop
+    module Yoshiki
+      module Layout
+        # Isolates a multiline block statement (`do`/`end` or a brace block)
+        # from neighboring statements with a blank line.
+        #
+        # Assigned blocks (`text = gsub(REF) do … end`, `protect = lambda do`)
+        # are Yoshiki/Layout/EmptyLineAroundMultilineAssignment — the statement
+        # is the assignment. This cop only fires when the block itself is the
+        # statement (a sibling in a `begin` sequence).
+        #
+        # Single-line blocks are left alone.
+        #
+        # @example
+        #   # bad
+        #   prepare
+        #   items.each do |item|
+        #     process item
+        #   end
+        #   finish
+        #
+        #   # good
+        #   prepare
+        #
+        #   items.each do |item|
+        #     process item
+        #   end
+        #
+        #   finish
+        class EmptyLineAroundMultilineBlock < Base
+
+          include EmptyLineAroundMultilineStatement
+          extend AutoCorrector
+
+          MSG_BEFORE = 'Add a blank line before this multiline block.'.freeze
+          MSG_AFTER  = 'Add a blank line after this multiline block.'.freeze
+
+          def on_block node
+            return unless block_paragraph?(node)
+
+            check_empty_lines_around(node)
+          end
+          alias on_numblock on_block
+          alias on_itblock on_block
+
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/yoshiki/layout/empty_line_around_multiline_conditional.rb

@@ -0,0 +1,61 @@
+module RuboCop
+  module Cop
+    module Yoshiki
+      module Layout
+        # Isolates a multiline `if` / `unless` / `case` / `while` / `until` /
+        # `for` / `begin` statement from neighboring statements with a blank
+        # line.
+        #
+        # Modifier and ternary forms are skipped. An `if` that is the RHS of an
+        # assignment is Yoshiki/Layout/EmptyLineAroundMultilineAssignment.
+        #
+        # @example
+        #   # bad
+        #   ref  = $1
+        #   href = resolve_ref(ref)
+        #   if href
+        #     link_to href
+        #   else
+        #     ref
+        #   end
+        #
+        #   # good
+        #   ref  = $1
+        #   href = resolve_ref(ref)
+        #
+        #   if href
+        #     link_to href
+        #   else
+        #     ref
+        #   end
+        class EmptyLineAroundMultilineConditional < Base
+
+          include EmptyLineAroundMultilineStatement
+          extend AutoCorrector
+
+          MSG_BEFORE = 'Add a blank line before this multiline conditional.'.freeze
+          MSG_AFTER  = 'Add a blank line after this multiline conditional.'.freeze
+
+          def on_if node
+            inspect_conditional(node)
+          end
+          alias on_case on_if
+          alias on_case_match on_if
+          alias on_while on_if
+          alias on_until on_if
+          alias on_for on_if
+          alias on_kwbegin on_if
+
+        private
+
+          def inspect_conditional node
+            return unless conditional_paragraph?(node)
+
+            check_empty_lines_around(node)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/yoshiki/version.rb

@@ -1,5 +1,5 @@
 module Yoshiki
 
-  VERSION = '11.0.0-12'.freeze
+  VERSION = '11.0.0-13'.freeze
 
 end

data/lib/yoshiki.rb

@@ -1,7 +1,11 @@
 require 'yoshiki/version'
 require 'rubocop'
 require 'rubocop/cop/yoshiki/keyword_only_arguments'
+require 'rubocop/cop/yoshiki/empty_line_around_multiline_statement'
 require 'rubocop/cop/yoshiki/layout/empty_line_before_comment'
+require 'rubocop/cop/yoshiki/layout/empty_line_around_multiline_assignment'
+require 'rubocop/cop/yoshiki/layout/empty_line_around_multiline_block'
+require 'rubocop/cop/yoshiki/layout/empty_line_around_multiline_conditional'
 require 'rubocop/cop/yoshiki/layout/hanging_keyword_arguments'
 require 'rubocop/cop/yoshiki/lint/parenthesize_value_omission'
 require 'rubocop/cop/yoshiki/style/it_block_parameter'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yoshiki
 version: !ruby/object:Gem::Version
-  version: 11.0.0.pre.12
+  version: 11.0.0.pre.13
 platform: ruby
 authors:
 - BM5k
@@ -84,8 +84,13 @@ files:
 - README.md
 - Rakefile
 - bin/console
+- lib/rubocop/cop/yoshiki/empty_line_around_multiline_statement.rb
+- lib/rubocop/cop/yoshiki/empty_line_around_multiline_statement/paragraph.rb
 - lib/rubocop/cop/yoshiki/haml/sibling_blank_lines.rb
 - lib/rubocop/cop/yoshiki/keyword_only_arguments.rb
+- lib/rubocop/cop/yoshiki/layout/empty_line_around_multiline_assignment.rb
+- lib/rubocop/cop/yoshiki/layout/empty_line_around_multiline_block.rb
+- lib/rubocop/cop/yoshiki/layout/empty_line_around_multiline_conditional.rb
 - lib/rubocop/cop/yoshiki/layout/empty_line_before_comment.rb
 - lib/rubocop/cop/yoshiki/layout/hanging_keyword_arguments.rb
 - lib/rubocop/cop/yoshiki/lint/parenthesize_value_omission.rb