jpie 2.1.0 → 2.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b40ba16f3f137fa6f71b5f03a5aae566168c602ecab473c8804991a5b37ed70f
-  data.tar.gz: ea9ba44be05ef07e7306ff0772377277f8f25eab9c199fbe2d3f7be7fc2477ac
+  metadata.gz: ff291316aa0dff52e52421edfb945d6c450224761af9552da4cf80c5d5939385
+  data.tar.gz: d20184a0ff94d93da07a167088fdd5ea12346698e5324554a9ee5b4e232784f6
 SHA512:
-  metadata.gz: 216f53ac57192799de8c9864b72d19da9c9284600c4e6b5807ef3c1aca501986411a5a110cfd5ae862066ab033c9b8d85002cb1a1c5a9232129221d2228356d0
-  data.tar.gz: d59596b504c0c69d9783ab590fdf70053ee7728def4ecc38902cb32f70d6313d81bfda425307bb8e0673e47daa808829df37e163cfe97c12767307ab29515ee9
+  metadata.gz: 5ef0a9f42b050d26a21545044b985d5deb9cd3417e073e5ec26d9fc462f954c687c547fd850f1a93b3bd7567d0d1b24418f289b61373792a5f6b7005af90885c
+  data.tar.gz: fa80175057fb038cc79ec2c3ee5fa01ac33758c72fd4f618369cd245f8dd3a4c2a2c8c7612ed2ff49f49374514aafb27abab55c801866821a92ae502582c2970

data/.claude/skills/root-cause-analysis/SKILL.md

@@ -20,6 +20,8 @@ Do NOT use when the cause is already known and verified, or for routine implemen
 
 **Find root cause before attempting fixes.** Quick patches mask underlying issues. If you are trying fixes without understanding why they might work, you are guessing—stop and investigate.
 
+Do not change code just to pass specs, and do not change specs just to make them pass. Specs must test real functionality; both code and specs should be fixed so that they correctly reflect and verify the intended behaviour.
+
 ## Problem definition (observable symptom only)
 
 Define the problem in terms of **what is observed**, not assumed cause:

data/.cursor/agents/systematic-debugging.md

@@ -9,6 +9,8 @@ You are a systematic debugging specialist for the json_api gem (JPie). Your only
 
 **ALWAYS find root cause before attempting fixes.** Symptom fixes are failure. Quick patches mask underlying issues. If you are trying fixes without understanding why they might work, you are guessing—stop and investigate.
 
+Do not recommend changing code just to pass specs, or changing specs just to make them pass. Specs must test real functionality; recommend fixes that make code and specs correctly reflect and verify intended behaviour.
+
 ## Four phases (complete in order)
 
 ### Phase 1: Investigation

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    jpie (2.1.0)
+    jpie (2.1.3)
       actionpack (~> 8.1, >= 8.1.0)
       pg_query (>= 4)
       prosopite (>= 1)

data/lib/json_api/controllers/concerns/resource_actions/filter_validation.rb

@@ -21,26 +21,15 @@ module JSONAPI
         check_filter_parts(parts, @resource_class, model_class)
       end
 
-      def check_filter_parts(parts, res_cls, mod_cls, allow_related: false)
+      def check_filter_parts(parts, res_cls, mod_cls)
         return false if parts.empty?
-        return single_filter_valid?(parts.first, res_cls, mod_cls, allow_related) if parts.length == 1
+        return single_filter_valid?(parts.first, res_cls) if parts.length == 1
 
         check_nested_filter(parts, res_cls, mod_cls)
       end
 
-      def single_filter_valid?(name, res_cls, mod_cls, allow_related)
-        return true if res_cls.permitted_filters.map(&:to_s).include?(name)
-        return false unless allow_related
-
-        related_column_valid?(name, mod_cls)
-      end
-
-      def related_column_valid?(name, mod_cls)
-        col = parse_column_filter(name)
-        return true if col && mod_cls.column_for_attribute(col[:column])
-        return true if mod_cls.column_names.include?(name)
-
-        mod_cls.respond_to?(name.to_sym)
+      def single_filter_valid?(name, res_cls)
+        res_cls.permitted_filters.map(&:to_s).include?(name)
       end
 
       def check_nested_filter(parts, res_cls, mod_cls)
@@ -59,7 +48,7 @@ module JSONAPI
         rel_res = JSONAPI::Resource.resource_for_model(rel_mod)
         return false unless rel_res
 
-        check_filter_parts(parts, rel_res, rel_mod, allow_related: true)
+        check_filter_parts(parts, rel_res, rel_mod)
       end
 
       def filter_rel_allowed?(res_cls, rel)

data/lib/json_api/resources/resource_loader.rb

@@ -17,25 +17,27 @@ module JSONAPI
     end
 
     def self.find(resource_type, namespace: nil)
-      return find_namespaced(resource_type, namespace) if namespace.present?
+      candidates = []
 
-      find_flat(resource_type, namespace)
-    end
+      # Namespaced resource, e.g. "widgets" with namespace "api/v1" → API::V1::WidgetResource
+      candidates << build_resource_class_name(resource_type, namespace) if namespace
 
-    def self.find_namespaced(resource_type, namespace)
-      namespaced_class = build_resource_class_name(resource_type, namespace)
-      namespaced_class.constantize
-    rescue NameError
-      raise MissingResourceClass.new(resource_type, namespace:) unless JSONAPI.configuration.namespace_fallback
+      # Flat resource, e.g. "widgets" → WidgetResource
+      if !namespace || JSONAPI.configuration.namespace_fallback
+        candidates << build_resource_class_name(resource_type,
+                                                nil,)
+      end
 
-      find_flat(resource_type, namespace)
+      resolve(candidates) || raise(MissingResourceClass.new(resource_type, namespace:))
     end
 
-    def self.find_flat(resource_type, namespace)
-      flat_class = build_resource_class_name(resource_type, nil)
-      flat_class.constantize
-    rescue NameError
-      raise MissingResourceClass.new(resource_type, namespace:)
+    def self.find_for_model(model_class, namespace: nil)
+      return ActiveStorageBlobResource if active_storage_blob?(model_class)
+
+      effective_namespace = namespace || extract_namespace_from_model(model_class)
+      candidates = model_candidates(model_class, effective_namespace)
+
+      resolve(candidates) || raise(MissingResourceClass.new(model_class.name, namespace: effective_namespace))
     end
 
     def self.build_resource_class_name(resource_type, namespace)
@@ -45,35 +47,42 @@ module JSONAPI
       "#{namespace.to_s.camelize}::#{base}"
     end
 
-    def self.find_for_model(model_class, namespace: nil)
-      return ActiveStorageBlobResource if active_storage_blob?(model_class)
+    # Builds an ordered list of candidate class names for a model, including
+    # STI base class candidates as a fallback.
+    def self.model_candidates(model_class, namespace)
+      candidates = candidates_for_class(model_class, namespace)
 
-      find_resource_for_model(model_class, namespace)
+      if sti_subclass?(model_class)
+        base = model_class.base_class
+        base_ns = extract_namespace_from_model(base) || namespace
+        candidates.concat(candidates_for_class(base, base_ns))
+      end
+
+      candidates
     end
 
-    def self.find_resource_for_model(model_class, namespace)
-      effective_namespace = namespace || extract_namespace_from_model(model_class)
+    def self.candidates_for_class(model_class, namespace)
       resource_type = model_class.name.demodulize.underscore.pluralize
+      candidates = []
 
-      find(resource_type, namespace: effective_namespace)
-    rescue MissingResourceClass
-      try_flat_full_name_resource(model_class) || find_base_class_resource(model_class, effective_namespace)
-    end
+      # Namespaced resource matching the model's namespace, e.g. API::V1::Widget → API::V1::WidgetResource
+      candidates << build_resource_class_name(resource_type, namespace) if namespace
 
-    def self.try_flat_full_name_resource(model_class)
-      return nil unless model_class.name.include?("::")
+      # Flat-combined name for namespaced models, e.g. Ticket::User → TicketUserResource
+      candidates << "#{model_class.name.gsub("::", "")}Resource" if model_class.name.include?("::")
 
-      "#{model_class.name.gsub("::", "")}Resource".constantize
-    rescue NameError
-      nil
-    end
+      # Standard flat resource using demodulized model name, e.g. User → UserResource
+      candidates << build_resource_class_name(resource_type, nil)
 
-    def self.find_base_class_resource(model_class, effective_namespace)
-      raise MissingResourceClass, model_class.name unless sti_subclass?(model_class)
+      candidates
+    end
 
-      base_resource_type = model_class.base_class.name.demodulize.underscore.pluralize
-      base_namespace = extract_namespace_from_model(model_class.base_class) || effective_namespace
-      find(base_resource_type, namespace: base_namespace)
+    def self.resolve(candidates)
+      candidates.each do |name|
+        klass = name.safe_constantize
+        return klass if klass
+      end
+      nil
     end
 
     def self.active_storage_blob?(model_class)

data/lib/json_api/support/concerns/condition_building.rb

@@ -13,8 +13,6 @@ module JSONAPI
       end
 
       def normalize_filter_value_for_model(model, column, raw_value)
-        return nil unless column
-
         value = raw_value.is_a?(Array) ? raw_value.first : raw_value
         return nil if value.nil?
 
@@ -39,6 +37,19 @@ module JSONAPI
         lower_attr.matches(pattern.downcase)
       end
 
+      def apply_column_filter(scope, model, filter_name, raw_value)
+        column_filter = parse_column_filter(filter_name)
+        return nil unless column_filter
+        return nil unless model.column_names.include?(column_filter[:column])
+
+        column = model.column_for_attribute(column_filter[:column])
+        value = normalize_filter_value_for_model(model, column, raw_value)
+        return nil unless value
+
+        condition = build_condition(model, column, value, column_filter[:operator])
+        condition ? apply_condition(scope, condition) : nil
+      end
+
       def apply_condition(scope, condition)
         scope.where(condition)
       end

data/lib/json_api/support/concerns/nested_filters.rb

@@ -81,40 +81,12 @@ module JSONAPI
       def apply_filter_on_model(scope, target_model, target_resource, filter_name, filter_value)
         return scope if empty_filter_value?(filter_value)
 
-        apply_column_operator_filter(scope, target_model, filter_name, filter_value) ||
-          apply_direct_column_filter(scope, target_model, filter_name, filter_value) ||
+        apply_column_filter(scope, target_model, filter_name, filter_value) ||
           apply_scope_method_filter(scope, target_model, target_resource, filter_name, filter_value) ||
           scope
       end
 
-      def apply_column_operator_filter(scope, target_model, filter_name, filter_value)
-        column_filter = parse_column_filter(filter_name)
-        return nil unless column_filter
-
-        column = target_model.column_for_attribute(column_filter[:column])
-        return nil unless column
-
-        value = normalize_filter_value_for_model(target_model, column, filter_value)
-        return nil unless value
-
-        condition = build_condition(target_model, column, value, column_filter[:operator])
-        condition ? apply_condition(scope, condition) : nil
-      end
-
-      def apply_direct_column_filter(scope, target_model, filter_name, filter_value)
-        return nil unless target_model.column_names.include?(filter_name)
-
-        scope.where(target_model.table_name => { filter_name => filter_value })
-      end
-
-      def apply_scope_method_filter(scope, target_model, target_resource, filter_name, filter_value)
-        if target_model.respond_to?(filter_name.to_sym)
-          return try_scope_method(scope, target_model, filter_name,
-                                  filter_value,)
-        end
-
-        return nil unless target_resource
-        return nil unless target_resource.permitted_filters.map(&:to_s).include?(filter_name)
+      def apply_scope_method_filter(scope, target_model, _target_resource, filter_name, filter_value)
         return nil unless target_model.respond_to?(filter_name.to_sym)
 
         try_scope_method(scope, target_model, filter_name, filter_value)

data/lib/json_api/support/concerns/regular_filters.rb

@@ -19,36 +19,8 @@ module JSONAPI
       def apply_regular_filter(scope, filter_name, filter_value)
         return scope if empty_filter_value?(filter_value)
 
-        column_filter = parse_column_filter(filter_name)
-        if column_filter
-          apply_column_filter(scope, column_filter, filter_value)
-        else
+        apply_column_filter(scope, model_class, filter_name, filter_value) ||
           apply_scope_fallback(scope, filter_name, filter_value)
-        end
-      end
-
-      def apply_column_filter(scope, column_filter, raw_value)
-        condition = build_column_condition(column_filter, raw_value)
-        condition ? apply_condition(scope, condition) : scope
-      rescue StandardError => e
-        log_filter_error(column_filter, column_filter[:operator], e)
-        scope
-      end
-
-      def build_column_condition(column_filter, raw_value)
-        column = model_class.column_for_attribute(column_filter[:column])
-        return nil unless column
-
-        value = normalize_filter_value_for_model(model_class, column, raw_value)
-        return nil if value.nil?
-
-        build_condition(model_class, column, value, column_filter[:operator])
-      end
-
-      def log_filter_error(column_filter, operator, error)
-        return unless defined?(Rails.logger)
-
-        Rails.logger.warn("Filter error for #{column_filter[:column]}_#{operator}: #{error.class} - #{error.message}")
       end
 
       def apply_scope_fallback(scope, filter_name, filter_value)

data/lib/json_api/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JSONAPI
-  VERSION = "2.1.0"
+  VERSION = "2.1.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jpie
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.1.3
 platform: ruby
 authors:
 - Emil Kampp