hecks 2.7.0 → 2.9.0

data/lib/hecks/bluebook/model_check/client_profile.rb

@@ -1,83 +1,37 @@
 module Hecks
   module Bluebook
     module ModelCheck
-      # The opt-in `client` profile: refuses the bluebook constructs this
-      # repository already knows produce a silently wrong answer, so a client
-      # domain cannot reach one without being told.
+      # The opt-in `client` profile: refuses bluebook constructs already known
+      # to produce a silently wrong answer, so a client domain can't reach one
+      # unnoticed.
       #
-      # ## What it is not
-      #
-      # It fixes nothing. Each rule below names a bug that is still open and
-      # stops a domain reaching it unnoticed; when the bug is fixed the rule
-      # goes with it. `spec/model_check_client_profile_spec.rb` holds a probe
-      # per rule that runs the buggy code and fails the moment the bug stops
-      # reproducing, naming the rule to delete.
-      #
-      # ## The rules
-      #
-      # - `:client_group_by_row_drop` — a `group_by` whose fields do not include
-      #   the grouped aggregate's whole identity. Rows sharing a key path are
-      #   collapsed to the first, on every adapter (docs/decisions/0061).
-      # - `:client_native_read_model` — a read model the SQLite projection
-      #   answers natively, where every other path answers it in process
-      #   (docs/1.0-readiness.md, "Known gaps at 1.0", item 2).
-      # - `:client_dotted_compute_source` — an era translation `compute` whose
-      #   source is a dotted path, which never fires
-      #   (`Translation::RuleCompiler.compile_compute`).
+      # Each rule names a bug that is still open; delete the rule when the bug is fixed.
       module ClientProfile
         # Adapters whose Ruby class implements `query_read_model`, which is what
         # makes `ReadModelInterpreter#project` take the native path. The spec
         # checks this list against the adapter classes themselves.
         NATIVE_READ_MODEL_ADAPTERS = %w[SqliteProjection].freeze
 
-        GROUP_BY_TRACKER = "docs/decisions/0061-query-dsl-aggregation-count-sum-group-by.md".freeze
         NATIVE_READ_MODEL_TRACKER = "docs/1.0-readiness.md (Known gaps at 1.0, item 2)".freeze
-        DOTTED_COMPUTE_TRACKER = "Translation::RuleCompiler.compile_compute, and the pending example " \
-                                 "\"applies the SQL of a compute whose source is a dotted member\" in " \
-                                 "spec/adapters/driven/postgres_era/migration_data_safety_spec.rb".freeze
 
         module_function
 
-        # Runs every client-profile rule over one chapter and its translations.
+        # Runs every client-profile rule over one chapter.
         #
         # @param bluebook [Bluebook::Chapter] the assembled chapter to check
         # @param hecksagon [Bluebook::Hecksagon, nil] the chapter's sibling wiring file; without
         #   one no aggregate is projected, so the native-read-model rule has nothing to find
-        # @param translations [Array<Bluebook::Translation>] the data translations declared for
-        #   this chapter's domain
         # @return [Array<ModelCheck::Finding>] one error-severity finding per construct refused
-        def call(bluebook, hecksagon: nil, translations: [])
+        def call(bluebook, hecksagon: nil)
           bluebook.read_models.flat_map do |model|
-            group_by_findings(bluebook, model) + native_read_model_findings(model, hecksagon)
-          end + dotted_compute_findings(translations)
-        end
-
-        # Refuses a `group_by` that cannot prove each of its key paths names one row.
-        #
-        # The interpreter's `nest` keeps `stripped.first` per key path, whichever adapter
-        # supplied the rows, because a `group_by` model never reaches the native path. Grouping
-        # by the aggregate's whole identity is the one shape that cannot collide.
-        #
-        # @param bluebook [Bluebook::Chapter] the chapter the read model is declared in
-        # @param model [Bluebook::ReadModel] the read model to inspect
-        # @return [Array<ModelCheck::Finding>] one finding, or `[]` when `model` declares no
-        #   `group_by` or groups by its aggregate's whole identity
-        def group_by_findings(bluebook, model)
-          return [] if model.group_by.empty? || groups_by_identity?(bluebook, model)
-
-          [finding(:client_group_by_row_drop, model.name,
-                   "group_by #{model.group_by_fields.map(&:inspect).join(', ')} does not cover the grouped " \
-                   "aggregate's whole identity, so rows sharing a key path are silently reduced to the " \
-                   "first. Tracked in #{GROUP_BY_TRACKER}.")]
+            native_read_model_findings(model, hecksagon)
+          end
         end
 
         # Refuses a read model that the SQLite projection would answer natively.
         #
-        # Mirrors the fork in `ReadModelInterpreter#project`: a rooted model with no `group_by`,
-        # `count` or `median` reads through `read_repository`, which is a projection repository
-        # only for an aggregate with a `projected_by` bind. Whether that projection is current
-        # is only known at run time (`Registry#projection_current?`), so a model eligible here
-        # can also silently run in process.
+        # Mirrors the fork in `ReadModelInterpreter#project`: which path runs is only
+        # known at run time, so a model eligible here can still run in process.
         #
         # @param model [Bluebook::ReadModel] the read model to inspect
         # @param hecksagon [Bluebook::Hecksagon, nil] the wiring holding the `projected_by` binds
@@ -95,26 +49,6 @@ module Hecks
                    "is not, and nothing checks the two agree. Tracked in #{NATIVE_READ_MODEL_TRACKER}.")]
         end
 
-        # Refuses a translation `compute` whose source names a member of a value object.
-        #
-        # `compile_compute` guards the compute with `__s ? '<from>'`, a top-level key test, so a
-        # dotted source never matches, the mint succeeds and the record keeps its old value.
-        #
-        # @param translations [Array<Bluebook::Translation>] the translations to inspect
-        # @return [Array<ModelCheck::Finding>] one finding per dotted-source compute
-        def dotted_compute_findings(translations)
-          translations.flat_map do |translation|
-            translation.aggregates.flat_map do |aggregate|
-              aggregate.computes.select { |compute| compute.from.to_s.include?(".") }.map do |compute|
-                finding(:client_dotted_compute_source, "#{translation.domain}::#{aggregate.name}",
-                        "compute #{compute.from.to_s.inspect} has a dotted source, which the compiled SQL " \
-                        "never matches, so the mint succeeds and leaves the old value in place. " \
-                        "Tracked in #{DOTTED_COMPUTE_TRACKER}.")
-              end
-            end
-          end
-        end
-
         # Reports whether a model's shape sends it down the native path in `#project`.
         #
         # @param model [Bluebook::ReadModel] the read model to inspect
@@ -123,21 +57,6 @@ module Hecks
           !model.reference_target.nil? && model.group_by.empty? && !model.count? && !model.median_field
         end
 
-        # Reports whether a `group_by` names every identity path of the aggregate it groups.
-        #
-        # @param bluebook [Bluebook::Chapter] the chapter the read model is declared in
-        # @param model [Bluebook::ReadModel] a read model that declares a `group_by`
-        # @return [Boolean] false when the many-side aggregate is not a top-level aggregate or
-        #   declares no identity, since uniqueness cannot then be shown
-        def groups_by_identity?(bluebook, model)
-          target = model.aggregate_heads.find { |head| head[:many] }
-          aggregate = target && bluebook.aggregate(target[:aggregate])
-          return false unless aggregate
-
-          identity = Array(aggregate.identity_heads).map(&:to_sym)
-          !identity.empty? && (identity - model.group_by_fields.map(&:to_sym)).empty?
-        end
-
         # Builds one error-severity finding of this profile.
         #
         # @param kind [Symbol] the finding's kind, one of the `:client_*` rules above