kennel 1.139.0 → 1.140.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33d7570c6b4d70c6d50f89d0111d8db96e6c0c0ba9273d00bb0975acfef12526
-  data.tar.gz: ea89fdf62138917a204e9c619a7a1182acca1e8d898f22e16707d0a02685cd26
+  metadata.gz: e8a15178bd108647314171a012bafa0c977f998a8488418c0d323de095e0a1b3
+  data.tar.gz: 1673aec908b72090afa31e0b3dd8a923dbf505c01ab2f5dfd6211846edab4f7d
 SHA512:
-  metadata.gz: de01f19064531cb09615b63056b1eaa82118a4734fbdd9afa44eef56019923a736b45f9f4440da584cd0939231f7d7928f9a819cbfdb2f014336e82ee0f66c7e
-  data.tar.gz: ec59ee486794d91f5af93e8b3f77134ff206b6f653cc424c3e337b6893fefef1a6fb92a401029e2f5fd4ca83db49c1d284bf556105ad6d38667b3825667bb973
+  metadata.gz: 0343af2d0a40081a7fd8ffe5bb9932344f75ef91f1b688f4b6e4eb72a0bd5f59c9b67cf72f498bb008f76aae7f6df645b0bcd8258b5c1c892cb8cd3ef21cc468
+  data.tar.gz: 3a1f1df7f6195ec235713dc173e8c869013654355432159e1bd1e59dd29ea3d849407ee9cf43f31453411a54224ae1ea8b80bc1e01e209176d0cfe28f8fc2bc3

data/lib/kennel/models/record.rb

@@ -2,14 +2,6 @@
 module Kennel
   module Models
     class Record < Base
-      class PrepareError < StandardError
-        def initialize(tracking_id)
-          super("Error while preparing #{tracking_id}")
-        end
-      end
-
-      UnvalidatedRecordError = Class.new(StandardError)
-
       include OptionalValidations
 
       # Apart from if you just don't like the default for some reason,
@@ -85,12 +77,12 @@ module Kennel
         end
       end
 
-      attr_reader :project, :unfiltered_validation_errors, :filtered_validation_errors
+      attr_reader :project, :as_json
 
-      def initialize(project, *args)
+      def initialize(project, ...)
         raise ArgumentError, "First argument must be a project, not #{project.class}" unless project.is_a?(Project)
         @project = project
-        super(*args)
+        super(...)
       end
 
       def diff(actual)
@@ -141,29 +133,9 @@ module Kennel
       end
 
       def build
-        @unfiltered_validation_errors = []
-        json = nil
-
-        begin
-          json = build_json
-          (id = json.delete(:id)) && json[:id] = id
-          validate_json(json)
-        rescue StandardError
-          if unfiltered_validation_errors.empty?
-            @unfiltered_validation_errors = nil
-            raise PrepareError, safe_tracking_id # FIXME: this makes errors hard to debug when running tests
-          end
-        end
-
-        @filtered_validation_errors = filter_validation_errors
-        @as_json = json # Only valid if filtered_validation_errors.empty?
-      end
-
-      def as_json
-        # A courtesy to those tests that still expect as_json to perform validation and raise on error
-        build if @unfiltered_validation_errors.nil?
-        raise UnvalidatedRecordError, "#{safe_tracking_id} as_json called on invalid part" if filtered_validation_errors.any?
-
+        @as_json = build_json
+        (id = @as_json.delete(:id)) && @as_json[:id] = id
+        validate_json(@as_json)
         @as_json
       end
 
@@ -184,6 +156,17 @@ module Kennel
 
       private
 
+      def validate_json(data)
+        bad = Kennel::Utils.all_keys(data).grep_v(Symbol).sort.uniq
+        return if bad.empty?
+        invalid!(
+          :hash_keys_must_be_symbols,
+          "Only use Symbols as hash keys to avoid permanent diffs when updating.\n" \
+          "Change these keys to be symbols (usually 'foo' => 1 --> 'foo': 1)\n" \
+          "#{bad.map(&:inspect).join("\n")}"
+        )
+      end
+
       def resolve(value, type, id_map, force:)
         return value unless tracking_id?(value)
         resolve_link(value, type, id_map, force: force)
@@ -214,10 +197,6 @@ module Kennel
         end
       end
 
-      def invalid!(tag, message)
-        unfiltered_validation_errors << ValidationMessage.new(tag || OptionalValidations::UNIGNORABLE, message)
-      end
-
       def raise_with_location(error, message)
         super error, "#{message} for project #{project.kennel_id}"
       end

data/lib/kennel/optional_validations.rb

@@ -4,80 +4,89 @@ module Kennel
     ValidationMessage = Struct.new(:tag, :text)
 
     UNIGNORABLE = :unignorable
+    UNUSED_IGNORES = :unused_ignores
 
     def self.included(base)
       base.settings :ignored_errors
       base.defaults(ignored_errors: -> { [] })
+      base.attr_reader :validation_errors
     end
 
-    def self.valid?(parts)
-      parts_with_errors = parts.reject do |part|
-        part.filtered_validation_errors.empty?
-      end
+    def initialize(...)
+      super
+      @validation_errors = []
+    end
 
-      return true if parts_with_errors.empty?
+    def invalid!(tag, message)
+      validation_errors << ValidationMessage.new(tag || OptionalValidations::UNIGNORABLE, message)
+    end
 
-      example_tag = nil
+    def self.valid?(parts)
+      parts_with_errors = parts.map { |p| [p, filter_validation_errors(p)] }
+      return true if parts_with_errors.all? { |_, errors| errors.empty? }
 
+      # print errors in order
+      example_tag = nil
       Kennel.err.puts
-      parts_with_errors.sort_by(&:safe_tracking_id).each do |part|
-        part.filtered_validation_errors.each do |err|
+      parts_with_errors.sort_by! { |p, _| p.safe_tracking_id }
+      parts_with_errors.each do |part, errors|
+        errors.each do |err|
           Kennel.err.puts "#{part.safe_tracking_id} [#{err.tag.inspect}] #{err.text.gsub("\n", " ")}"
           example_tag = err.tag unless err.tag == :unignorable
         end
       end
       Kennel.err.puts
 
-      Kennel.err.puts <<~MESSAGE if example_tag
-        If a particular error cannot be fixed, it can be marked as ignored via `ignored_errors`, e.g.:
-          Kennel::Models::Monitor.new(
-            ...,
-            ignored_errors: [#{example_tag.inspect}]
-          )
+      if example_tag
+        Kennel.err.puts <<~MESSAGE
+          If a particular error cannot be fixed, it can be marked as ignored via `ignored_errors`, e.g.:
+            Kennel::Models::Monitor.new(
+              ...,
+              ignored_errors: [#{example_tag.inspect}]
+            )
 
-      MESSAGE
+        MESSAGE
+      end
 
       false
     end
 
-    private
-
-    def validate_json(data)
-      bad = Kennel::Utils.all_keys(data).grep_v(Symbol).sort.uniq
-      return if bad.empty?
-      invalid!(
-        :hash_keys_must_be_symbols,
-        "Only use Symbols as hash keys to avoid permanent diffs when updating.\n" \
-        "Change these keys to be symbols (usually 'foo' => 1 --> 'foo': 1)\n" \
-        "#{bad.map(&:inspect).join("\n")}"
-      )
-    end
+    def self.filter_validation_errors(part)
+      errors = part.validation_errors
+      ignored_tags = part.ignored_errors
 
-    def filter_validation_errors
-      if unfiltered_validation_errors.empty?
-        if ignored_errors.empty?
+      if errors.empty? # 95% case, so keep it fast
+        if ignored_tags.empty? || ignored_tags.include?(UNUSED_IGNORES)
           []
         else
-          [ValidationMessage.new(UNIGNORABLE, "`ignored_errors` is non-empty, but there are no errors to ignore. Remove `ignored_errors`")]
+          # tell users to remove the whole line and not just an element
+          [
+            ValidationMessage.new(
+              UNUSED_IGNORES,
+              "`ignored_errors` is non-empty, but there are no errors to ignore. Remove `ignored_errors`"
+            )
+          ]
         end
       else
-        to_report =
-          if ENV["NO_IGNORED_ERRORS"]
-            # Turn off all suppressions, to see what errors are actually being suppressed
-            unfiltered_validation_errors
+        reported_errors =
+          if ENV["NO_IGNORED_ERRORS"] # let users see what errors are suppressed
+            errors
           else
-            unfiltered_validation_errors.reject do |err|
-              err.tag != UNIGNORABLE && ignored_errors.include?(err.tag)
-            end
+            errors.select { |err| err.tag == UNIGNORABLE || !ignored_tags.include?(err.tag) }
           end
 
-        unused_ignores = ignored_errors - unfiltered_validation_errors.map(&:tag)
-
-        if unused_ignores.any?
-          to_report << ValidationMessage.new(UNIGNORABLE, "Unused ignores #{unused_ignores.map(&:inspect).sort.uniq.join(" ")}. Remove these from `ignored_errors`")
+        # let users know when they can remove an ignore ... unless they don't care (for example for a generic monitor)
+        unless ignored_tags.include?(UNUSED_IGNORES)
+          unused_ignored_tags = ignored_tags - errors.map(&:tag)
+          if unused_ignored_tags.any?
+            reported_errors << ValidationMessage.new(
+              UNUSED_IGNORES,
+              "Unused ignores #{unused_ignored_tags.map(&:inspect).sort.uniq.join(" ")}. Remove these from `ignored_errors`"
+            )
+          end
         end
 
-        to_report
+        reported_errors
       end
     end
   end

data/lib/kennel/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Kennel
-  VERSION = "1.139.0"
+  VERSION = "1.140.0"
 end

data/lib/kennel.rb

@@ -127,7 +127,7 @@ module Kennel
           Utils.parallel(parts, &:build)
         end
 
-        OptionalValidations.valid?(parts) or raise GenerationAbortedError
+        OptionalValidations.valid?(parts) || raise(GenerationAbortedError)
 
         parts
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kennel
 version: !ruby/object:Gem::Version
-  version: 1.139.0
+  version: 1.140.0
 platform: ruby
 authors:
 - Michael Grosser
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-26 00:00:00.000000000 Z
+date: 2023-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs