rubocop-discourse 3.8.6 → 3.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf5c1b4b83dac7f5180e776e8161b812987f18e95b16d0eaca23d24256be6ace
-  data.tar.gz: e15870cbf907b1561cbf8f669e2dbda6043e664c271ddaca8649d8183463c271
+  metadata.gz: 416bda6686bc9313c67819f5cdc6e47dd25b68cae808fcb190c1da14b1fda371
+  data.tar.gz: 577720bc7b63aa1fa574ea6da53c9326010e35ce2dc9e367eb888e459d9d17d3
 SHA512:
-  metadata.gz: efcbbb0a6935fd5f59ae3a1c40abd05af96618cc8eb172fdba9e2e073e2c0cdb0119a280244fe7b89d0c62ca418f3bc14e51b486411978e240d6edfe77e22cbf
-  data.tar.gz: 6cdbe8ffdd66166f2a617bf654579a284db4342f9fa5f30186a760a51bb73e6e173b2b09c87d8282905440c6d79999cc5f87254cc3f6ee7e2fb596d4240da1a9
+  metadata.gz: 569fb633072ebff20f3187fd684073d0d1d4ebbaf090cfc173de1c9c794933276ef09beb105d5af2bc639c8b72aa9e221bbcef9d5041d5ab3300dd4a82b64c52
+  data.tar.gz: 6eb8ced2313523c8c6fa0c1681bab7103a9b5b21d97dba683a100bf81bbe082515468d7468c633d46158348d0c92762a32aada56c72afc126b4e28bde5f0b0d8

data/config/default.yml

@@ -90,3 +90,9 @@ Discourse/Plugins/UseRequireRelative:
 
 Discourse/Plugins/NoMonkeyPatching:
   Enabled: true
+
+Discourse/Services/GroupKeywords:
+  Enabled: true
+
+Discourse/Services/EmptyLinesAroundBlocks:
+  Enabled: true

data/lib/rubocop/cop/discourse/services/empty_lines_around_blocks.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Discourse
+      module Services
+        # Put empty lines around multiline blocks.
+        #
+        # @example
+        #   # bad
+        #   model :my_model
+        #   params do
+        #     attribute :my_attribute
+        #     validates :my_attribute, presence: true
+        #   end
+        #   policy :my_policy
+        #   step :another_step
+        #
+        #   # good
+        #   model :my_model
+        #
+        #   params do
+        #     attribute :my_attribute
+        #     validates :my_attribute, presence: true
+        #   end
+        #
+        #   policy :my_policy
+        #   step :another_step
+        #
+        class EmptyLinesAroundBlocks < Base
+          extend AutoCorrector
+
+          MSG = "Add empty lines around a step block."
+
+          def_node_matcher :service_include?, <<~MATCHER
+            (class _ _
+             {
+               (begin <(send nil? :include (const (const nil? :Service) :Base)) ...>)
+               <(send nil? :include (const (const nil? :Service) :Base)) ...>
+             }
+            )
+          MATCHER
+
+          def_node_matcher :top_level_block?, <<~MATCHER
+            (block (send nil? _) ...)
+          MATCHER
+
+          def on_class(node)
+            return unless service_include?(node)
+            @service = true
+          end
+
+          def on_block(node)
+            return unless service?
+            return unless top_level_block?(node)
+            return if node.single_line?
+
+            if missing_empty_lines?(node)
+              add_offense(node, message: MSG) do |corrector|
+                if missing_empty_line_before?(node) &&
+                     corrected_after.exclude?(node.left_sibling)
+                  corrected_before << node
+                  corrector.insert_before(
+                    node.loc.expression.adjust(
+                      begin_pos: -node.loc.expression.column
+                    ),
+                    "\n"
+                  )
+                end
+                if missing_empty_line_after?(node) &&
+                     corrected_before.exclude?(node.right_sibling)
+                  corrected_after << node
+                  corrector.insert_after(node.loc.end, "\n")
+                end
+              end
+            end
+          end
+
+          private
+
+          def service?
+            @service
+          end
+
+          def missing_empty_lines?(node)
+            missing_empty_line_before?(node) || missing_empty_line_after?(node)
+          end
+
+          def missing_empty_line_before?(node)
+            processed_source[node.loc.expression.line - 2].present? &&
+              node.left_siblings.present?
+          end
+
+          def missing_empty_line_after?(node)
+            processed_source[node.loc.end.line].present? &&
+              node.right_siblings.present?
+          end
+
+          def corrected_before
+            @corrected_before ||= []
+          end
+
+          def corrected_after
+            @corrected_before ||= []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/discourse/services/group_keywords.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Discourse
+      module Services
+        # Don’t put empty lines between keywords that are not multiline blocks.
+        #
+        # @example
+        #   # bad
+        #   model :my_model
+        #
+        #   policy :my_policy
+        #
+        #   try { step :might_raise }
+        #
+        #   # good
+        #   model :my_model
+        #   policy :my_policy
+        #   try { step :might_raise }
+        #
+        class GroupKeywords < Base
+          extend AutoCorrector
+
+          MSG = "Group one-liner steps together by removing extra empty lines."
+          RESTRICT_ON_SEND = %i[step model policy].freeze
+
+          def_node_matcher :service_include?, <<~MATCHER
+            (class _ _
+             {
+               (begin <(send nil? :include (const (const nil? :Service) :Base)) ...>)
+               <(send nil? :include (const (const nil? :Service) :Base)) ...>
+             }
+            )
+          MATCHER
+
+          def on_class(node)
+            return unless service_include?(node)
+            @service = true
+          end
+
+          def on_send(node)
+            return unless service?
+            return unless top_level?(node)
+            return unless extra_empty_line_after?(node)
+
+            add_offense(node, message: MSG) do |corrector|
+              range =
+                node.loc.expression.end.with(
+                  end_pos: node.right_sibling.loc.expression.begin_pos
+                )
+              content = range.source.gsub(/^(\n)+/, "\n")
+              corrector.replace(range, content)
+            end
+          end
+
+          private
+
+          def service?
+            @service
+          end
+
+          def extra_empty_line_after?(node)
+            processed_source[node.loc.expression.line].blank? &&
+              (
+                service_keyword?(node.right_sibling) ||
+                  single_line_block?(node.right_sibling)
+              )
+          end
+
+          def service_keyword?(node)
+            return unless node
+            node.send_type? && RESTRICT_ON_SEND.include?(node.method_name)
+          end
+
+          def single_line_block?(node)
+            return unless node
+            node.block_type? && node.single_line?
+          end
+
+          def top_level?(node)
+            while (!node.root?)
+              node = node.parent
+              return if %i[begin class block].exclude?(node.type)
+            end
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop-discourse.rb

@@ -3,6 +3,8 @@
 require "rubocop"
 require "active_support"
 require "active_support/core_ext/string/inflections"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/enumerable"
 require_relative "rubocop/discourse"
 require_relative "rubocop/discourse/inject"
 

data/rubocop-discourse.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = "rubocop-discourse"
-  s.version = "3.8.6"
+  s.version = "3.9.0"
   s.summary = "Custom rubocop cops used by Discourse"
   s.authors = ["Discourse Team"]
   s.license = "MIT"

data/spec/lib/rubocop/cop/discourse/services/empty_lines_around_blocks_spec.rb

@@ -0,0 +1,294 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe RuboCop::Cop::Discourse::Services::EmptyLinesAroundBlocks,
+               :config do
+  subject(:cop) { described_class.new(config) }
+
+  let(:config) { RuboCop::Config.new }
+
+  context "when not in a service class" do
+    it "does nothing" do
+      expect_no_offenses(<<~RUBY)
+        class NotAService
+          step :first_step
+          params do
+            attribute :my_attribute
+          end
+          step :another_step
+        end
+      RUBY
+    end
+  end
+
+  context "when in a service class" do
+    context "when a blank line is missing before a block" do
+      it "registers an offense" do
+        expect_offense(<<~RUBY)
+          class MyService
+            include Service::Base
+
+            step :first_step
+            params do
+            ^^^^^^^^^ Discourse/Services/EmptyLinesAroundBlocks: Add empty lines around a step block.
+              attribute :my_attribute
+            end
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          class MyService
+            include Service::Base
+
+            step :first_step
+
+            params do
+              attribute :my_attribute
+            end
+          end
+        RUBY
+      end
+    end
+
+    context "when a blank line is missing after a block" do
+      it "registers an offense" do
+        expect_offense(<<~RUBY)
+          class MyService
+            include Service::Base
+
+            params do
+            ^^^^^^^^^ Discourse/Services/EmptyLinesAroundBlocks: Add empty lines around a step block.
+              attribute :my_attribute
+            end
+            step :last_step
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          class MyService
+            include Service::Base
+
+            params do
+              attribute :my_attribute
+            end
+
+            step :last_step
+          end
+        RUBY
+      end
+    end
+
+    context "when two blocks are next to each other" do
+      it "registers an offense" do
+        expect_offense(<<~RUBY)
+          class MyService
+            include Service::Base
+
+            params do
+            ^^^^^^^^^ Discourse/Services/EmptyLinesAroundBlocks: Add empty lines around a step block.
+              attribute :attribute
+              validates :attribute, presence: true
+            end
+            transaction do
+            ^^^^^^^^^^^^^^ Discourse/Services/EmptyLinesAroundBlocks: Add empty lines around a step block.
+              step :first
+              step :second
+            end
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          class MyService
+            include Service::Base
+
+            params do
+              attribute :attribute
+              validates :attribute, presence: true
+            end
+
+            transaction do
+              step :first
+              step :second
+            end
+          end
+        RUBY
+      end
+    end
+
+    context "when a block is a one-liner" do
+      it "does not register an offense" do
+        expect_no_offenses(<<~RUBY)
+          class MyService
+            include Service::Base
+
+            try { step :might_raise }
+            step :last_step
+          end
+        RUBY
+      end
+    end
+
+    context "when blocks are nested" do
+      context "when the nested block is in the first position" do
+        context "when there is no empty line before" do
+          it "does not register an offense" do
+            expect_no_offenses(<<~RUBY)
+              class MyService
+                include Service::Base
+
+                transaction do
+                  try do
+                    step :first_step
+                    step :second_step
+                  end
+
+                  step :third_step
+                end
+              end
+            RUBY
+          end
+        end
+
+        context "when there is no empty line after" do
+          it "registers an offense" do
+            expect_offense(<<~RUBY)
+              class MyService
+                include Service::Base
+
+                transaction do
+                  try do
+                  ^^^^^^ Discourse/Services/EmptyLinesAroundBlocks: Add empty lines around a step block.
+                    step :first_step
+                    step :second_step
+                  end
+                  step :third_step
+                end
+              end
+            RUBY
+
+            expect_correction(<<~RUBY)
+              class MyService
+                include Service::Base
+
+                transaction do
+                  try do
+                    step :first_step
+                    step :second_step
+                  end
+
+                  step :third_step
+                end
+              end
+            RUBY
+          end
+        end
+      end
+
+      context "when the nested block is in the last position" do
+        context "when there is no empty line after" do
+          it "does not register an offense" do
+            expect_no_offenses(<<~RUBY)
+              class MyService
+                include Service::Base
+
+                transaction do
+                  step :first_step
+
+                  try do
+                    step :second_step
+                    step :third_step
+                  end
+                end
+              end
+            RUBY
+          end
+        end
+
+        context "when there is no empty line before" do
+          it "registers an offense" do
+            expect_offense(<<~RUBY)
+              class MyService
+                include Service::Base
+
+                transaction do
+                  step :first_step
+                  try do
+                  ^^^^^^ Discourse/Services/EmptyLinesAroundBlocks: Add empty lines around a step block.
+                    step :second_step
+                    step :third_step
+                  end
+                end
+              end
+            RUBY
+
+            expect_correction(<<~RUBY)
+              class MyService
+                include Service::Base
+
+                transaction do
+                  step :first_step
+
+                  try do
+                    step :second_step
+                    step :third_step
+                  end
+                end
+              end
+            RUBY
+          end
+        end
+      end
+    end
+
+    context "when blocks are used in methods" do
+      it "does not register an offense" do
+        expect_no_offenses(<<~RUBY)
+          class MyService
+            include Service::Base
+
+            step :first_step
+
+            def first_step(model:)
+              model.transaction do
+                do_something
+              end
+            end
+          end
+        RUBY
+      end
+    end
+
+    context "with a full valid example" do
+      it "does not register an offense" do
+        expect_no_offenses(<<~RUBY)
+          class MyService
+            include Service::Base
+
+            step :first_step
+
+            params do
+              attribute :my_attribute
+
+              validates :my_attributes, presence: true
+            end
+
+            policy :allowed?
+            model :user
+
+            transaction do
+              try do
+                step :save_user
+                step :log
+              end
+
+              step :other_step
+            end
+
+            step :last_step
+          end
+        RUBY
+      end
+    end
+  end
+end

data/spec/lib/rubocop/cop/discourse/services/group_keywords_spec.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe RuboCop::Cop::Discourse::Services::GroupKeywords, :config do
+  subject(:cop) { described_class.new(config) }
+
+  let(:config) { RuboCop::Config.new }
+
+  context "when not in a service class" do
+    it "does nothing" do
+      expect_no_offenses(<<~RUBY)
+        class NotAService
+          step :first_step
+
+          step :another_step
+        end
+      RUBY
+    end
+  end
+
+  context "when in a service class" do
+    context "when keywords are not grouped together" do
+      it "reports an offense" do
+        expect_offense(<<~RUBY)
+          class MyService
+            include Service::Base
+
+            model :user
+            ^^^^^^^^^^^ Discourse/Services/GroupKeywords: Group one-liner steps together by removing extra empty lines.
+
+            policy :allowed?
+            step :save
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          class MyService
+            include Service::Base
+
+            model :user
+            policy :allowed?
+            step :save
+          end
+        RUBY
+      end
+    end
+
+    context "when a one-liner block has an empty line before a keyword" do
+      it "reports an offense" do
+        expect_offense(<<~RUBY)
+          class MyService
+            include Service::Base
+
+            model :user
+            policy :allowed?
+            ^^^^^^^^^^^^^^^^ Discourse/Services/GroupKeywords: Group one-liner steps together by removing extra empty lines.
+
+            try { step :save }
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          class MyService
+            include Service::Base
+
+            model :user
+            policy :allowed?
+            try { step :save }
+          end
+        RUBY
+      end
+    end
+
+    context "when keywords with empty lines appear in a nested block" do
+      it "reports an offense" do
+        expect_offense(<<~RUBY)
+          class MyService
+            include Service::Base
+
+            transaction do
+              step :save
+              ^^^^^^^^^^ Discourse/Services/GroupKeywords: Group one-liner steps together by removing extra empty lines.
+
+              step :log
+            end
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          class MyService
+            include Service::Base
+
+            transaction do
+              step :save
+              step :log
+            end
+          end
+        RUBY
+      end
+    end
+
+    context "when keywords are grouped together" do
+      it "does not report an offense" do
+        expect_no_offenses(<<~RUBY)
+          class MyService
+            include Service::Base
+
+            model :user
+            policy :allowed?
+
+            transaction do
+              step :save
+              step :log
+            end
+          end
+        RUBY
+      end
+    end
+
+    context "when keywords are not at the top level" do
+      it "does not report an offense" do
+        expect_no_offenses(<<~RUBY)
+          class MyService
+            include Service::Base
+
+            private
+
+            def my_method
+              step(:save)
+
+              step(:log)
+            end
+          end
+        RUBY
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-discourse
 version: !ruby/object:Gem::Version
-  version: 3.8.6
+  version: 3.9.0
 platform: ruby
 authors:
 - Discourse Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-11-13 00:00:00.000000000 Z
+date: 2024-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -170,6 +170,8 @@ files:
 - lib/rubocop/cop/discourse/plugins/no_monkey_patching.rb
 - lib/rubocop/cop/discourse/plugins/use_plugin_instance_on.rb
 - lib/rubocop/cop/discourse/plugins/use_require_relative.rb
+- lib/rubocop/cop/discourse/services/empty_lines_around_blocks.rb
+- lib/rubocop/cop/discourse/services/group_keywords.rb
 - lib/rubocop/cop/discourse/time_eq_matcher.rb
 - lib/rubocop/cop/discourse_cops.rb
 - lib/rubocop/discourse.rb
@@ -188,6 +190,8 @@ files:
 - spec/fixtures/controllers/namespaced_parent_controller.rb
 - spec/fixtures/controllers/no_requires_plugin_controller.rb
 - spec/fixtures/controllers/requires_plugin_controller.rb
+- spec/lib/rubocop/cop/discourse/services/empty_lines_around_blocks_spec.rb
+- spec/lib/rubocop/cop/discourse/services/group_keywords_spec.rb
 - spec/lib/rubocop/cop/fabricator_shorthand_spec.rb
 - spec/lib/rubocop/cop/no_add_reference_active_record_migrations_spec.rb
 - spec/lib/rubocop/cop/no_mixing_multisite_and_standard_specs_spec.rb