classy-yaml 1.3.1 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82933744cd15e116066a4004c44169d70d36b2c6e58b4fbb6654d957ecea0ed4
-  data.tar.gz: 305cfa5b8a5a53bd50d5187fe8b2d13b0ecc52ea295a591dcca694c407567503
+  metadata.gz: b91dad78932d510d2299faae67a08584bad33501c3a048435603a6e673049090
+  data.tar.gz: c3d9d4e2c543e3f3b70b94260f2293d5d3f6a24474e228690aa5c97f5a80666f
 SHA512:
-  metadata.gz: d9e8f6d551c9b482b0712a8b4b50734ae579f876012dd1414df37f3db8f4ad9e5030a008ebdb1172e560d517f10c8b387237c45739ffc6f68d85c9d1184674eb
-  data.tar.gz: c6347754df73ef47fd53bc7d9ee1650a0aea5b7042d8ae08c3310fc4579281dc3763816cbe1aa4fb612f98d7d7eac165fa5566fd4a75b08f76f4c6b9ea292385
+  metadata.gz: 1bc0b46c0d2f9fb2a49eedada6e497c7aebf14bc6f95f75609461620f44d5df12066dd8437fe8be90240053670dad19bf6cf1a80a1d8a3f08f0a54ea8e1ce6ad
+  data.tar.gz: bcf8f2d58c819e91a935076eb920094e27b2855e30d13038fd26ad3942447d1c5c14f646427e18d3787a6c39774da89bc63443995cf0373935eceb28db0186b4

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

@@ -2,13 +2,13 @@ module Classy
   module Yaml
     module ComponentHelpers
       def yass(*args)
-        calling_path = Object.const_source_location(self.class.name).first.split('/')[0...-1].join('/')
-        calling_file = Object.const_source_location(self.class.name).first.split('/').last.split('.').first
-        component_name = self.class.name.underscore.split('/').last.split('.').first
+        calling_path = Object.const_source_location(self.class.name).first.split("/")[0...-1].join("/")
+        calling_file = Object.const_source_location(self.class.name).first.split("/").last.split(".").first
+        component_name = self.class.name.underscore.split("/").last.split(".").first
 
-        classy_files = ["#{calling_path}/#{component_name}.yml",
+        classy_files = [ "#{calling_path}/#{component_name}.yml",
                         "#{calling_path}/#{calling_file}/#{calling_file}.yml",
-                        "#{calling_path}/#{calling_file}/#{component_name}.yml"]
+                        "#{calling_path}/#{calling_file}/#{component_name}.yml" ]
 
         if args.first.is_a?(Hash)
           args.first.merge!({ classy_files: classy_files.uniq })

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)
@@ -42,14 +73,14 @@ module Classy
             end
 
             value.keys.each do |key|
-              values << (root + [key.to_s])
-              flatten_args(root: root + [key.to_s], values: [value[key]], keys: keys, added_classes: added_classes)
+              values << (root + [ key.to_s ])
+              flatten_args(root: root + [ key.to_s ], values: [ value[key] ], keys: keys, added_classes: added_classes)
             end
           else
             if value.is_a?(Array)
               flatten_args(root: root, values: value, keys: keys, added_classes: added_classes)
             else
-              keys << (root + [value.to_s])
+              keys << (root + [ value.to_s ])
             end
           end
         end
@@ -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.5.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,135 @@ module Classy
     mattr_accessor :extra_files
     @@extra_files = []
 
+    mattr_accessor :override_tag_helpers
+    @@override_tag_helpers = false
+
+    # -- 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
+
+    def self.override_tag_helpers=(value)
+      @@override_tag_helpers = value
+      apply_tag_helper_override if value
     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
+      # Apply tag helper override if enabled
+      apply_tag_helper_override if @@override_tag_helpers
+    end
+
+    private
+
+    def self.apply_tag_helper_override
+      return unless defined?(ActionView::Helpers::TagHelper)
+
+      # Override the TagBuilder class which is what the tag method returns
+      ActionView::Helpers::TagHelper::TagBuilder.class_eval do
+        unless method_defined?(:classy_yaml_original_tag_options)
+          alias_method :classy_yaml_original_tag_options, :tag_options
+
+          def tag_options(options, escape = true)
+            if options
+              class_key = options.key?(:class) ? :class : "class"
+              options = options.dup
+              val = options[class_key]
+              if val.is_a?(Symbol) || val.is_a?(Hash) || val.is_a?(Array)
+                options[:class] = yass(val)
+              end
+            end
+            classy_yaml_original_tag_options(options, escape)
+          end
+        end
+      end
+    end
+
+    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.5.0
 platform: ruby
 authors:
 - Tonksthebear
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-30 00:00:00.000000000 Z
+date: 2025-08-06 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