svelte-on-rails 5.3.2 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66ba05e463ee27dcf6234fd49f46f1879daecd331f52549080d1d9f2f9e0748d
-  data.tar.gz: 1947be68d44b723ed074098728db6a0aaba6e5c5bbbb72dc09604b5fc4dc93f3
+  metadata.gz: 72ff2251a05680fdb51fa556c72aaba218728a0040265412544d838ef7a4b4e7
+  data.tar.gz: 394c75169ba815b224e74f5b4c3e2675f50845505f4e00c52bdecf363b9db4ba
 SHA512:
-  metadata.gz: 3c4a60a0c0f2d372535af2a7972c4df70ecb2958e0f0f2e9c718f6aeeccbab8f2797c329ec8ea789e5aa9d9e5154bc5b5cc88f70d0a5211416aa1d5d0296d8ad
-  data.tar.gz: afa1cef4cef2787e3da4d0a040b6261f1313b503ae149238faa74f779c46a5d78a569a4ac98c84d0e76276c514d8940f9dd6b6086a58c9c7e54490a2671d18a1
+  metadata.gz: cfbbe11843b3b00a104bba37d942c98f5e49aca735f0b933475a3ee77b495418758eb83638b073dd7ed5e866a32bacc4c434e6daaa33e7b98303aa8731093bfe
+  data.tar.gz: a228c78ccf69847ff2f61d360734af6d1e7cb912b3928d6af056585fa1cabc0d121405c5d7b9099b659d15143a1771937e6d3745aa80bfd8a39d73e0fea66b0a

data/README.md

@@ -302,13 +302,18 @@ But, in normal cases it should not be neccessary testing ssr explicitly.
 
 ## ActiveRecord helpers
 
-Adds the `#svelte_attributes` helper to your models, example: 
+Adds the `#to_svelte` helper to your models, example: 
 
 ```ruby
-@book.svelte_attributes(
+@book.to_svelte(
   :name,
   :calculation_method,
-  author: [:name]
+  author: [:name],
+  editions: [
+    :date, 
+    offset: 2, 
+    limit: 1
+  ]
 )
 ```
 
@@ -322,6 +327,11 @@ would result in something like this:
     "author" => {
       "name" => "Michael Hartl"
     },
+    "editions" => [
+      {
+        date: "2025-02-03"
+      }
+    ]
   },
   "book_labels" => {
     "name" => "Name", # translated by human_attribute_name..
@@ -330,15 +340,35 @@ would result in something like this:
   },
   "author_labels": {
     "name" => "Name" 
+  },
+  "edition_labels" => {
+    "date" => "Date"
   }
 }
 ```
 
 This should ease transferring data you need within the component mostly.
 
-If an optional `belongs_to` association is empty, the labels are still calculated.
+The same method is applicable for:
+
+- The model itself
+  - It returns only the labels: Same result like above, but without the `values` key
+- `ActiveRecord::Relation`
+  - Same result like above, but `values` then is a Array.
+
+If a association returns a empty result, the labels are still calculated.
+
+`offset` and `limit` are reserved keys, so, columns with the same name would be ignored.
+
+**Caching:** 
+
+Caching Capability is not implemented on this method, you easily can wrap it by `Redis`
 
-**Caching:** The component's attributes are used to generate a checksum, which serves as the cache key for efficient storage and retrieval.
+If used on the `cached_svelte_component` view helper, 
+the component's attributes are used to generate a checksum, which serves as the 
+cache key for efficient storage and retrieval. So, this method is meant to 
+make it easier to exactly filter out only the information that is needed
+on the component.
 
 ## Caching
 

data/lib/svelte-on-rails.rb

@@ -10,6 +10,7 @@ require "svelte_on_rails/renderer/renderer"
 
 require "svelte_on_rails/lib/utils"
 require "svelte_on_rails/lib/view_helper_support"
+require "svelte_on_rails/lib/to_svelte"
 
 # installer
 require 'svelte_on_rails/installer/utils'

data/lib/svelte_on_rails/active_record_extensions.rb

@@ -1,41 +1,40 @@
 # lib/svelte_on_rails/active_record_extensions.rb
 module SvelteOnRails
   module ActiveRecordExtensions
-    def self.included(base)
-      unless defined?(ActiveRecord::Base) && base.ancestors.include?(ActiveRecord::Base)
-        raise 'SvelteOnRails::ActiveRecordExtensions can only be included in ActiveRecord models'
-      end
-    end
+    # def self.included(base)
+    #   unless defined?(ActiveRecord::Base) && base.ancestors.include?(ActiveRecord::Base)
+    #     raise 'SvelteOnRails::ActiveRecordExtensions can only be included in ActiveRecord models'
+    #   end
+    # end
 
     # Returns a hash of attributes, methods, and associations formatted for Svelte components
-    def svelte_attributes(*attributes)
-      @svelte_attributes ||= begin
+    def to_svelte(*attributes)
+      @to_svelte ||= begin
 
-                               # separate offset and limit
+                               cl = SvelteOnRails::Lib::SvelteAttributes
+                               cl.new.calculate_instance(self, attributes)
 
-                               h = attributes.grep(Hash)
-                               attr = if h.present?
-                                        opts = h.first.symbolize_keys
-                                        offset = opts[:offset]
-                                        limit = opts[:limit]
-                                        if offset || limit
-                                          unless self.respond_to?(:each)
-                                            raise 'offset and limit are only supported for record sets that respond to :each'
-                                          end
-                                          _opts = opts.reject { |key, _| [:offset, :limit].include?(key) }
-                                          attributes.select { |item| !item.is_a?(Hash) }.push(_opts)
-                                        else
-                                          attributes
-                                        end
-                                      else
-                                        attributes
-                                      end
+                             end
+    end
 
-                               utils = SvelteOnRails::Lib::Utils
-                               utils.svelte_attributes(self, attr, offset: offset, limit: limit)
+  end
 
+  module ActiveRecordClassExtensions
+    def to_svelte(*attributes)
+      @to_svelte ||= begin
+                               cl = SvelteOnRails::Lib::SvelteAttributes
+                               cl.new.calculate_class(self, attributes)
                              end
     end
+  end
 
+  module ActiveRecordRelationExtensions
+    def to_svelte(*attributes)
+      @to_svelte ||= begin
+                               cl = SvelteOnRails::Lib::SvelteAttributes
+                               cl.new.calculate_relation(self, attributes)
+                             end
+    end
   end
+
 end

data/lib/svelte_on_rails/lib/to_svelte.rb

@@ -0,0 +1,190 @@
+module SvelteOnRails
+  module Lib
+    class SvelteAttributes
+
+      def initialize
+        @labels = {}
+      end
+
+      def calculate_instance(record, attributes, call_stack: 0, offset: nil, limit: nil)
+
+        next_stack = call_stack + 1
+
+        if record.respond_to?(:each)
+
+          recs2 = if offset || limit
+                    if (record.is_a?(ActiveRecord::Relation) || record.is_a?(ActiveRecord::Associations::CollectionProxy) rescue false)
+                      _recs = (offset ? record.offset(offset) : record)
+                      (limit ? _recs.limit(limit) : _recs)
+                    elsif record.respond_to?(:drop) && record.respond_to?(:take) # that might be a array
+                      _recs = offset ? record.drop(offset) : record
+                      limit ? _recs.take(limit) : _recs
+                    else
+                      raise "[svelte-on-rails:to_svelte] unknown class for records: #{record}"
+                    end
+                  else
+                    record
+                  end
+
+          set_labels(record.first, attributes)
+
+          values = recs2.map do |rec|
+            calculate_instance(rec, attributes, call_stack: next_stack)
+          end
+
+        else
+
+          # we have a single record
+
+          values = {}
+
+          set_labels(record, attributes)
+
+          attributes.each do |attr|
+
+            if attr.is_a? Hash
+
+              # we have associations
+              attr.each do |key, value|
+                next if ['offset', 'limit'].include?(key.to_s)
+                _offset, _limit, _value = extract_limit(value)
+
+                _key = key.to_s
+
+                # inspect association and set_labels
+
+                reflect = record.class.reflect_on_association(_key)
+                raise "invalid association: #{_key}" unless reflect
+                set_labels(reflect, value)
+
+                # values
+
+                recs = record.send(_key)
+                if recs.present?
+                  if recs.respond_to?(:each)
+                    values[_key] = calculate_instance(
+                      recs,
+                      value,
+                      call_stack: next_stack,
+                      offset: _offset,
+                      limit: _limit
+                    )
+                  else
+                    values[_key] = calculate_instance(
+                      recs,
+                      value,
+                      call_stack: next_stack
+                    )
+                  end
+                end
+              end
+
+            else
+              # we have attributes
+              raise 'Invalid attribute' unless [Symbol, String].include?(attr.class)
+              _key = attr.to_s
+
+              values[_key] = record.send(_key)
+            end
+
+          end
+        end
+
+        if call_stack >= 1
+          values
+        else
+          { 'values' => values }.merge(@labels)
+        end
+
+      end
+
+      def calculate_class(model, attributes, call_stack: 0)
+
+        next_stack = call_stack + 1
+
+        set_labels(model, attributes)
+
+        hash = attributes.find { |element| element.is_a?(Hash) } || {}
+        hash.each do |key, value|
+          reflect = model.reflect_on_association(key.to_s)
+          if reflect
+            calculate_class(
+              reflect,
+              value,
+              call_stack: next_stack
+            )
+          end
+        end
+
+        if call_stack == 0
+          @labels
+        end
+      end
+
+      def calculate_relation(relation, attributes, call_stack: 0)
+        set_labels(relation.klass, attributes)
+        values = relation.map do |rec|
+          calculate_instance(rec, attributes)['values']
+        end
+        {
+          'values' => values
+        }.merge(@labels)
+      end
+
+      private
+
+      def extract_limit(attributes)
+
+        _hash_args = attributes.grep(Hash).first.dup
+        attr, lim = if _hash_args.present?
+                      hash_args = _hash_args.transform_keys { |key| key.to_s } # multiple arrays is not possible
+                      hash_remainder = hash_args.reject { |key, _| %w[offset limit].include?(key.to_s) }
+                      _attr = attributes.reject { |item| item.is_a?(Hash) }
+                      [
+                        if hash_remainder.any?
+                          _attr + [hash_remainder]
+                        else
+                          _attr
+                        end,
+                        hash_args
+                      ]
+                    else
+                      [
+                        attributes,
+                        {}
+                      ]
+                    end
+
+        [
+          lim['offset'],
+          lim['limit'],
+          attr
+        ]
+      end
+
+      def set_labels(record, keys)
+
+        first_hash = keys.find { |element| element.is_a?(Hash) }
+        _keys = keys.reject { |element| element.is_a?(Hash) }
+        _keys += first_hash.keys if first_hash
+
+        _keys.each do |attr|
+          unless attr.respond_to?(:each)
+            obj = if record.respond_to?(:human_attribute_name)
+                    record
+                  elsif record.class.respond_to?(:human_attribute_name)
+                    record.class
+                  end
+
+            next unless obj
+
+            @labels["#{obj.to_s.underscore}_labels"] ||= {}
+            @labels["#{obj.to_s.underscore}_labels"][attr.to_s] ||= obj.human_attribute_name(attr)
+
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/svelte_on_rails/lib/utils.rb

@@ -163,132 +163,6 @@ module SvelteOnRails
         end
       end
 
-      def self.svelte_attributes(record, attributes, labels: {}, call_stack: 0, offset: nil, limit: nil)
-
-        if record.is_a?(Class)
-
-          # this is the case if a belongs_to association is empty; In that case we pass the class itself and extract only the labels
-          raise 'limit and offset are supported only for iterable objects' if limit || offset
-          attributes.each do |attr|
-            unless attr.respond_to?(:each)
-              labels["#{record.to_s.underscore}_labels"] ||= {}
-              labels["#{record.to_s.underscore}_labels"][attr.to_s] ||= record.human_attribute_name(attr)
-            end
-          end
-          values = {}
-
-        elsif record.respond_to?(:each)
-
-          unless record.is_a?(ActiveRecord::Relation) || record.is_a?(ActiveRecord::Associations::CollectionProxy)
-            raise 'record set must be a Article::ActiveRecord_Associations_CollectionProxy'
-          end
-
-          recs = (offset ? record.offset(offset) : record)
-          recs2 = (limit ? recs.limit(limit) : recs)
-
-          values = recs2.map do |rec|
-            svelte_attributes(rec, attributes, labels: labels, call_stack: call_stack + 1)
-          end
-
-        else
-
-          # we have a single record
-
-          raise 'limit and offset are supported only for iterable objects' if limit || offset
-          values = {}
-
-          table_name = record.class.to_s.underscore
-
-          attributes.each do |attr|
-
-            if attr.is_a? Hash
-
-              # we have associations
-              attr.each do |key, value|
-                _key = key.to_s
-
-                # skip and fetch offset and limit
-                if key.to_s.match(/_limit$/) && !record.respond_to?(key)
-                  raise 'Invalid attribute' unless record.respond_to?(key.to_s[0..-7])
-                  next
-                end
-                if key.to_s.match(/_offset$/) && !record.respond_to?(key)
-                  raise 'Invalid attribute' unless record.respond_to?(key.to_s[0..-8])
-                  next
-                end
-                offs, lim = svelte_attribute_extract_limit(record, attributes, _key)
-
-                labels["#{table_name}_labels"] ||= {}
-                labels["#{table_name}_labels"][_key] ||= record.class.human_attribute_name(_key)
-
-                # values
-
-                reflect = record.class.reflect_on_association(_key)
-                if reflect
-                  recs = record.send(_key)
-                  content = (recs.present? ? recs : reflect.active_record) # if no record, we extract only the labels
-                  if content.respond_to?(:each)
-                    values[_key] = svelte_attributes(
-                      content,
-                      value,
-                      labels: labels,
-                      call_stack: call_stack + 1,
-                      offset: offs,
-                      limit: lim
-                    )
-                  else
-                    values[_key] = svelte_attributes(
-                      content,
-                      value,
-                      labels: labels,
-                      call_stack: call_stack + 1,
-                      offset: offs,
-                      limit: lim
-                    )
-                  end
-                else
-                  raise "invalid association: #{_key}"
-                end
-              end
-
-            else
-              # we have attributes
-              raise 'Invalid attribute' unless [Symbol, String].include?(attr.class)
-              _key = attr.to_s
-
-              labels["#{table_name}_labels"] ||= {}
-              labels["#{table_name}_labels"][_key] ||= record.class.human_attribute_name(_key)
-
-              values[_key] = record.send(_key)
-            end
-
-          end
-        end
-
-        if call_stack >= 1
-          values
-        else
-          { 'values' => values }.merge(labels)
-        end
-
-      end
-
-      private
-
-      def self.svelte_attribute_extract_limit(record, attributes, key)
-
-        hash_args = attributes.grep(Hash).first.with_indifferent_access # multiple arrays is not possible
-
-        offset = if hash_args["#{key}_offset"] && !record.respond_to?("#{key}_offset")
-                   hash_args["#{key}_offset"]
-                 end
-
-        limit = if hash_args["#{key}_limit"] && !record.respond_to?("#{key}_limit")
-                  hash_args["#{key}_limit"]
-                end
-
-        [offset, limit]
-      end
     end
   end
 end

data/lib/svelte_on_rails/railtie.rb

@@ -15,10 +15,18 @@ module SvelteOnRails
 
     initializer 'svelte_on_rails.active_record_extensions' do
       ActiveSupport.on_load(:active_record) do
+        # Include instance-level extensions
         include SvelteOnRails::ActiveRecordExtensions
+        # Extend with class-level extensions
+        extend SvelteOnRails::ActiveRecordClassExtensions
       end
     end
 
+    # Extend ActiveRecord::Relation
+    ActiveSupport.on_load(:active_record_relation) do
+      include SvelteOnRails::ActiveRecordRelationExtensions
+    end
+
     rake_tasks do
       load File.expand_path("../../tasks/svelte_on_rails_tasks.rake", __FILE__)
     end

data/templates/all_features_test/app/controllers/svelte_on_rails_hello_world_controller.rb

@@ -5,10 +5,6 @@ class SvelteOnRailsHelloWorldController < ApplicationController
 
   def web_socket_action
 
-    # render plain: Article.first.svelte_attributes(:name) #(:name, :calc_method, children: [:name], children_limit: 2, parent: [:name]).to_json
-    #
-    # return
-
     comp = 'ReceiveFromChannel'
 
     case params['stream']

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: svelte-on-rails
 version: !ruby/object:Gem::Version
-  version: 5.3.2
+  version: 6.0.0
 platform: ruby
 authors:
 - Christian Sedlmair
@@ -43,6 +43,7 @@ files:
 - lib/svelte_on_rails/installer/utils.rb
 - lib/svelte_on_rails/installer/vite.rb
 - lib/svelte_on_rails/lib/development_utils.rb
+- lib/svelte_on_rails/lib/to_svelte.rb
 - lib/svelte_on_rails/lib/utils.rb
 - lib/svelte_on_rails/lib/view_helper_support.rb
 - lib/svelte_on_rails/railtie.rb