svelte-on-rails 9.3.3 → 9.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6acd26e8d04eaa789b173da6fefb7d0746a5594e3924bca9329c2deeedc66d7f
-  data.tar.gz: e518a366fc727de81797f9159371f3d917926956cf3046439944baa1aa641fd6
+  metadata.gz: 4351ebf2a7a0cb7a957bf9593eaa07f2eb158d5e29c3d28ceca46a45ab4ba664
+  data.tar.gz: 406e23ce8765f4ac0387b26cf0384bf8edbd5666bf2049dcc689ea55592230f0
 SHA512:
-  metadata.gz: 0f4c20a508c14810fff8570bca050f23b1e12babe1d6939f90046d43ebcbe14c85ce237f441b83227c9888dcd4d3c4518562bf4e8f73f11eba6b077fd21dc5fd
-  data.tar.gz: 1ddf6e95118890b7c46849ff2ed97f4953fe164fff42ea6bb4cbaa84973528c9c1209be1393f6d30bda5b5d12a89a999ad91ceb7f31b5787aa40fec2945807b2
+  metadata.gz: dd17c528584d0f2cca9ee940e17ef7079c371c47c3ecb8d8c7881efa0321922ff1281703f6603c1c44455e3eed9720621e4e20903179f29a0332b7983f5c0fae
+  data.tar.gz: 575032b254b1d6cfb09f0d669564f55581436936377ed15938fe816d2acb8e782594027caef777d5b0bfda213aaabf837dd8cc5492dff832d700976b98fda547

data/lib/svelte_on_rails/active_record_extensions.rb

@@ -8,7 +8,7 @@ module SvelteOnRails
     def to_svelte(*attributes, **associations)
       @to_svelte ||= begin
 
-                       tsv = SvelteOnRails::Lib::ToSvelteValues.new
+                       tsv = SvelteOnRails::Lib::ToSvelteValues
                        tsl = SvelteOnRails::Lib::ToSvelteLabels.new
                        res = tsl.extract_labels(self.class, attributes, associations)
 
@@ -42,7 +42,7 @@ module SvelteOnRails
     def to_svelte(*attributes, **associations)
       @to_svelte ||= begin
                        cl = SvelteOnRails::Lib::ToSvelteValues
-                       val = cl.new.extract_values(self, attributes, associations)
+                       val = cl.extract_values(self, attributes, associations)
 
                        tsl = SvelteOnRails::Lib::ToSvelteLabels.new
                        res = tsl.extract_labels(self.klass, attributes, associations)

data/lib/svelte_on_rails/lib/to_svelte_values.rb

@@ -1,75 +1,125 @@
 module SvelteOnRails
   module Lib
     class ToSvelteValues
-      def extract_values(record, attributes, associations, call_stack: 0)
+      # Public API – returns Hash for single record, Array<Hash> for collections
+      def self.extract_values(record, attributes = [], associations = {})
+        records = normalize_to_enumerable(record, associations)
 
-        next_stack = call_stack + 1
+        result = extract_values_recursive(records, attributes, associations, call_stack: 0)
+
+        # Mirror input shape for the top-level return value
+        looks_like_single?(record) ? (result.first || {}) : result
+      end
 
-        if record.respond_to?(:each)
-
-          recs2 = if associations.include?(:offset) || associations.include?(:limit)
-                    if (record.is_a?(ActiveRecord::Relation) || record.is_a?(ActiveRecord::Associations::CollectionProxy) rescue false)
-                      _recs = (associations[:offset] ? record.offset(associations[:offset]) : record)
-                      (associations[:limit] ? _recs.limit(associations[:limit]) : _recs)
-                    elsif record.respond_to?(:drop) && record.respond_to?(:take) # that might be a array
-                      _recs = associations[:offset] ? record.drop(associations[:offset]) : record
-                      associations[:limit] ? _recs.take(associations[:limit]) : _recs
-                    else
-                      raise "[svelte-on-rails:to_svelte] unknown class for records: #{record}"
-                    end
-                  else
-                    record
-                  end
-
-          values = recs2.map do |rec|
-            extract_values(rec, attributes, associations, call_stack: next_stack)
+      private
+
+      def self.normalize_to_enumerable(record, associations)
+        if looks_like_collection?(record)
+          apply_pagination(record, associations)
+        else
+          [record]  # single → wrap → recursive code can be uniform
+        end
+      end
+
+      def self.apply_pagination(coll, associations)
+        if associations.key?(:offset) || associations.key?(:limit)
+          if active_record_collection?(coll)
+            scope = coll
+            scope = scope.offset(associations[:offset]) if associations.key?(:offset)
+            scope = scope.limit(associations[:limit])  if associations.key?(:limit)
+            scope.to_a
+          elsif coll.respond_to?(:drop) && coll.respond_to?(:take)
+            res = coll
+            res = res.drop(associations[:offset]) if associations.key?(:offset)
+            res = res.take(associations[:limit])  if associations.key?(:limit)
+            res
+          else
+            raise "[svelte-on-rails:to_svelte] Cannot paginate #{coll.class}"
           end
+        else
+          coll.respond_to?(:to_a) ? coll.to_a : coll
+        end
+      end
+
+      def self.extract_values_recursive(thing, attributes, associations, call_stack:)
+        next_stack = call_stack + 1
 
+        if collection_like?(thing)
+          thing.map do |record|
+            extract_single_record(record, attributes, associations, next_stack)
+          end
         else
+          extract_single_record(thing, attributes, associations, next_stack)
+        end
+      end
 
-          # we have a single record
+      def self.extract_single_record(record, attributes, associations, next_stack)
+        return {} unless record  # or raise – depending on your preference
 
-          values = {}
-          enums = record.class.defined_enums
+        values = {}
 
-          attributes.each do |attr|
-            raise "Invalid attribute «#{attr}» on «#{record.class}»" unless [Symbol, String].include?(attr.class)
-            raise "[svelte-on-rails:to_svelte] #{record.class} does not respond to: #{attr}" unless record.respond_to?(attr)
-            key_s = attr.to_s
+        enums = record.class.try(:defined_enums) || {}
 
-            if enums.key?(key_s)
-              values[key_s] = record.send(key_s)
-            else
-              values[key_s] = record.send(key_s)
-            end
+        attributes.each do |attr|
+          validate_attribute!(record, attr)
 
-          end
+          key_s = attr.to_s
+          value = record.send(attr)
 
-          associations.each do |key, val|
-            key_s = key.to_s
-            next if ['offset', 'limit'].include?(key_s)
-            _attrs, _assocs = SvelteOnRails::Lib::ToSvelteSupport.separate_associations(val)
-            reflect = record.class.reflect_on_association(key_s)
-            raise "invalid association: «#{key_s}» for «#{record.class}»" unless reflect
-
-            recs = record.send(key_s)
-            if recs.present?
-              values[key_s] = extract_values(
-                recs,
-                _attrs,
-                _assocs,
-                call_stack: next_stack
-              )
-            end
+          values[key_s] = enums.key?(key_s) ? record.send(key_s) : value
+        end
 
-          end
+        associations.each do |key, val|
+          key_s = key.to_s
+          next if %w[offset limit].include?(key_s)
+
+          reflection = record.class.reflect_on_association(key_s)
+          raise ArgumentError, "No association #{key_s.inspect} on #{record.class}" unless reflection
+
+          related = record.send(key_s)
+          next if related.nil? || (related.respond_to?(:empty?) && related.empty?)
+
+          sub_attrs, sub_assocs = SvelteOnRails::Lib::ToSvelteSupport.separate_associations(val)
+
+          values[key_s] = extract_values_recursive(
+            related,
+            sub_attrs,
+            sub_assocs,
+            call_stack: next_stack
+          )
         end
 
         values
+      end
+
+      # Helpers ────────────────────────────────────────────────
 
+      def self.looks_like_single?(obj)
+        !looks_like_collection?(obj)
       end
 
+      def self.looks_like_collection?(obj)
+        return false if obj.nil? || obj.is_a?(Hash) || obj.is_a?(String)
+        obj.respond_to?(:each)
+      end
+
+      def self.collection_like?(obj)
+        looks_like_collection?(obj) || obj.is_a?(Array)
+      end
+
+      def self.active_record_collection?(obj)
+        (obj.is_a?(ActiveRecord::Relation) ||
+          obj.is_a?(ActiveRecord::Associations::CollectionProxy)) rescue false
+      end
 
+      def self.validate_attribute!(record, attr)
+        unless attr.is_a?(Symbol) || attr.is_a?(String)
+          raise ArgumentError, "Attribute must be Symbol or String, got #{attr.inspect}"
+        end
+        unless record.respond_to?(attr)
+          raise "[svelte-on-rails:to_svelte] No method #{attr.inspect} on #{record.class}"
+        end
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: svelte-on-rails
 version: !ruby/object:Gem::Version
-  version: 9.3.3
+  version: 9.3.4
 platform: ruby
 authors:
 - Christian Sedlmair