rubocop-cuseum 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ad683ca7ea03f7bec7d45905e18daa39d264479bf4773c808cddab3d789d82a5
+  data.tar.gz: 259e2e8242b0f5c159954b7418e2bfeaefe03a6b3a3e3ec44b017861119479c1
+SHA512:
+  metadata.gz: fc1724b3648dd94d8f284fa31b43a75d57898b0e6155ab824ec7e3e7f65b174636177c5f53e08c9f63b1d72a545f1c5d80eb56d46df61cf4a18635e761330326
+  data.tar.gz: 2538c7425f8185d9696791076042be51f49305029650fb9805e5f5330382acea94e807cade06145a2e5c715c782d92b25647b37fd109a8aa2c43f779cb81dede

data/README.md

@@ -0,0 +1,134 @@
+# RuboCop Cuseum
+
+Custom RuboCop cops for enforcing Cuseum service class conventions.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rubocop-cuseum', github: 'cuseum/rubocop-cuseum'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install rubocop-cuseum
+
+## Usage
+
+Put this into your `.rubocop.yml`:
+
+```yaml
+require:
+  - rubocop-cuseum
+```
+
+## Cops
+
+### Cuseum/SinglePublicMethodService
+
+Ensures that service classes have at most one public method.
+
+```ruby
+# good - zero public methods
+class UserService < BaseService
+  private
+
+  def process_user
+    # ...
+  end
+end
+
+# good - one public method
+class UserService < BaseService
+  def call
+    # ...
+  end
+
+  private
+
+  def process_user
+    # ...
+  end
+end
+
+# bad - multiple public methods
+class UserService < BaseService
+  def call
+    # ...
+  end
+
+  def execute  # ← should be private
+    # ...
+  end
+end
+```
+
+### Cuseum/InheritFromBaseService
+
+Ensures that service classes inherit from BaseService directly or indirectly.
+
+```ruby
+# good - direct inheritance
+class UserService < BaseService
+  def call
+    # ...
+  end
+end
+
+# good - indirect inheritance through ApplicationService
+class UserService < ApplicationService
+  def call
+    # ...
+  end
+end
+
+# bad - no inheritance from BaseService
+class UserService
+  def call
+    # ...
+  end
+end
+```
+
+### Cuseum/PublicMethodNamedCall
+
+Ensures that any public method in service classes is named "call".
+
+```ruby
+# good - public method named "call"
+class UserService < BaseService
+  def call
+    # ...
+  end
+
+  private
+
+  def process_user
+    # ...
+  end
+end
+
+# bad - public method with wrong name
+class UserService < BaseService
+  def execute  # ← should be "call"
+    # ...
+  end
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/cuseum/rubocop-cuseum.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/config/default.yml

@@ -0,0 +1,17 @@
+Cuseum/SinglePublicMethodService:
+  Description: Service classes should have at most one public method.
+  Enabled: true
+  Include:
+    - app/services/**/*.rb
+
+Cuseum/InheritFromBaseService:
+  Description: Service classes must inherit from BaseService directly or indirectly.
+  Enabled: true
+  Include:
+    - app/services/**/*.rb
+
+Cuseum/PublicMethodNamedCall:
+  Description: Public methods in service classes should be named "call".
+  Enabled: true
+  Include:
+    - app/services/**/*.rb

data/lib/rubocop/cop/cuseum/inherit_from_base_service.rb

@@ -0,0 +1,83 @@
+# typed: false
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Cuseum
+      # Ensures that service classes in app/services inherit from BaseService directly or indirectly.
+      #
+      # @example
+      #   # good - direct inheritance
+      #   class UserService < BaseService
+      #     def call
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # good - indirect inheritance
+      #   class ApplicationService < BaseService
+      #   end
+      #
+      #   class UserService < ApplicationService
+      #     def call
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # bad - no inheritance from BaseService
+      #   class UserService
+      #     def call
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # bad - inherits from something else
+      #   class UserService < SomeOtherClass
+      #     def call
+      #       # ...
+      #     end
+      #   end
+      #
+      class InheritFromBaseService < Base
+        MSG = "Service classes must inherit from BaseService directly or indirectly."
+
+        def on_class(node)
+          return if inherits_from_base_service?(node)
+
+          add_offense(node, message: MSG)
+        end
+
+        private
+
+        def inherits_from_base_service?(node)
+          parent_class = node.parent_class
+          return false unless parent_class
+
+          check_inheritance_chain(parent_class)
+        end
+
+        def check_inheritance_chain(parent_class_node)
+          return false unless parent_class_node
+
+          class_name = extract_class_name(parent_class_node)
+          return true if class_name == "BaseService"
+
+          # For more complex inheritance checking, we'd need to resolve the actual class
+          # and check its ancestors, but for most cases, direct parent checking should suffice
+          # This cop assumes BaseService inheritance is usually direct or one level deep
+          false
+        end
+
+        def extract_class_name(class_node)
+          case class_node.type
+          when :const
+            class_node.const_name
+          when :send
+            # Handle namespaced classes like Module::BaseService
+            class_node.method_name.to_s if class_node.receiver.nil?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/cuseum/public_method_named_call.rb

@@ -0,0 +1,124 @@
+# typed: false
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Cuseum
+      # Ensures that any public method in service classes is named "call".
+      #
+      # @example
+      #   # good - no public methods
+      #   class UserService < BaseService
+      #     private
+      #
+      #     def process_user
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # good - public method named "call"
+      #   class UserService < BaseService
+      #     def call
+      #       # ...
+      #     end
+      #
+      #     private
+      #
+      #     def process_user
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # bad - public method with wrong name
+      #   class UserService < BaseService
+      #     def execute  # ← should be "call"
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # bad - multiple public methods, some with wrong names
+      #   class UserService < BaseService
+      #     def call
+      #       # ...
+      #     end
+      #
+      #     def execute  # ← should be "call" or private
+      #       # ...
+      #     end
+      #   end
+      #
+      class PublicMethodNamedCall < Base
+        MSG = 'Public methods in service classes should be named "call".'
+
+        def on_class(node)
+          public_methods = extract_public_methods(node)
+
+          public_methods.each do |method_node|
+            method_name = method_node.method_name.to_s
+            unless method_name == "call"
+              add_offense(method_node, message: MSG)
+            end
+          end
+        end
+
+        private
+
+        def extract_public_methods(class_node)
+          public_methods = []
+          current_visibility = :public
+
+          if class_node.body
+            if class_node.body.begin_type?
+              # Multiple statements in class body
+              class_node.body.each_child_node do |child|
+                case child.type
+                when :send
+                  if visibility_modifier?(child)
+                    current_visibility = child.method_name
+                  end
+                when :def
+                  if current_visibility == :public && regular_method?(child)
+                    public_methods << child
+                  end
+                end
+              end
+            else
+              # Single statement in class body (likely a single method)
+              child = class_node.body
+              case child.type
+              when :send
+                if visibility_modifier?(child)
+                  current_visibility = child.method_name
+                end
+              when :def
+                if current_visibility == :public && regular_method?(child)
+                  public_methods << child
+                end
+              end
+            end
+          end
+
+          public_methods
+        end
+
+        def visibility_modifier?(node)
+          return false unless node.send_type?
+
+          [:private, :protected, :public].include?(node.method_name) &&
+            node.receiver.nil? &&
+            node.arguments.empty?
+        end
+
+        def regular_method?(method_node)
+          return false unless method_node.def_type?
+
+          method_name = method_node.method_name.to_s
+          # Exclude initialize and special methods
+          method_name != "initialize" &&
+            !method_name.start_with?("initialize") &&
+            !method_name.match?(/^[^a-zA-Z]/)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/cuseum/single_public_method_service.rb

@@ -0,0 +1,119 @@
+# typed: false
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Cuseum
+      # Ensures that service classes in app/services have at most one public method.
+      #
+      # @example
+      #   # good - zero public methods
+      #   class UserService < BaseService
+      #     private
+      #
+      #     def process_user
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # good - one public method
+      #   class UserService < BaseService
+      #     def call
+      #       # ...
+      #     end
+      #
+      #     private
+      #
+      #     def process_user
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # bad - multiple public methods
+      #   class UserService < BaseService
+      #     def call
+      #       # ...
+      #     end
+      #
+      #     def execute  # ← should be private
+      #       # ...
+      #     end
+      #   end
+      #
+      class SinglePublicMethodService < Base
+        MSG = "Service classes should have at most one public method."
+
+        def on_class(node)
+          public_methods = extract_public_methods(node)
+
+          # Allow 0 or 1 public methods, flag 2 or more
+          return if public_methods.size <= 1
+
+          public_methods.each_with_index do |method_node, index|
+            next if index.zero? # Allow the first public method
+
+            add_offense(method_node, message: MSG)
+          end
+        end
+
+        private
+
+        def extract_public_methods(class_node)
+          public_methods = []
+          current_visibility = :public
+
+          if class_node.body
+            if class_node.body.begin_type?
+              # Multiple statements in class body
+              class_node.body.each_child_node do |child|
+                case child.type
+                when :send
+                  if visibility_modifier?(child)
+                    current_visibility = child.method_name
+                  end
+                when :def
+                  if current_visibility == :public && regular_method?(child)
+                    public_methods << child
+                  end
+                end
+              end
+            else
+              # Single statement in class body (likely a single method)
+              child = class_node.body
+              case child.type
+              when :send
+                if visibility_modifier?(child)
+                  current_visibility = child.method_name
+                end
+              when :def
+                if current_visibility == :public && regular_method?(child)
+                  public_methods << child
+                end
+              end
+            end
+          end
+
+          public_methods
+        end
+
+        def visibility_modifier?(node)
+          return false unless node.send_type?
+
+          [:private, :protected, :public].include?(node.method_name) &&
+            node.receiver.nil? &&
+            node.arguments.empty?
+        end
+
+        def regular_method?(method_node)
+          return false unless method_node.def_type?
+
+          method_name = method_node.method_name.to_s
+          # Exclude initialize and special methods
+          method_name != "initialize" &&
+            !method_name.start_with?("initialize") &&
+            !method_name.match?(/^[^a-zA-Z]/)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/cuseum_cops.rb

@@ -0,0 +1,6 @@
+# typed: false
+# frozen_string_literal: true
+
+require_relative "cuseum/single_public_method_service"
+require_relative "cuseum/inherit_from_base_service"
+require_relative "cuseum/public_method_named_call"

data/lib/rubocop-cuseum.rb

@@ -0,0 +1,6 @@
+# typed: false
+# frozen_string_literal: true
+
+require "rubocop"
+
+require_relative "rubocop/cop/cuseum_cops"

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: rubocop-cuseum
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Cuseum Team
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Custom RuboCop cops to enforce Cuseum service class patterns and best
+  practices
+email:
+- dev@cuseum.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- config/default.yml
+- lib/rubocop-cuseum.rb
+- lib/rubocop/cop/cuseum/inherit_from_base_service.rb
+- lib/rubocop/cop/cuseum/public_method_named_call.rb
+- lib/rubocop/cop/cuseum/single_public_method_service.rb
+- lib/rubocop/cop/cuseum_cops.rb
+homepage: https://github.com/cuseum/rubocop-cuseum
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/cuseum/rubocop-cuseum
+  source_code_uri: https://github.com/cuseum/rubocop-cuseum
+  changelog_uri: https://github.com/cuseum/rubocop-cuseum/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+  - - "<="
+    - !ruby/object:Gem::Version
+      version: 3.3.10
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: RuboCop extension for Cuseum service class conventions
+test_files: []