classy-yaml 1.3.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82933744cd15e116066a4004c44169d70d36b2c6e58b4fbb6654d957ecea0ed4
-  data.tar.gz: 305cfa5b8a5a53bd50d5187fe8b2d13b0ecc52ea295a591dcca694c407567503
+  metadata.gz: 8a6e53b93d281f5b22bc929c6b1df6f389fcd81ed4bc8b9bd3710830a1974ed1
+  data.tar.gz: 0702b4fe219583b61140e89487fb0f42c87b4f6de1c2b5889cbacc7186d546b2
 SHA512:
-  metadata.gz: d9e8f6d551c9b482b0712a8b4b50734ae579f876012dd1414df37f3db8f4ad9e5030a008ebdb1172e560d517f10c8b387237c45739ffc6f68d85c9d1184674eb
-  data.tar.gz: c6347754df73ef47fd53bc7d9ee1650a0aea5b7042d8ae08c3310fc4579281dc3763816cbe1aa4fb612f98d7d7eac165fa5566fd4a75b08f76f4c6b9ea292385
+  metadata.gz: ef1645ba8e34171a8b2a4eb24830789f5d3d412445e2bca83b6e30285a3a20fdd0911ac65388e092cd44197c3e1b9980bc0b565c8d4e623f72671c678ba1935f
+  data.tar.gz: c62c9a28bb4dc589fe04838f5ed33b6fcf27ee2dc68c833161f8e8a57ead9421ef78705c31f8baa546921de1366e247be4f3caf6e9e122720f428940a94e6246

data/README.md

@@ -85,6 +85,23 @@ btn:
 
 # will add the classes "px-3 py-2 text-blue-50"
 ```
+
+yass(:button, :primary) # => "btn btn-primary"
+yass(:button, :secondary) # => "btn btn-secondary"
+yass(:button, :large) # => "btn btn-lg"
+yass(:button, :primary, :large) # => "btn btn-primary btn-lg"
+
+### Array style definition
+
+```
+array:
+  - "px-3 py-2"
+  - "bg-gray"
+  - "text-purple"
+```
+
+yass(:array) # => "px-3 py-2 bg-gray text-purple"
+
 ## Configuration
 You can configure the gem by creating an initializer in your Rails app. The following options are available:
 

data/lib/classy/yaml/helpers.rb

@@ -1,38 +1,69 @@
 module Classy
   module Yaml
     module Helpers
+      # Fetches utility classes from YAML files based on the provided keys.
+      # The method follows a priority order:
+      # 1. Extra files (highest priority)
+      # 2. Default YAML
+      # 3. ViewComponent YAMLs (lowest priority)
+      #
+      # @param args [Array] Array of keys to look up in the YAML files
+      # @return [String] Space-separated list of CSS classes
       def yass(*args)
-        classy_yamls = []
+        # Start with ViewComponent YAMLs (lowest priority)
+        classy_yamls = Classy::Yaml.cached_engine_yamls.dup
 
-        Classy::Yaml.engine_files.each do |file|
-          if File.exist?(file) && YAML.load_file(file)
-            file = YAML.load_file(file)
-            classy_yamls << file if file
-          end
-        end
+        # Add default YAML (next priority)
+        default_yaml = Classy::Yaml.cached_default_yaml
+        classy_yamls << default_yaml if default_yaml
 
-        classy_yamls << YAML.load_file(Rails.root.join(Classy::Yaml.default_file)) if File.exist?(Rails.root.join(Classy::Yaml.default_file))
+        # Add extra files (highest priority)
+        Classy::Yaml.extra_files.each do |file_path|
+          load_yaml_file(file_path, classy_yamls, "extra")
+        end
 
+        # Add classy_files (highest priority)
         classy_files_hash = args.find { |arg| arg.is_a?(Hash) && arg.keys.include?(:classy_files) } || { classy_files: [] }
-
-        (classy_files_hash[:classy_files] + Classy::Yaml.extra_files).each do |file|
-          if File.exist?(file) && YAML.load_file(file)
-            file = YAML.load_file(file)
-            classy_yamls << file if file
-          end
+        classy_files_hash[:classy_files].each do |file_path|
+          load_yaml_file(file_path, classy_yamls, "classy")
         end
 
-        return if classy_yamls.blank?
+        return "" if classy_yamls.blank?
 
         skip_base_hash = args.find { |arg| arg.is_a?(Hash) && arg.keys.include?(:skip_base) } || {}
         keys, classes = flatten_args(values: args)
         classes += fetch_classes(keys, classy_yamls: classy_yamls, skip_base: skip_base_hash[:skip_base])
 
-        return classes.flatten.join(" ")
+        classes.flatten.uniq.join(" ")
       end
 
       private
 
+      # Loads a YAML file and adds its contents to the classy_yamls array
+      # @param file_path [String, Pathname] Path to the YAML file
+      # @param classy_yamls [Array] Array to add the parsed YAML to
+      # @param file_type [String] Type of file being loaded (for error messages)
+      def load_yaml_file(file_path, classy_yamls, file_type)
+        begin
+          path_obj = file_path.is_a?(Pathname) ? file_path : Rails.root.join(file_path)
+          if File.exist?(path_obj)
+            content = File.read(path_obj, encoding: 'UTF-8')
+            parsed_yaml = YAML.safe_load(content, permitted_classes: [Symbol, String, Array, Hash], aliases: true)
+            classy_yamls << parsed_yaml if parsed_yaml && parsed_yaml.is_a?(Hash)
+          end
+        rescue Psych::SyntaxError => e
+          Rails.logger.error "Classy::Yaml (yass helper): Failed to parse #{file_type} YAML file #{file_path}: #{e.message}"
+        rescue => e
+          Rails.logger.error "Classy::Yaml (yass helper): Error loading #{file_type} YAML file #{file_path}: #{e.message}"
+        end
+      end
+
+      # Flattens the arguments into keys and classes
+      # @param root [Array] Current root path in the argument tree
+      # @param values [Array] Values to process
+      # @param keys [Array] Array to store found keys
+      # @param added_classes [Array] Array to store found classes
+      # @return [Array] Tuple of [keys, added_classes]
       def flatten_args(root: [], values: [], keys: [], added_classes: [])
         values.each do |value|
           if value.is_a?(Hash)
@@ -57,6 +88,11 @@ module Classy
         return keys, added_classes
       end
 
+      # Fetches classes from the YAML files based on the provided keys
+      # @param keys [Array] Array of keys to look up
+      # @param classy_yamls [Array] Array of YAML files to search in
+      # @param skip_base [Boolean] Whether to skip base classes
+      # @return [Array] Array of found classes
       def fetch_classes(keys, classy_yamls: [], skip_base: false)
         classes = []
 
@@ -65,36 +101,58 @@ module Classy
           fetched_classes = nil
 
           classy_yamls.reverse_each do |classy_yaml|
+            # Base Class Lookup
             unless skip_base == true
               begin
-                base_classes ||= if classy_yaml.send(:dig, *key).is_a?(Hash)
-                                   classy_yaml.send(:dig, *(key + ['base'])).try(:split, " ")
-                                 else
-                                   classy_yaml.send(:dig, *(key[0...-1] + ['base'])).try(:split, " ")
-                                 end
+                value_at_key = classy_yaml.send(:dig, *key)
+                base_value = if value_at_key.is_a?(Hash)
+                               classy_yaml.send(:dig, *(key + ['base']))
+                             elsif key.length > 1
+                               classy_yaml.send(:dig, *(key[0...-1] + ['base']))
+                             else
+                               nil
+                             end
+                normalized_base = normalize_original(base_value)
+                base_classes ||= normalized_base
               rescue
                 Rails.logger.warn(Classy::Yaml::InvalidKeyError.new(data: key))
               end
             end
 
+            # Specific Key Class Lookup
             begin
-              fetched_classes ||= unless classy_yaml.send(:dig, *key).is_a?(Hash)
-                                    classy_yaml.send(:dig, *key).try(:split, " ")
-                                  end
-
-              base_classes = nil if base_classes.blank?
-              fetched_classes = nil if fetched_classes.blank?
+              value = classy_yaml.send(:dig, *key)
+              unless value.is_a?(Hash)
+                normalized_fetched = normalize_original(value)
+                fetched_classes ||= normalized_fetched
+              end
             rescue
               Rails.logger.warn(Classy::Yaml::InvalidKeyError.new(data: key))
             end
+
+            base_classes = nil if base_classes.blank?
+            fetched_classes = nil if fetched_classes.blank?
           end
 
           classes << base_classes unless base_classes.blank?
           classes << fetched_classes unless fetched_classes.blank?
         end
 
-        classes.reject!(&:blank?)
-        return classes.flatten.uniq
+        classes.flatten.uniq
+      end
+
+      # Normalizes a value into an array of classes
+      # @param value [String, Array, nil] Value to normalize
+      # @return [Array, nil] Array of classes or nil if value is invalid
+      def normalize_original(value)
+        case value
+        when String
+          value.split(" ").reject(&:blank?)
+        when Array
+          value.flatten.map(&:to_s).reject(&:blank?)
+        else
+          nil
+        end
       end
     end
   end

data/lib/classy/yaml/version.rb

@@ -1,5 +1,5 @@
 module Classy
   module Yaml
-    VERSION = '1.3.1'
+    VERSION = '1.4.0'
   end
 end

data/lib/classy/yaml.rb

@@ -3,6 +3,7 @@ require "classy/yaml/engine"
 
 module Classy
   module Yaml
+    # -- Configuration Accessors --
     mattr_accessor :default_file
     @@default_file = "config/utility_classes.yml"
 
@@ -12,20 +13,103 @@ module Classy
     mattr_accessor :extra_files
     @@extra_files = []
 
+    # -- Autoloads --
     autoload :Helpers, "classy/yaml/helpers"
     autoload :ComponentHelpers, "classy/yaml/component_helpers"
     autoload :InvalidKeyError, "classy/yaml/invalid_key_error"
 
+    # -- Class Instance Variables for Caching --
+    @cached_engine_yamls = nil
+    @cached_default_yaml = nil
+    @load_lock = Mutex.new # Prevent race conditions during lazy loading
+
+    # -- Configuration Setters with Path Resolution --
     def self.engine_files=(value)
       @@engine_files = Array.wrap(value).reject(&:blank?).map { |file| Rails.root.join(file) }
+      @cached_engine_yamls = nil # Clear cache on reassignment
     end
 
     def self.extra_files=(value)
       @@extra_files = Array.wrap(value).reject(&:blank?).map { |file| Rails.root.join(file) }
+      # Note: extra_files are not cached globally by default
+    end
+
+    def self.default_file=(value)
+      @@default_file = value
+      @cached_default_yaml = nil # Clear cache on reassignment
+    end
+
+    # -- Cached Data Accessors (Lazy Loading) --
+    def self.cached_engine_yamls
+      # Bypass cache in development and test environments
+      return load_engine_yamls if Rails.env.development? || Rails.env.test?
+
+      # Use cache in other environments
+      return @cached_engine_yamls if @cached_engine_yamls
+
+      @load_lock.synchronize do
+        # Double-check idiom to ensure loading happens only once
+        return @cached_engine_yamls if @cached_engine_yamls
+        @cached_engine_yamls = load_engine_yamls
+      end
+    end
+
+    def self.cached_default_yaml
+      # Bypass cache in development and test environments
+      return load_default_yaml if Rails.env.development? || Rails.env.test?
+
+      # Use cache in other environments
+      return @cached_default_yaml if @cached_default_yaml
+
+      @load_lock.synchronize do
+        return @cached_default_yaml if @cached_default_yaml
+        @cached_default_yaml = load_default_yaml
+      end
     end
 
+    # -- Setup Method --
     def self.setup
       yield self
+      # Clear all caches when configuration changes
+      @cached_engine_yamls = nil
+      @cached_default_yaml = nil
+    end
+
+    private
+
+    # -- Private Loading Methods --
+    def self.load_engine_yamls
+      yamls = []
+      self.engine_files.each do |file_path|
+        begin
+          if File.exist?(file_path)
+            content = File.read(file_path, encoding: 'UTF-8')
+            parsed_yaml = YAML.safe_load(content, permitted_classes: [Symbol, String, Array, Hash], aliases: true)
+            yamls << parsed_yaml if parsed_yaml && parsed_yaml.is_a?(Hash)
+          end
+        rescue Psych::SyntaxError => e
+          Rails.logger.error "Classy::Yaml: Failed to parse engine YAML file #{file_path}: #{e.message}"
+        rescue => e
+          Rails.logger.error "Classy::Yaml: Error loading engine YAML file #{file_path}: #{e.message}"
+        end
+      end
+      yamls
+    end
+
+    def self.load_default_yaml
+      default_path = Rails.root.join(self.default_file)
+      begin
+        if File.exist?(default_path)
+          content = File.read(default_path, encoding: 'UTF-8')
+          parsed_yaml = YAML.safe_load(content, permitted_classes: [Symbol, String, Array, Hash], aliases: true)
+          return parsed_yaml if parsed_yaml && parsed_yaml.is_a?(Hash)
+        end
+      rescue Psych::SyntaxError => e
+        Rails.logger.error "Classy::Yaml: Failed to parse default YAML file #{default_path}: #{e.message}"
+      rescue => e
+        Rails.logger.error "Classy::Yaml: Error loading default YAML file #{default_path}: #{e.message}"
+      end
+      nil # Return nil if file doesn't exist or fails to load/parse
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: classy-yaml
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.4.0
 platform: ruby
 authors:
 - Tonksthebear
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-30 00:00:00.000000000 Z
+date: 2025-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -80,6 +80,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.36'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.60'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.60'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rails-omakase
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Rails helper to allow yaml configuration of utility css classes
 email:
 - ''
@@ -120,7 +162,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
+rubygems_version: 3.5.16
 signing_key:
 specification_version: 4
 summary: Rails helper to allow yaml configuration of utility css classes