rubocop-hgoostdd 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4c1ae10a637f90f9e429e8dc4cd890a7a6e69d9391a21d9a0cd709e492fd4832
+  data.tar.gz: edfd60cef5f12f859139a297500f756fe588d9baf4d45ba6229c8a189478a916
+SHA512:
+  metadata.gz: 2fad4f9674daeceb4516d6847756120d85cd67c4f6e8d8916bb6279ad022b32630c1c4e1479b5557fe67a3bd4de240f6ce2fd813bbba3b887cef6201205b29ff
+  data.tar.gz: adfd8413938df19b45ef5b1e0d74366e3d05d2537dea9a77f87b1ee87cebaf008bfb442e32afc1b74f5187d8a7fd3f0137482f65e89b16d68b5b2b42a8884ce3

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tommy Caruso
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,85 @@
+# rubocop-hgoostdd
+
+Custom RuboCop cops that codify the rules of **Hardened GOOS TDD** —
+the testing discipline that wraps Freeman & Pryce's outside-in TDD with
+explicit guardrails against the failure modes that bite long-lived
+mockist codebases: interface drift, behavior drift, hidden globals, and
+ossified mocks.
+
+## What it enforces
+
+| Cop | Rule | Autocorrect |
+|---|---|---|
+| `HGOOSTDD/NoTimeInDomain` | §6 — no `Time.now` / `Time.current` in domain code | `→ @clock.now` (unsafe) |
+| `HGOOSTDD/NoSecureRandomInDomain` | §6 — no `SecureRandom.*` in domain code | `→ @id_gen.<method>(args)` (unsafe) |
+| `HGOOSTDD/NoRailsLoggerInDomain` | §6 — no `Rails.logger` in domain code | `→ @logger` preserving chain (unsafe) |
+| `HGOOSTDD/NoEnvOutsideAppConfig` | §6 — `ENV[` / `ENV.fetch` only in `app/support/app_config.rb` | — |
+| `HGOOSTDD/NoTimecopInDomainSpecs` | §6 — no `Timecop` / `travel_to` in inner-loop specs | — |
+| `HGOOSTDD/NoMocksInAcceptance` | §2 — no `instance_double` / `allow` / `expect…to receive` in `spec/acceptance/**` | — |
+
+The three autocorrectable cops are marked `SafeAutoCorrect: false` —
+the rewrite assumes the surrounding object has the matching ivar wired
+by an injected collaborator. `rubocop -a` skips them; only `rubocop -A`
+applies.
+
+## Install
+
+```ruby
+# Gemfile
+group :development, :test do
+  gem "rubocop-hgoostdd", require: false
+end
+```
+
+```yaml
+# .rubocop.yml
+require:
+  - rubocop-hgoostdd
+
+AllCops:
+  TargetRubyVersion: 4.0
+  NewCops: disable
+  DisabledByDefault: true
+  SuggestExtensions: false
+```
+
+`DisabledByDefault: true` is recommended unless you're also running
+stock RuboCop — otherwise default style cops will fire and bury the
+HGOOSTDD output.
+
+## Default paths
+
+Each cop ships with Rails-app-shaped `Include`/`Exclude` defaults under
+`config/default.yml`. Override in your own `.rubocop.yml` if your
+project structure differs:
+
+```yaml
+HGOOSTDD/NoTimeInDomain:
+  Include:
+    - 'lib/**/*'
+  Exclude:
+    - 'lib/clock.rb'
+```
+
+## The six rules in brief
+
+- **§1** Only mock types you own. Wrap third-party SDKs in adapters; mock the adapter, not the SDK.
+- **§2** Outer-loop acceptance test against real Rails; inner loop mockist and fast.
+- **§3** Contract tests for adapters — paired against real and fake.
+- **§4** Inject collaborators; no hidden reaches.
+- **§5** Real > Fake > Stub > Mock. Fakes are first-class.
+- **§6** No implicit globals in domain code.
+
+Full discipline at the goos_tdd worked example (the sandbox that
+produced this gem).
+
+## Origin
+
+These cops were extracted from a Rails sandbox built to validate the
+discipline end-to-end (`goos_tdd`). Each cop has a paired
+`expect_offense` / `expect_no_offenses` spec; the three autocorrect
+cops also assert via `expect_correction`. 24 examples, 0 failures.
+
+## License
+
+MIT.

data/config/default.yml

@@ -0,0 +1,63 @@
+AllCops:
+  DisabledByDefault: true
+
+HGOOSTDD/NoTimeInDomain:
+  Description: 'Inject a clock: collaborator; do not call Time.now / Time.current in domain code (§6).'
+  Enabled: true
+  SafeAutoCorrect: false
+  Include:
+    - 'app/services/**/*'
+    - 'app/domain/**/*'
+    - 'app/controllers/**/*'
+    - 'app/models/**/*'
+    - 'app/adapters/**/*'
+    - 'app/repositories/**/*'
+    - 'app/jobs/**/*'
+  Exclude:
+    - 'app/support/clock.rb'
+
+HGOOSTDD/NoSecureRandomInDomain:
+  Description: 'Inject an id_gen: collaborator; do not call SecureRandom.* in domain code (§6).'
+  Enabled: true
+  SafeAutoCorrect: false
+  Include:
+    - 'app/services/**/*'
+    - 'app/domain/**/*'
+    - 'app/controllers/**/*'
+    - 'app/models/**/*'
+    - 'app/adapters/**/*'
+    - 'app/repositories/**/*'
+    - 'app/jobs/**/*'
+  Exclude:
+    - 'app/support/id_gen.rb'
+
+HGOOSTDD/NoRailsLoggerInDomain:
+  Description: 'Inject a logger: collaborator; do not reach for Rails.logger in domain code (§6).'
+  Enabled: true
+  SafeAutoCorrect: false
+  Include:
+    - 'app/**/*'
+  Exclude:
+    - 'app/support/**/*'
+
+HGOOSTDD/NoEnvOutsideAppConfig:
+  Description: 'Read configuration through AppConfig, not directly from ENV (§6).'
+  Enabled: true
+  Include:
+    - 'app/**/*'
+  Exclude:
+    - 'app/support/app_config.rb'
+
+HGOOSTDD/NoTimecopInDomainSpecs:
+  Description: 'Use a FakeClock instead of Timecop / travel_to in domain specs (§6).'
+  Enabled: true
+  Include:
+    - 'spec/**/*'
+  Exclude:
+    - 'spec/acceptance/**/*'
+
+HGOOSTDD/NoMocksInAcceptance:
+  Description: 'Acceptance specs must not use mocks; swap fakes via the adapter registry (§2).'
+  Enabled: true
+  Include:
+    - 'spec/acceptance/**/*'

data/lib/rubocop/cop/hgoostdd/no_env_outside_app_config.rb

@@ -0,0 +1,26 @@
+module RuboCop
+  module Cop
+    module HGOOSTDD
+      # `ENV[...]` and `ENV.fetch` should only appear in the AppConfig
+      # boundary. Domain code reads config through an injected `config:`
+      # collaborator. See HGOOSTDD §6.
+      class NoEnvOutsideAppConfig < Base
+        MSG = "Read configuration through AppConfig, not directly from ENV (§6)."
+
+        def_node_matcher :env_index?, <<~PATTERN
+          (send (const {nil? cbase} :ENV) :[] _)
+        PATTERN
+
+        def_node_matcher :env_fetch?, <<~PATTERN
+          (send (const {nil? cbase} :ENV) :fetch ...)
+        PATTERN
+
+        def on_send(node)
+          return unless env_index?(node) || env_fetch?(node)
+
+          add_offense(node, message: MSG)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/hgoostdd/no_mocks_in_acceptance.rb

@@ -0,0 +1,36 @@
+module RuboCop
+  module Cop
+    module HGOOSTDD
+      # Acceptance specs exercise the real Rails stack with fakes only at
+      # the adapter seam. They must not mock or stub. Inner-loop unit
+      # specs can use mocks; acceptance specs cannot. See HGOOSTDD §2.
+      class NoMocksInAcceptance < Base
+        MSG = "Acceptance specs must not use `%{call}`; swap fakes via the adapter registry instead (§2)."
+
+        MOCK_BUILDERS = %i[instance_double class_double object_double].freeze
+
+        def_node_matcher :mock_builder?, <<~PATTERN
+          (send nil? ${:instance_double :class_double :object_double} ...)
+        PATTERN
+
+        def_node_matcher :allow_call?, <<~PATTERN
+          (send nil? :allow _)
+        PATTERN
+
+        def_node_matcher :receive_chain?, <<~PATTERN
+          (send (send nil? :expect _) :to (send nil? :receive _))
+        PATTERN
+
+        def on_send(node)
+          if (m = mock_builder?(node))
+            add_offense(node, message: format(MSG, call: m))
+          elsif allow_call?(node)
+            add_offense(node, message: format(MSG, call: :allow))
+          elsif receive_chain?(node)
+            add_offense(node, message: format(MSG, call: "expect(...).to receive"))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/hgoostdd/no_rails_logger_in_domain.rb

@@ -0,0 +1,29 @@
+module RuboCop
+  module Cop
+    module HGOOSTDD
+      # Domain code logs through an injected `logger:` collaborator, never
+      # the global `Rails.logger`. See HGOOSTDD §6.
+      #
+      # Autocorrect rewrites `Rails.logger` (the receiver) to `@logger`,
+      # leaving any chained method call intact. Marked unsafe — assumes
+      # `@logger` exists.
+      class NoRailsLoggerInDomain < Base
+        extend AutoCorrector
+
+        MSG = "Inject a `logger:` collaborator; do not reach for `Rails.logger` in domain code (§6)."
+
+        def_node_matcher :rails_logger?, <<~PATTERN
+          (send (const {nil? cbase} :Rails) :logger)
+        PATTERN
+
+        def on_send(node)
+          return unless rails_logger?(node)
+
+          add_offense(node, message: MSG) do |corrector|
+            corrector.replace(node, "@logger")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/hgoostdd/no_secure_random_in_domain.rb

@@ -0,0 +1,32 @@
+module RuboCop
+  module Cop
+    module HGOOSTDD
+      # Domain code must generate IDs via an injected `id_gen:` collaborator,
+      # not via the `SecureRandom` constant. See HGOOSTDD §6.
+      #
+      # Autocorrect rewrites `SecureRandom.<method>(args)` to
+      # `@id_gen.<method>(args)`, preserving the method name and args.
+      # Marked unsafe — assumes `@id_gen` exists and exposes a matching
+      # method (e.g. `IdGen#uuid` for `SecureRandom.uuid`).
+      class NoSecureRandomInDomain < Base
+        extend AutoCorrector
+
+        MSG = "Inject an `id_gen:` collaborator; do not call `%{call}` in domain code (§6)."
+
+        def_node_matcher :secure_random_send?, <<~PATTERN
+          (send (const {nil? cbase} :SecureRandom) $_ ...)
+        PATTERN
+
+        def on_send(node)
+          return unless (method_name = secure_random_send?(node))
+
+          add_offense(node, message: format(MSG, call: node.source)) do |corrector|
+            args = node.arguments.map(&:source).join(", ")
+            replacement = args.empty? ? "@id_gen.#{method_name}" : "@id_gen.#{method_name}(#{args})"
+            corrector.replace(node, replacement)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/hgoostdd/no_time_in_domain.rb

@@ -0,0 +1,33 @@
+module RuboCop
+  module Cop
+    module HGOOSTDD
+      # Domain code must read time via an injected `clock:` collaborator,
+      # not via `Time.now` / `Time.current`. See HGOOSTDD §6.
+      #
+      # Autocorrect rewrites the call to `@clock.now`. This is marked
+      # unsafe (SafeAutoCorrect: false in .rubocop.yml) because it
+      # assumes the surrounding object has a `@clock` ivar wired by an
+      # injected collaborator. After autocorrect, the developer must
+      # ensure the constructor accepts `clock:` and assigns `@clock`.
+      class NoTimeInDomain < Base
+        extend AutoCorrector
+
+        MSG = "Inject a `clock:` collaborator; do not call `%{call}` in domain code (§6)."
+
+        RESTRICT_ON_SEND = %i[now current].freeze
+
+        def_node_matcher :time_send?, <<~PATTERN
+          (send (const {nil? cbase} :Time) {:now :current})
+        PATTERN
+
+        def on_send(node)
+          return unless time_send?(node)
+
+          add_offense(node, message: format(MSG, call: node.source)) do |corrector|
+            corrector.replace(node, "@clock.now")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/hgoostdd/no_timecop_in_domain_specs.rb

@@ -0,0 +1,31 @@
+module RuboCop
+  module Cop
+    module HGOOSTDD
+      # `Timecop`, `travel_to`, `travel_back`, and `freeze_time` are
+      # acceptable in acceptance specs (which exercise the real Rails
+      # stack) but not in inner-loop domain specs — inject a clock fake
+      # instead. See HGOOSTDD §6.
+      class NoTimecopInDomainSpecs < Base
+        MSG = "Use a FakeClock instead of `%{call}` in domain specs (§6)."
+
+        TRAVEL_METHODS = %i[travel_to travel_back freeze_time travel].freeze
+
+        def_node_matcher :timecop_send?, <<~PATTERN
+          (send (const {nil? cbase} :Timecop) _ ...)
+        PATTERN
+
+        def_node_matcher :travel_call?, <<~PATTERN
+          (send nil? ${:travel_to :travel_back :freeze_time :travel} ...)
+        PATTERN
+
+        def on_send(node)
+          if timecop_send?(node)
+            add_offense(node, message: format(MSG, call: node.source))
+          elsif travel_call?(node)
+            add_offense(node, message: format(MSG, call: node.method_name))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/hgoostdd/inject.rb

@@ -0,0 +1,24 @@
+require "pathname"
+require "yaml"
+
+module RuboCop
+  module HGOOSTDD
+    PROJECT_ROOT = Pathname.new(__dir__).parent.parent.parent.expand_path.freeze
+    CONFIG_DEFAULT = PROJECT_ROOT.join("config", "default.yml").freeze
+
+    # Merges this gem's default.yml into RuboCop's default configuration so
+    # host projects only need `require: rubocop-hgoostdd` in their
+    # .rubocop.yml and can rely on the per-cop Include/Exclude/Enabled
+    # defaults shipped here.
+    module Inject
+      def self.defaults!
+        path = CONFIG_DEFAULT.to_s
+        hash = ConfigLoader.send(:load_yaml_configuration, path)
+        config = RuboCop::Config.new(hash, path)
+        puts "configuration from #{path}" if ConfigLoader.debug?
+        config = ConfigLoader.merge_with_default(config, path)
+        ConfigLoader.instance_variable_set(:@default_configuration, config)
+      end
+    end
+  end
+end

data/lib/rubocop/hgoostdd/version.rb

@@ -0,0 +1,5 @@
+module RuboCop
+  module HGOOSTDD
+    VERSION = "0.1.0"
+  end
+end

data/lib/rubocop-hgoostdd.rb

@@ -0,0 +1,13 @@
+require "rubocop"
+
+require_relative "rubocop/hgoostdd/version"
+require_relative "rubocop/hgoostdd/inject"
+
+RuboCop::HGOOSTDD::Inject.defaults!
+
+require_relative "rubocop/cop/hgoostdd/no_time_in_domain"
+require_relative "rubocop/cop/hgoostdd/no_secure_random_in_domain"
+require_relative "rubocop/cop/hgoostdd/no_rails_logger_in_domain"
+require_relative "rubocop/cop/hgoostdd/no_env_outside_app_config"
+require_relative "rubocop/cop/hgoostdd/no_timecop_in_domain_specs"
+require_relative "rubocop/cop/hgoostdd/no_mocks_in_acceptance"

data/rubocop-hgoostdd.gemspec

@@ -0,0 +1,32 @@
+require_relative "lib/rubocop/hgoostdd/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "rubocop-hgoostdd"
+  spec.version = RuboCop::HGOOSTDD::VERSION
+  spec.authors = ["Tommy Caruso"]
+  spec.email = ["tommy.caruso2118@gmail.com"]
+
+  spec.summary = "RuboCop cops enforcing Hardened GOOS TDD discipline"
+  spec.description = <<~DESC
+    Six cops that codify the §1-§6 rules of Hardened GOOS TDD:
+    no Time.now / SecureRandom / Rails.logger / ENV reads in domain code,
+    no Timecop in inner-loop specs, no mocks in acceptance specs.
+    Three of the six autocorrect to the injected-collaborator form.
+  DESC
+  spec.homepage = "https://github.com/tommy2118/rubocop-hgoostdd"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+
+  spec.files = Dir[
+    "lib/**/*.rb",
+    "config/**/*.yml",
+    "LICENSE.txt",
+    "README.md",
+    "rubocop-hgoostdd.gemspec"
+  ]
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rubocop", ">= 1.70", "< 2.0"
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: rubocop-hgoostdd
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tommy Caruso
+bindir: bin
+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.70'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.70'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: |
+  Six cops that codify the §1-§6 rules of Hardened GOOS TDD:
+  no Time.now / SecureRandom / Rails.logger / ENV reads in domain code,
+  no Timecop in inner-loop specs, no mocks in acceptance specs.
+  Three of the six autocorrect to the injected-collaborator form.
+email:
+- tommy.caruso2118@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- config/default.yml
+- lib/rubocop-hgoostdd.rb
+- lib/rubocop/cop/hgoostdd/no_env_outside_app_config.rb
+- lib/rubocop/cop/hgoostdd/no_mocks_in_acceptance.rb
+- lib/rubocop/cop/hgoostdd/no_rails_logger_in_domain.rb
+- lib/rubocop/cop/hgoostdd/no_secure_random_in_domain.rb
+- lib/rubocop/cop/hgoostdd/no_time_in_domain.rb
+- lib/rubocop/cop/hgoostdd/no_timecop_in_domain_specs.rb
+- lib/rubocop/hgoostdd/inject.rb
+- lib/rubocop/hgoostdd/version.rb
+- rubocop-hgoostdd.gemspec
+homepage: https://github.com/tommy2118/rubocop-hgoostdd
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/tommy2118/rubocop-hgoostdd
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: RuboCop cops enforcing Hardened GOOS TDD discipline
+test_files: []