svelte-on-rails 9.3.1 → 9.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 909e9c6262ad80cd433ad7f53708ecd4c0df12d9949100b25d75c865f51ef149
-  data.tar.gz: ff488ba08eb9f180f969c4c518d9aaba264036a44e0ce925151e1a3a626e2db7
+  metadata.gz: 2c00a2d1fbef66d704980e82ff2c014b10d51c7fd96ce6e1eebf9507cd482404
+  data.tar.gz: a32be8b0ada337147e45b95aa8385969616473371c11ab1f77d2d7f9f055d71f
 SHA512:
-  metadata.gz: 5f47db6b96f95efe3d75a3bb342ccbf02614ddacba3d8e70dfbe6e51a72415eb24719202c8fdd6531b3de51ef63b7e8d7b49d66e07e570999e7582b5d1a2150b
-  data.tar.gz: f5181e016d6aaf07ad97dd18765210024914e47493e897ee67171f2aa456bb7d254c278f545cdf7d997670e4d7c9e120ff8001dac26375386878cb42b7406196
+  metadata.gz: 6c4ea68fcce1fbe65fff3f0e48c23f5124974a91640fdbe9236fafc251762b630e156fdc2da334a973103e312d4d5482489b3ab703f9c02bec4e84181d6ce31f
+  data.tar.gz: ee14779e2dd1ffd64f1cb5770e4c7d6137243734a435c262006d928a762d5968ed2f47efe7d64b15899e15ea21760812acdc9843d74b4f6e0bab0379d973318c

data/lib/svelte-on-rails.rb

@@ -10,7 +10,9 @@ 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"
+require "svelte_on_rails/lib/to_svelte_labels"
+require "svelte_on_rails/lib/to_svelte_values"
+require "svelte_on_rails/lib/to_svelte_support"
 
 # installer
 require 'svelte_on_rails/installer/utils'

data/lib/svelte_on_rails/active_record_extensions.rb

@@ -8,12 +8,12 @@ module SvelteOnRails
     def to_svelte(*attributes, **associations)
       @to_svelte ||= begin
 
-                       cl = SvelteOnRails::Lib::SvelteAttributes
-                       lab, enums, val = cl.new.calculate_instance(self, attributes, associations)
-                       k = self.class.to_s.underscore
-                       res = lab
-                       res["#{k}_enums"] = enums if enums
-                       res[k] = val
+                       tsv = SvelteOnRails::Lib::ToSvelteValues.new
+                       tsl = SvelteOnRails::Lib::ToSvelteLabels.new
+                       res = tsl.extract_labels(self.class, attributes, associations)
+
+                       val = tsv.extract_values(self, attributes, associations)
+                       res[self.class.to_s.underscore] = val
                        res
 
                      end
@@ -28,11 +28,8 @@ module SvelteOnRails
     def to_svelte(*attributes, **associations)
 
       @to_svelte ||= begin
-                       cl = SvelteOnRails::Lib::SvelteAttributes
-                       lab, enums = cl.new.calculate_class(self, attributes, associations)
-                       lab["#{self.to_s.underscore}_enums"] = enums if enums
-                       lab
-
+                       cl = SvelteOnRails::Lib::ToSvelteLabels.new
+                       cl.extract_labels(self, attributes, associations)
                      end
     end
 
@@ -44,12 +41,15 @@ module SvelteOnRails
 
     def to_svelte(*attributes, **associations)
       @to_svelte ||= begin
-                       cl = SvelteOnRails::Lib::SvelteAttributes
-                       lab, enums, val = cl.new.calculate_relation(self, attributes, associations)
+                       cl = SvelteOnRails::Lib::ToSvelteValues
+                       val = cl.new.extract_values(self, attributes, associations)
+
+                       tsl = SvelteOnRails::Lib::ToSvelteLabels.new
+                       res = tsl.extract_labels(self.klass, attributes, associations)
+
                        k = self.klass.to_s.underscore
-                       lab[k.pluralize] = val
-                       lab["#{k}_enums"] = enums if enums
-                       lab
+                       res[k.pluralize] = val
+                       res
                      end
     end
 

data/lib/svelte_on_rails/configuration.rb

@@ -9,8 +9,23 @@ module SvelteOnRails
 
     attr_accessor :configs
 
+    def labels_cache(model, attributes, associations, value = nil)
+      attr_str = attributes.to_s + associations.to_s
+      attr_key = Zlib.crc32(attr_str, 0).to_s(36)
+
+      if value
+        @labels_cache ||= {}
+        @labels_cache[I18n.locale] ||= {}
+        @labels_cache[I18n.locale][model.to_s] ||= {}
+        @labels_cache[I18n.locale][model.to_s][attr_key] = value
+      elsif @labels_cache
+        @labels_cache.dig(I18n.locale, model.to_s, attr_key)
+      end
+    end
+
     def initialize
 
+      @boot_key = SecureRandom.hex(3) # currently not used, more for debugging purposes
       @configs = redis_cache_store_configs
 
       return unless defined?(Rails.root)

data/lib/svelte_on_rails/lib/to_svelte_labels.rb

@@ -0,0 +1,77 @@
+module SvelteOnRails
+  module Lib
+    class ToSvelteLabels
+
+      def initialize
+        @labels = {}
+        @enums = {}
+      end
+
+      def extract_labels(model, attributes, associations)
+
+        config = SvelteOnRails::Configuration.instance
+
+        if !config.watch_changes?
+          cached = config.labels_cache(model, attributes, associations)
+          if cached
+            return cached
+          else
+            extract_labels_recursive(model, attributes, associations)
+            r = config.labels_cache(model, attributes, associations, @labels.merge!(@enums))
+            return r
+          end
+        else
+          extract_labels_recursive(model, attributes, associations)
+          @labels.merge!(@enums)
+        end
+      end
+
+      private
+
+      def extract_labels_recursive(model, attributes, associations)
+
+        attributes.each do |attr|
+
+          if attr.is_a?(Hash)
+            associations.merge!(attr)
+          else
+
+            enums = model.defined_enums
+            model_un = model.to_s.underscore
+            attr_s = attr.to_s
+
+            if !model.method_defined?(attr) && !model.attribute_names.include?(attr.to_s)
+              raise "ERROR: Attribute or method «#{attr}» not found in model «#{model}»"
+            end
+            @labels["#{model_un}_labels"] ||= {}
+            @labels["#{model_un}_labels"][attr.to_s] ||= model.human_attribute_name(attr)
+            @labels["#{model_un}_labels"]['model_name'] ||= model.model_name.human
+            @labels["#{model_un}_labels"]['model_name_plural'] ||= model.model_name.human(count: :many)
+
+            if enums.key?(attr_s)
+              @enums["#{model_un}_enums"] ||= {}
+              en = enums[attr_s].each_with_object({}) do |(k, _), h|
+                h[k] = I18n.t("enums.#{model_un}.#{attr_s}.#{k}")
+              end
+              @enums["#{model_un}_enums"][attr_s] = en
+            end
+
+          end
+        end
+
+        associations.each do |k, attrs|
+
+          _attrs, _assoc = SvelteOnRails::Lib::ToSvelteSupport.separate_associations(attrs)
+
+          cl = model.reflect_on_association(k)
+          raise "ERROR: Association «#{k}» not found in model «#{model}»" unless cl
+          @labels["#{model.to_s.underscore}_labels"] ||= {}
+          @labels["#{model.to_s.underscore}_labels"][k.to_s] ||= model.human_attribute_name(k)
+          extract_labels_recursive(cl.klass, _attrs, _assoc)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/svelte_on_rails/lib/to_svelte_support.rb

@@ -0,0 +1,25 @@
+module SvelteOnRails
+  module Lib
+    class ToSvelteSupport
+      def self.separate_associations(array)
+
+        attrs = []
+        assoc = {}
+
+        array.each do |item|
+          if item.is_a?(Hash)
+            assoc.merge!(item)
+          else
+            attrs.push(item)
+          end
+        end
+
+        [
+          attrs,
+          assoc
+        ]
+
+      end
+    end
+  end
+end

data/lib/svelte_on_rails/lib/to_svelte_values.rb

@@ -0,0 +1,75 @@
+module SvelteOnRails
+  module Lib
+    class ToSvelteValues
+      def extract_values(record, attributes, associations, call_stack: 0)
+
+        next_stack = call_stack + 1
+
+        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)
+          end
+
+        else
+
+          # we have a single record
+
+          values = {}
+          enums = record.class.defined_enums
+
+          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
+
+            if enums.key?(key_s)
+              values[key_s] = record.send(key_s)
+            else
+              values[key_s] = record.send(key_s)
+            end
+
+          end
+
+          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
+
+          end
+        end
+
+        values
+
+      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.1
+  version: 9.3.2
 platform: ruby
 authors:
 - Christian Sedlmair
@@ -58,7 +58,9 @@ files:
 - lib/svelte_on_rails/installer/svelte.rb
 - lib/svelte_on_rails/installer/utils.rb
 - lib/svelte_on_rails/lib/development_utils.rb
-- lib/svelte_on_rails/lib/to_svelte.rb
+- lib/svelte_on_rails/lib/to_svelte_labels.rb
+- lib/svelte_on_rails/lib/to_svelte_support.rb
+- lib/svelte_on_rails/lib/to_svelte_values.rb
 - lib/svelte_on_rails/lib/utils.rb
 - lib/svelte_on_rails/lib/view_helper_support.rb
 - lib/svelte_on_rails/railtie.rb

data/lib/svelte_on_rails/lib/to_svelte.rb

@@ -1,225 +0,0 @@
-module SvelteOnRails
-  module Lib
-    class SvelteAttributes
-
-      def initialize
-        @labels = {}
-      end
-
-      def calculate_instance(record, attributes, associations, 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
-
-          values = recs2.map do |rec|
-            calculate_instance(rec, attributes, associations, call_stack: next_stack)
-          end
-
-        else
-
-          # we have a single record
-
-          values = {}
-
-          set_labels(record, attributes, associations)
-
-          attributes.each do |attr|
-            raise 'Invalid attribute' 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 = attr.to_s
-
-            values[_key] = record.send(_key)
-
-            fetch_enum(record.class, attr)
-          end
-
-          associations.each do |key, val|
-
-            # we have associations
-            val.each do |_key|
-              next if ['offset', 'limit'].include?(_key.to_s)
-              raise "[svelte-on-rails:to_svelte] #{record.class} does not respond to: #{key}" unless record.respond_to?(key)
-              _offset, _limit, _value = extract_limit(val)
-
-              _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, val)
-
-              # values
-
-              recs = record.send(_key)
-              if recs.present?
-                if recs.respond_to?(:each)
-                  values[_key] = calculate_instance(
-                    recs,
-                    val.reject { |v| v.is_a?(Hash) },
-                    {},
-                    call_stack: next_stack,
-                    offset: _offset,
-                    limit: _limit
-                  )
-                else
-                  values[_key] = calculate_instance(
-                    recs,
-                    val,
-                    {},
-                    call_stack: next_stack
-                  )
-                end
-              end
-            end
-          end
-        end
-
-        if call_stack >= 1
-          values
-        else
-          [
-            @labels,
-            @enums,
-            values
-          ]
-        end
-
-      end
-
-      def calculate_class(model, attributes, associations, call_stack: 0)
-
-        next_stack = call_stack + 1
-
-        set_labels(model, attributes, associations)
-        attributes.each do |attr|
-          fetch_enum(model, attr)
-        end
-
-        associations.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,
-            @enums
-          ]
-        end
-
-      end
-
-      def calculate_relation(relation, attributes, associations)
-        set_labels(relation.klass, attributes)
-        attributes.each do |attr|
-          fetch_enum(relation.klass, attr)
-        end
-        r = relation.map do |rec|
-          calculate_instance(rec, attributes, associations, call_stack: 1)
-        end
-
-        [
-          @labels,
-          @enums,
-          r
-        ]
-
-      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, assoc = {})
-
-        _keys = keys.reject { |element| element.is_a?(Hash) } + assoc.keys
-
-        _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)
-            @labels["#{obj.to_s.underscore}_labels"]['model_name'] ||= obj.model_name.human
-            @labels["#{obj.to_s.underscore}_labels"]['model_name_plural'] ||= obj.model_name.human(count: :many)
-
-          end
-        end
-      end
-
-      def fetch_enum(model, attribute)
-        return unless model.respond_to?(:defined_enums)
-        raise ArgumentError, "attribute_name must be a symbol" unless attribute.is_a?(Symbol)
-
-        enums = model.defined_enums
-        return nil unless enums.key?(attribute.to_s)
-
-        @enums ||= {}
-        @enums[attribute.to_s] = enums[attribute.to_s].map do |k,v|
-          translation_key = "activerecord.attributes.#{model.model_name.i18n_key}.#{attribute}/#{k}"
-          [
-            k,
-            I18n.t(translation_key, default: k.humanize)
-          ]
-        end
-      end
-
-    end
-  end
-end