svelte-on-rails 5.3.1 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b172f3a295136f0317cc6fabb713262b1d1ac813894ef7e07f9b48da61f01a0
-  data.tar.gz: 477f5ce8a86e4d0e7bbf508be99486a9763454ee027b43240cb3432cf5250c37
+  metadata.gz: 72ff2251a05680fdb51fa556c72aaba218728a0040265412544d838ef7a4b4e7
+  data.tar.gz: 394c75169ba815b224e74f5b4c3e2675f50845505f4e00c52bdecf363b9db4ba
 SHA512:
-  metadata.gz: 2f2595ac48833224788450ce49f31d775ffcd552dd628b630caa450045b02a38c725c81fadeaf4833b6eb8134d32b28c7c1b69fd387b639d0c9c655a22549a08
-  data.tar.gz: fd6aecc7d1923717b5e0119b337d221d6cf0e5c1e4a6b95f5a2a58911787b0e5a4587022850ea546a2c9e385e7d19a8fd96856ecbb07f010830bbe0d5319641b
+  metadata.gz: cfbbe11843b3b00a104bba37d942c98f5e49aca735f0b933475a3ee77b495418758eb83638b073dd7ed5e866a32bacc4c434e6daaa33e7b98303aa8731093bfe
+  data.tar.gz: a228c78ccf69847ff2f61d360734af6d1e7cb912b3928d6af056585fa1cabc0d121405c5d7b9099b659d15143a1771937e6d3745aa80bfd8a39d73e0fea66b0a

data/README.md

@@ -5,20 +5,11 @@
 
 ---
 
-**Svelte on Rails: Modern Front-End + Rails Simplicity**
-
-Guided by our Principles:
-
-- **Minimal JavaScript but Reactive Power**
-- **Beautiful Code, More Joy, Better Results**
-- **Convention over Configuration**
-
-`svelte-on-rails` completes [DHH's vision](https://rubyonrails.org/2021/12/15/Rails-7-fulfilling-a-vision) 
-for modern front-end demands.
+Realizing [DHH's vision](https://rubyonrails.org/2021/12/15/Rails-7-fulfilling-a-vision) with modern front-end technologies.
 
 # Why Integrate Svelte?
 
-Svelte offers the simplest and most elegant approach to building reactive, high-performance front-end components.
+Svelte offers the simplest and most elegant soulution to building reactive, high-performance front-end components.
 
 - **Seamless Integration**
   - Works flawlessly with Hotwired/Turbo
@@ -311,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
+  ]
 )
 ```
 
@@ -331,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..
@@ -339,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.
 
-**Caching:** The component's attributes are used to generate a checksum, which serves as the cache key for efficient storage and retrieval.
+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`
+
+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
 
@@ -388,39 +409,19 @@ on the svelte-on-rails config file or pass the `expires_in` as argument to the v
 
 Pass `debug: true` to the helper and you will see on the logs how your configuration works.
 
-## ActionCable / TurboStream
+## ActionCable vs. TurboStream
 
 There are two ways that the server can talk to the client over Websocket:
 
-- ActionCable transmits directly to the frontends javascript
-- TurboStreams is a wrapper around ActionCable
-  - You always need a html part for communication
-
-**Configs**
-
-Check the regarding keys and their commends on the [config file](https://gitlab.com/sedl/svelte-on-rails/-/blob/main/templates/config_base/config/svelte_on_rails.yml?ref_type=heads).
-From there, you just need:
-
-```yaml
-turbo_stream:
-  target_html_id: 'svelte-on-rails-stream-actions-box'
-  channel: 'public'
-```
-
-## ActionCable vs TurboStream
-
-- **ActionCable**
-  - Cleaner setup no html needed
-  - Seams to initialize securer, especially for testings (not: production)
-- **TurboStream**
-  - Secured Streams by html-tag `signed-stream-name` if you want to send confidential data 
-    over streams or have different channels for each user privileges
-  - Has [Compatibility issue with UJS](https://github.com/hotwired/turbo-rails?tab=readme-ov-file#compatibility-with-rails-ujs)
+- **ActionCable** transmits directly to the frontends javascript
+- **TurboStreams** is a wrapper around ActionCable
+  - You always need a html part for communication by secured channels
+  - Makes sense when you want to transfer confidential data or separate onto privileged user channels
+  - Has [compatibility issues with Rails-UJS](https://github.com/hotwired/turbo-rails?tab=readme-ov-file#compatibility-with-rails-ujs)
 
+    
 ## SvelteOnRails::ActionCable
 
-ActionCable is the more basic library behind `TurboStream` and it is a second Option to call Javascript Actions from the server.
-
 **Setup**
 
 Add `app/channels/svelte_on_rails_channel.rb`
@@ -437,7 +438,14 @@ class SvelteOnRailsChannel < ApplicationCable::Channel
 end
 ```
 
-run
+config
+
+```yaml
+action_cable:
+  channel: "svelte_on_rails_channel"
+```
+
+javascript
 
 ```shell
 npm i @rails/actioncable
@@ -510,11 +518,6 @@ on the whole `document` and fires the given event there.
 
 # SvelteOnRails::TurboStream
 
-Turbo Stream makes more sense when you think of sending confidential data to the components
-or you want to separate to channels based on user groups, for example.
-
-Few setup is needed for that:
-
 **Setup**
 
 Please setup the `turbo-rails` gem and follow the chapter [Come alive with Turbo Streams](https://github.com/hotwired/turbo-rails?tab=readme-ov-file#come-alive-with-turbo-streams), which mainly is:
@@ -541,6 +544,17 @@ you can test it by:
 
 When this works you are good to go.
 
+**Configs**
+
+Check the regarding keys and their commends on the [config file](https://gitlab.com/sedl/svelte-on-rails/-/blob/main/templates/config_base/config/svelte_on_rails.yml?ref_type=heads).
+From there, you just need:
+
+```yaml
+turbo_stream:
+  target_html_id: 'svelte-on-rails-stream-actions-box'
+  channel: 'public'
+```
+
 **Minimal Usage Example**
 
 And call this by:

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/action_cable.rb

@@ -40,7 +40,7 @@ module SvelteOnRails
 
       args = {
         eventDetail: event_detail,
-        component: '/false/',
+        component: ':false:',
         event: event,
         selector: selector
       }

data/lib/svelte_on_rails/active_record_extensions.rb

@@ -1,36 +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)
 
-                               opts = attributes.grep(Hash).first.symbolize_keys
-                               offset = opts[:offset]
-                               limit = opts[:limit]
-                               attr = 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
+                             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/lib/view_helper_support.rb

@@ -79,7 +79,13 @@ module SvelteOnRails
 
       def render_ssr
         renderer = SvelteOnRails::Renderer.new(filename)
-        renderer.render(@svelte_props)
+        res = renderer.render(@svelte_props)
+        if res['html'].is_a?(Array)
+          res['html'] = res['html'].join
+          res
+        else
+          res
+        end
       end
 
       def custom_cache_key

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/lib/svelte_on_rails/renderer/render.js

@@ -14,13 +14,13 @@ import {loadComponentModule, readPropsFromStdin} from './utils.js';
 
     try {
         MyComponent(payload, props); // Writes directly to payload.out
-        console.log(`[svelte-on-rails:debug] written to payload`)
+        console.log(`[svelte-on-rails:debug] written to payload (typeof payload.out => «${typeof payload.out}»)`)
     } catch (error) {
         console.error('[svelte-on-rails:debug] Error rendering component:', error);
         process.exit(1);
     }
 
-    const res = {status: 'SUCCESS', html: payload.out.join('')};
+    const res = {status: 'SUCCESS', html: payload.out};
     console.log('[svelte-on-rails:successful-json-response]' + JSON.stringify(res));
 })();
 

data/lib/svelte_on_rails/turbo_stream.rb

@@ -40,7 +40,7 @@ module SvelteOnRails
 
       args = {
         eventDetail: event_detail,
-        component: '/false/',
+        component: ':false:',
         event: event,
         selector: selector
       }

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']

data/templates/all_features_test/app/frontend/initializers/actionCable.js

@@ -1,5 +1,6 @@
 import { createConsumer } from "@rails/actioncable"
-import {dispatchSvelteStreamEvent, actionCableDebugLog} from '@csedl/svelte-on-rails'
+import { SvelteOnRails, dispatchSvelteStreamEvent, actionCableDebugLog } from '@csedl/svelte-on-rails'
+SvelteOnRails.debug = true
 
 const consumer = createConsumer()
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: svelte-on-rails
 version: !ruby/object:Gem::Version
-  version: 5.3.1
+  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