attrify 0.4.0

data/lib/attrify/helpers.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Attrify
+  module Helpers
+    def compute_attributes(hash)
+      results = {}
+
+      hash.each do |key, operations|
+        if operations.is_a?(Hash)
+          results[key] = compute_attributes(operations)
+        elsif operations.is_a?(Array)
+          current_value = []
+
+          # Process each operation in order
+          operations.each do |operation_hash|
+            operation_hash.each do |operation, value|
+              current_value = execute_operation(operation.to_sym, current_value, value)
+            end
+          end
+
+          # Flatten array and convert to string if not a hash
+          results[key] = current_value.join(" ")
+        else
+          results[key] = operations
+        end
+      end
+
+      results
+    end
+
+    def execute_operation(operation, current_value, value)
+      case operation
+      when :append
+        current_value + value
+      when :prepend
+        value + current_value
+      when :remove
+        current_value - value
+      when :set
+        value
+      else
+        current_value
+      end
+    end
+
+    def deep_merge_hashes!(hash1, hash2)
+      hash1.merge!(hash2) do |key, oldval, newval|
+        if oldval.is_a?(Hash)
+          deep_merge_hashes(oldval, newval)
+        elsif oldval.is_a?(Array)
+          oldval + newval  # Concatenate arrays
+        else
+          newval  # In case of conflicting types or non-container types, prefer newval
+        end
+      end
+    end
+
+    def deep_merge_hashes(hash1, hash2)
+      hash1.merge(hash2) do |key, oldval, newval|
+        if oldval.is_a?(Hash)
+          deep_merge_hashes(oldval, newval)
+        elsif oldval.is_a?(Array)
+          oldval + newval  # Concatenate arrays
+        else
+          newval
+        end
+      end
+    end
+  end
+end

data/lib/attrify/operation_set.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require "action_view"
+require "attrify/parser"
+
+module Attrify
+  class OperationSet
+    include ActionView::Helpers::TagHelper
+    include Helpers
+
+    attr_reader :operations
+    attr_reader :has_procs
+
+    def initialize(operations, has_procs = false)
+      @has_procs = has_procs
+      @operations = operations
+    end
+
+    def to_html
+      tag.attributes(@result)
+    end
+
+    def to_tags
+      to_hash
+    end
+
+    def dig(*keys)
+      result = @result.dig(*keys)
+
+      if result.present?
+        if result.has_key?(:attributes)
+          result[:attributes]
+        end
+      end
+    end
+
+    def values_for(instance:, keys:)
+      # if @has_procs
+
+      @operations = run_procs_on(@operations, instance)
+      @result = cache_result(@operations)[:value]
+      @result = @result.dig(*keys)
+      if @result.present?
+        if @result.has_key?(:attributes)
+          @result = @result[:attributes]
+        end
+      end
+      self
+      # else
+      #  self
+      # end
+    end
+
+    def to_hash
+      @result
+    end
+
+    # Retrieve value by key
+    def [](key)
+      @result[key]
+    end
+
+    # Set value by key
+    def []=(key, value)
+      @result[key] = value
+    end
+
+    # Iterate like a hash
+    def each(&)
+      @result.each(&)
+    end
+
+    # Return all keys
+    def keys
+      @result.keys
+    end
+
+    # Return all values
+    def values
+      @result
+    end
+
+    def to_s
+      to_html
+    end
+
+    private
+
+    def cache_result(hash, current_root = nil)
+      results = {}
+      has_procs = false
+
+      hash.each do |key, operations|
+        # Set current_root if it's not already set (top-level keys)
+        current_root = key if current_root.nil?
+
+        if operations.is_a?(Hash)
+          # Recursively process the nested hash
+          result = cache_result(operations, current_root)
+          results[key] = result[:value]
+          has_procs ||= result[:has_procs]
+        elsif operations.is_a?(Array)
+          current_value = []
+          # Determine if we can cache the value
+          can_cache_value = operations.any? { |operation| operation.key?(:set) } ||
+            current_root == :main
+
+          # Process each operation in order
+          operations.each do |operation_hash|
+            operation_hash.each do |operation, value|
+              # Ensure value is an array
+              value_array = Array(value)
+              has_procs ||= value_array.any? { |c| c.is_a?(Proc) }
+              if can_cache_value
+                current_value = execute_operation(operation.to_sym, current_value, value_array)
+              end
+            end
+          end
+
+          # Set the result based on whether we can cache the value
+          results[key] = if can_cache_value
+            current_value.join(" ")
+          else
+            operations
+          end
+        else
+          has_procs ||= operations.is_a?(Proc)
+          results[key] = operations
+        end
+      end
+
+      {value: results, has_procs: has_procs}
+    end
+
+    def cache_resultss(hash)
+      results = {}
+      has_procs = false
+
+      hash.each do |key, operations|
+        if operations.is_a?(Hash)
+          result = cache_result(operations)
+          results[key] = result[:value]
+          has_procs = true if result[:has_procs]
+        elsif operations.is_a?(Array)
+          current_value = []
+          # If any operation is a SET operation, then we can simply perform all operations now
+          can_cache_value = operations.any? { |operation| operation.key?(:set) } || key == :main
+
+          # Process each operation in order
+          operations.each do |operation_hash|
+            operation_hash.each do |operation, value|
+              has_procs = true if value.any? { |c| c.is_a?(Proc) }
+              if can_cache_value
+                current_value = execute_operation(operation.to_sym, current_value, value)
+              end
+            end
+          end
+
+          # Flatten array and convert to string if not a hash
+          results[key] = if can_cache_value
+            current_value.join(" ")
+          else
+            operations
+          end
+        else
+          has_procs = true if operations.is_a?(Proc)
+          results[key] = operations
+        end
+      end
+
+      {value: results, has_procs: has_procs}
+    end
+
+    def merge_arrays(hash)
+      hash.transform_values do |value|
+        case value
+        when Hash
+          merge_arrays(value)  # Recursively process nested hashes
+        when Array
+          if value.all? { |v| v.is_a?(String) }
+            value.join(" ")    # Join array of strings into a single string
+          else
+            value.map { |v| v.is_a?(Hash) ? merge_arrays(v) : v }
+          end
+        else
+          value  # Return the value as is if it's neither a Hash nor an Array
+        end
+      end
+    end
+
+    # Recursively traverse a hash and run any procs
+    def run_procs_on(hash, instance)
+      hash.each_with_object({}) do |(key, value), processed_hash|
+        processed_hash[key] = if value.is_a?(Hash)
+          # Recursively handle nested hashes
+          run_procs_on(value, instance)
+        elsif value.is_a?(Array)
+          # Process arrays, replacing any procs
+          value.map do |element|
+            if element.is_a?(Proc)
+              # If it's a proc, execute it with the instance
+              instance.instance_exec(&element)
+            elsif element.is_a?(Hash)
+              # Recursively handle nested hashes
+              run_procs_on(element, instance)
+            else
+              element
+            end
+          end
+        elsif value.is_a?(Proc)
+          # If it's a proc, execute it with the instance
+          instance.instance_exec(&value)
+        else
+          # If it's not a proc or a hash, keep it as is
+          value
+        end
+      end
+    end
+  end
+end

data/lib/attrify/parser.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require_relative "helpers"
+
+module Attrify
+  class Parser
+    OPERATIONS = [:append, :prepend, :remove, :set].freeze
+    ALLOWED_NESTED_FIELDS = [:data, :aria].freeze
+
+    class << self
+      include Helpers
+
+      def parse_base(base)
+        parse_slots(base)
+      end
+
+      def parse_variants(variants)
+        variants.transform_values do |variant_options|
+          variant_options.transform_values do |option|
+            parse_slots(option)
+          end
+        end
+      end
+
+      def parse_compounds(compounds)
+        raise ArgumentError, "Invalid compounds structure: Expected an Array" unless compounds.is_a?(Array)
+        return [] if compounds.empty?
+
+        compounds.map do |compound|
+          # Ensure each compound is a Hash and contains :variant and :attributes keys
+          unless compound.is_a?(Hash) && compound.key?(:variants) && compound.key?(:attributes)
+            raise ArgumentError, "Invalid compound structure: Each compound must have :variants and :attributes keys"
+          end
+
+          # Parse the attributes section using parse_slots
+          {
+            variants: compound[:variants], # Keep the variants as they are
+            attributes: parse_slots(compound[:attributes]) # Parse the attributes section using parse_slots
+          }
+        end
+      end
+
+      def parse_defaults(defaults)
+        # Ensure the defaults is a hash
+        unless defaults.is_a?(Hash)
+          raise ArgumentError, "Defaults must be a hash, got #{defaults.class}"
+        end
+
+        # Ensure that all keys and values are symbols
+        unless defaults.all? { |key, value| key.is_a?(Symbol) && value.is_a?(Symbol) }
+          raise ArgumentError, "Defaults must be a flat hash of symbols. Got: #{defaults.inspect}"
+        end
+
+        defaults
+      end
+
+      def parse_slots(slots)
+        parsed_value = parse_slot(slots)
+        if parsed_value.key?(:attributes)
+          parsed_value = {main: parsed_value}
+        end
+        parsed_value
+      end
+
+      # {
+      #   class: [{set: %w[bg-blue-500 text-white]}],
+      #   style:  "width:100px",
+      #   data: { controller: "stimulus_controller" },
+      #   # this one is a slot
+      #   nested: { sub_slot: {class:"red"}, class: "10"}
+      # }
+      def parse_slot(slot)
+        raise ArgumentError, "Invalid slot structure: Expected a Hash #{slot}" unless slot.is_a?(Hash)
+
+        attributes = slot[:attributes] || {}
+
+        nested_slots = nested_slots(slot)
+        additional_attributes = slot.reject { |key, _| key == :attributes || nested_slots.include?(key) }
+
+        deep_merge_hashes!(attributes, additional_attributes)
+
+        parsed_slot = {}
+        parsed_slot[:attributes] = parse_attributes(attributes) unless attributes.empty?
+
+        # Recursively handle nested slots
+        nested_slots.each do |nested_slot_name|
+          parsed_slot[nested_slot_name] = parse_slot(slot[nested_slot_name])
+        end
+        parsed_slot
+      end
+
+      #  class: [{set: %w[bg-blue-500 text-white]}]
+      #  style: "width:100px"
+      #  data: { controller: "stimulus_controller" }
+      #  class: "red"
+      #  class: "10"
+      def parse_attributes(attributes)
+        unless attributes.is_a?(Hash)
+          raise ArgumentError, "Invalid attributes list: Expected a Hash, got #{attributes.class}"
+        end
+
+        if is_simple_operation?(attributes)
+          raise ArgumentError, "Invalid Attributes List: got an operation"
+        end
+
+        parsed_attributes = {}
+
+        attributes.each do |key, value|
+          parsed_attributes[key] = parse_attribute(key, value)
+        end
+        parsed_attributes
+      end
+
+      def parse_attribute(key, value)
+        unless valid_attribute?(key, value)
+          raise ArgumentError, "Invalid attributes list: invalid attribute #{key}"
+        end
+        unless key.is_a?(Symbol)
+          raise ArgumentError, "Attribute: Key must be a symbol #{key}"
+        end
+
+        parse_operations(value)
+      end
+
+      def parse_operations(value)
+        case value
+        when Hash
+          # Check if the hash is a simple operation or needs further parsing
+          if is_simple_operation?(value)
+            [parse_operation(value)]
+          else
+            value.transform_values { |v|
+              parsed_operation = parse_operations(v)
+              if is_simple_operation?(parsed_operation)
+                [parsed_operation]
+              else
+                parsed_operation
+              end
+            }
+          end
+        when Array
+          if value.any? { |v| is_simple_operation?(v) }
+            value.map { |v| parse_operation(v) }
+          else
+            [parse_operation(value)]
+          end
+        else
+          [parse_operation(value)]
+        end
+      end
+
+      def parse_operation(operation)
+        case operation
+        when Hash
+          if !is_simple_operation?(operation)
+            raise ArgumentError, "Invalid operation: got #{operation}"
+          end
+          operation.transform_values { |v|
+            if v.is_a?(Array)
+              v.map { |x| x.is_a?(Proc) ? x : x.to_s }
+            else
+              [v.is_a?(Proc) ? v : v.to_s]
+            end
+          }
+        when Array
+          {set: operation.map { |v| v.is_a?(Proc) ? v : v.to_s }}
+        when Proc
+          {set: [operation]}
+        else
+          {set: Array(operation.to_s)}
+        end
+      end
+
+      private
+
+      def nested_slots(hash)
+        hash.keys.select do |key|
+          value = hash[key]
+          next false unless value.is_a?(Hash)
+
+          key != :attributes && !ALLOWED_NESTED_FIELDS.include?(key) && !is_simple_operation?(value)
+        end
+      end
+
+      def valid_attribute?(key, value)
+        return true unless value.is_a?(Hash)
+        ALLOWED_NESTED_FIELDS.include?(key) || is_simple_operation?(value)
+      end
+
+      def is_simple_operation?(operation)
+        operation.is_a?(Hash) && (operation.keys.size == 1) && OPERATIONS.include?(operation.keys.first)
+      end
+
+      def array_of_operations?(array)
+        return false if array.empty?
+        array.all? do |item|
+          item.is_a?(Hash) && is_simple_operation?(item)
+        end
+      end
+    end
+  end
+end

data/lib/attrify/variant.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "attrify/operation_set"
+
+module Attrify
+  class Variant
+    include Helpers
+
+    attr_reader :operations
+    attr_reader :attributes
+    attr_reader :has_procs
+
+    def initialize(operations)
+      @operations = operations
+
+      result = cache_result(operations)
+
+      @has_procs = result[:has_procs]
+      @attributes = result[:value]
+    end
+
+    def adjust(hash)
+      OperationSet.new(deep_merge_hashes(@operations, hash))
+    end
+
+    private
+
+    def cache_result(hash)
+      results = {}
+      has_procs = false
+
+      hash.each do |key, operations|
+        if operations.is_a?(Hash)
+          result = cache_result(operations)
+          results[key] = result[:value]
+          has_procs = true if result[:has_procs]
+        elsif operations.is_a?(Array)
+          current_value = []
+          # If any operation is a SET operation, then we can simply perform all operations now
+          can_cache_value = operations.any? { |operation| operation.key?(:set) } || key == :main
+
+          # Process each operation in order
+          operations.each do |operation_hash|
+            operation_hash.each do |operation, value|
+              has_procs = true if value.any? { |c| c.is_a?(Proc) }
+              if can_cache_value
+                current_value = execute_operation(operation.to_sym, current_value, value)
+              end
+            end
+          end
+
+          # Flatten array and convert to string if not a hash
+          results[key] = if can_cache_value
+            current_value # .join(" ")
+          else
+            operations
+          end
+        else
+          has_procs = true if operations.is_a?(Proc)
+          results[key] = operations
+        end
+      end
+
+      {value: results, has_procs: has_procs}
+    end
+  end
+end

data/lib/attrify/variant_registry.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "action_view/helpers/tag_helper"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/string/inflections"
+
+require "attrify/parser"
+require "attrify/variant"
+require "attrify/helpers"
+
+module Attrify
+  class VariantRegistry
+    include Helpers
+
+    attr_reader :base, :variants, :defaults, :compounds
+
+    def initialize(base: {}, variants: {}, defaults: {}, compounds: [])
+      self.base = base
+      self.variants = variants
+      self.defaults = defaults
+      self.compounds = compounds
+      @cache = {}
+    end
+
+    def base=(value)
+      @base = Parser.parse_base(value)
+    end
+
+    def variants=(value)
+      @variants = Parser.parse_variants(value)
+    end
+
+    def compounds=(value)
+      @compounds = Parser.parse_compounds(value)
+    end
+
+    def defaults=(value)
+      @defaults = Parser.parse_defaults(value)
+    end
+
+    # Fetch the correct variant, with caching
+    def fetch(**args)
+      # Split args into variant and operations
+      variant_keys = variants.keys
+      variant_args = {}
+      operation_args = {}
+
+      args.each do |key, value|
+        if variant_keys.include?(key)
+          variant_args[key] = Array(value).join("_").to_sym
+        else
+          operation_args[key] = value
+        end
+      end
+
+      operations = Parser.parse_slots(operation_args)
+
+      cache_key = generate_cache_key(variant_args)
+
+      # Return the cached result if it exists
+      unless @cache.key?(cache_key)
+        @cache[cache_key] = compute_variant(variant: variant_args)
+      end
+
+      @cache[cache_key].adjust(operations)
+    end
+
+    def initialize_copy(orig)
+      super
+      @base = @base.dup
+      @variants = @variants.dup
+      @defaults = @defaults.dup
+      @compounds = @compounds.dup
+      @cache = {}
+    end
+
+    private
+
+    # Generate a unique key based on the variants
+    def generate_cache_key(variant)
+      variant.sort.to_h.to_s
+    end
+
+    def compute_variant(variant: {})
+      # Start with our base attributes
+      result = @base.dup
+
+      # Merge default variants with user-specified variants
+      selected_variants = @defaults.merge(variant)
+
+      # Apply selected variants to the base attributes
+      selected_variants.each do |variant_type, variant_key|
+        variant_defs = @variants.dig(variant_type, variant_key)
+        next unless variant_defs
+        deep_merge_hashes!(result, variant_defs)
+      end
+
+      # Apply compounds variants
+      @compounds.each do |compound_variant|
+        if compound_variant[:variants].all? { |key, value| selected_variants[key] == value }
+          deep_merge_hashes!(result, compound_variant[:attributes])
+        end
+      end
+
+      Variant.new(result)
+    end
+  end
+end

data/lib/attrify/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Attrify
+  VERSION = "0.4.0"
+end