tailmix 0.1.0 → 0.4.5

data/lib/tailmix/html/attributes.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "erb"
+require_relative "class_list"
+require_relative "data_map"
+
+module Tailmix
+  module HTML
+    class Attributes < Hash
+      attr_reader :element_name
+
+      def initialize(initial_hash = {}, element_name: nil)
+        @element_name = element_name
+        super()
+        self[:class] = ClassList.new
+        self[:data]  = DataMap.new
+        merge!(initial_hash)
+      end
+
+      def each(&block)
+        to_h.each(&block)
+      end
+
+      def to_h
+        final_attrs = select { |k, _| !%i[class data].include?(k.to_sym) }
+        class_string = self[:class].to_s
+        final_attrs[:class] = class_string unless class_string.empty?
+        final_attrs.merge!(self[:data].to_h)
+
+        selector_attr = Tailmix.configuration.element_selector_attribute
+        if selector_attr && @element_name
+          final_attrs[selector_attr] = @element_name
+        end
+
+        final_attrs
+      end
+      alias_method :to_hash, :to_h
+
+      def to_s
+        classes.to_s
+      end
+
+      def classes
+        self[:class]
+      end
+
+      def data
+        self[:data]
+      end
+
+      def stimulus
+        data.stimulus
+      end
+
+      def toggle(class_names)
+        classes.toggle(class_names)
+        self
+      end
+
+      def add(class_names)
+        classes.add(class_names)
+        self
+      end
+
+      def remove(class_names)
+        classes.remove(class_names)
+        self
+      end
+    end
+  end
+end

data/lib/tailmix/html/class_list.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Tailmix
+  module HTML
+    # Manages a set of CSS classes with a fluent, chainable API.
+    # Inherits from Set to ensure uniqueness and leverage its performance.
+    class ClassList < Set
+      # Initializes a new ClassList.
+      # @param initial_classes [String, Array, Set, nil] The initial classes to add.
+      def initialize(initial_classes = nil)
+        super()
+        add(initial_classes) if initial_classes
+      end
+
+      # Adds one or more classes. Handles strings, arrays, or other sets.
+      # This method is MUTABLE and chainable.
+      # @param class_names [String, Array, Set, nil]
+      # @return [self]
+      def add(class_names)
+        each_token(class_names) { |token| super(token) }
+        self
+      end
+      alias << add
+
+      # Removes one or more classes.
+      # This method is MUTABLE and chainable.
+      # @param class_names [String, Array, Set, nil]
+      # @return [self]
+      def remove(class_names)
+        each_token(class_names) { |token| delete(token) }
+        self
+      end
+
+      # Toggles one or more classes.
+      # This method is MUTABLE and chainable.
+      # @param class_names [String, Array, Set, nil]
+      # @return [self]
+      def toggle(class_names)
+        each_token(class_names) { |token| include?(token) ? delete(token) : add(token) }
+        self
+      end
+
+      # Returns a new ClassList with the given classes added. IMMUTABLE.
+      def added(class_names)
+        dup.add(class_names)
+      end
+
+      # Returns a new ClassList with the given classes removed. IMMUTABLE.
+      def removed(class_names)
+        dup.remove(class_names)
+      end
+
+      # Returns a new ClassList with the given classes toggled. IMMUTABLE.
+      def toggled(class_names)
+        dup.toggle(class_names)
+      end
+
+      # Renders the set of classes to a space-separated string for HTML.
+      # @return [String]
+      def to_s
+        to_a.join(" ")
+      end
+
+      private
+
+      # A robust way to iterate over tokens from various input types.
+      def each_token(input)
+        return unless input
+        # Convert Set/ClassList to array before splitting strings inside
+        items = input.is_a?(Set) ? input.to_a : Array(input)
+        items.each do |item|
+          item.to_s.split.each { |token| yield token unless token.empty? }
+        end
+      end
+    end
+  end
+end

data/lib/tailmix/html/data_map.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "erb"
+require "json"
+require_relative "stimulus_builder"
+
+module Tailmix
+  module HTML
+    class DataMap
+      MERGEABLE_LIST_ATTRIBUTES = %i[controller action target].freeze
+
+      def initialize(initial_data = {})
+        @data = {}
+        merge!(initial_data)
+      end
+
+      def stimulus
+        StimulusBuilder.new(self)
+      end
+
+      def merge!(other_data)
+        return self unless other_data
+        data_to_merge = other_data.is_a?(DataMap) ? other_data.instance_variable_get(:@data) : other_data
+
+        (data_to_merge || {}).each do |key, value|
+          key = key.to_sym
+          if value.is_a?(Hash) && @data[key].is_a?(Hash)
+            @data[key].merge!(value)
+          elsif MERGEABLE_LIST_ATTRIBUTES.include?(key)
+            add_to_set(key, value)
+          else
+            @data[key] = value
+          end
+        end
+        self
+      end
+      alias_method :add, :merge!
+
+      def merge(other_data)
+        dup.merge!(other_data)
+      end
+
+      def add_to_set(key, value)
+        @data[key] ||= Set.new
+        return unless value
+        items_to_process = value.is_a?(Set) ? value.to_a : Array(value)
+        items_to_process.each do |item|
+          item.to_s.split.each do |token|
+            @data[key].add(token) unless token.empty?
+          end
+        end
+      end
+
+      def remove(other_data)
+        (other_data || {}).each do |key, _|
+          @data.delete(key.to_sym)
+        end
+        self
+      end
+
+      def toggle(other_data)
+        (other_data || {}).each do |key, value|
+          key = key.to_sym
+          @data[key] == value ? @data.delete(key) : @data[key] = value
+        end
+        self
+      end
+
+      def to_h
+        flatten_data_hash(@data)
+      end
+
+      private
+
+      def flatten_data_hash(hash, prefix = "data", accumulator = {})
+        hash.each do |key, value|
+          current_key = "#{prefix}-#{key.to_s.tr('_', '-')}"
+          if key.to_s.end_with?("_value")
+            serialized_value = case value
+            when Hash, Array then value.to_json
+            else value
+            end
+            accumulator[current_key] = serialized_value
+          elsif value.is_a?(Hash)
+            flatten_data_hash(value, current_key, accumulator)
+          else
+            serialized_value = value.is_a?(Set) ? value.to_a.join(" ") : value
+            accumulator[current_key] = serialized_value unless serialized_value.to_s.empty?
+          end
+        end
+        accumulator
+      end
+    end
+  end
+end

data/lib/tailmix/html/stimulus_builder.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Tailmix
+  module HTML
+    # A fluent DSL (builder) for constructing Stimulus data attributes.
+    # It acts as a proxy, modifying a DataMap instance directly.
+    class StimulusBuilder
+      def initialize(data_map)
+        @data_map = data_map
+        @context = nil # For context-aware attributes like targets and values
+      end
+
+      # Defines a controller and sets it as the current context.
+      # @return [self] for chaining.
+      def controller(controller_name)
+        @data_map.add_to_set(:controller, controller_name)
+        @context = controller_name.to_s
+        self
+      end
+
+      # Sets the controller context for subsequent calls.
+      def context(controller_name)
+        @context = controller_name.to_s
+        self
+      end
+
+      # Adds an action.
+      # @example
+      #   .action("click->modal#open")
+      # @return [self]
+      def action(action_string)
+        @data_map.add_to_set(:action, action_string)
+        self
+      end
+
+      # Adds a target, scoped to the current controller context.
+      # @return [self]
+      def target(target_name)
+        ensure_context!
+        # `target` is a shared attribute, but names are scoped to a controller.
+        # So we add to the common `target` set.
+        @data_map.add_to_set(:"#{@context}-target", target_name)
+        self
+      end
+
+      # Adds a value, scoped to the current controller context.
+      # @return [self]
+      def value(value_name, value)
+        ensure_context!
+        @data_map.merge!("#{context_key(value_name)}_value" => value)
+        self
+      end
+
+      private
+
+      def ensure_context!
+        raise "A controller context must be set via .controller() or .context() before this call." unless @context
+      end
+
+      def context_key(name)
+        "#{@context}-#{name.to_s.tr('_', '-')}"
+      end
+    end
+  end
+end

data/lib/tailmix/runtime/action.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Tailmix
+  module Runtime
+    # Represents a callable action at runtime that can apply a set of
+    # predefined mutations to its context.
+    class Action
+      attr_reader :context, :definition
+
+      def initialize(context, action_name)
+        @context = context
+        @action_name = action_name.to_sym
+        @definition = context.definition.actions[@action_name]
+        raise Error, "Action `#{@action_name}` not found." unless @definition
+      end
+
+      # Applies the mutations to the context immutably, returning a new context.
+      # @return [Context] A new, modified context instance.
+      def apply
+        new_context = context.dup
+
+        action_on_clone = self.class.new(new_context, @action_name)
+
+        action_on_clone.apply!
+      end
+
+      def apply!
+        # `definition.mutations`  { element_name => [commands] }
+        definition.mutations.each do |element_name, commands|
+          attributes_object = context.live_attributes_for(element_name)
+          next unless attributes_object
+
+          commands.each do |command|
+            target_field = attributes_object.public_send(command[:field])
+            target_field.public_send(command[:method], command[:payload])
+          end
+        end
+        context
+      end
+
+      # Serializes the action's definition into a hash for the JS bridge.
+      # @return [Hash]
+      def to_h
+        {
+          method: definition.action,
+          mutations: definition.mutations
+        }
+      end
+    end
+  end
+end

data/lib/tailmix/runtime/context.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Tailmix
+  module Runtime
+    class Context
+      attr_reader :component_instance, :definition, :dimensions
+
+      def initialize(component_instance, definition, dimensions)
+        @component_instance = component_instance
+        @definition = definition
+        @dimensions = dimensions
+        @attributes_cache = {}
+      end
+
+      def initialize_copy(source)
+        super
+        @attributes_cache = source.instance_variable_get(:@attributes_cache).transform_values(&:dup)
+      end
+
+      def live_attributes_for(element_name)
+        @attributes_cache[element_name] ||= build_attributes_for(element_name, @dimensions)
+      end
+
+      def attributes_for(element_name, runtime_dimensions = {})
+        merged_dimensions = @dimensions.merge(runtime_dimensions)
+        return @attributes_cache[element_name] if merged_dimensions == @dimensions && @attributes_cache[element_name]
+
+        attributes_object = build_attributes_for(element_name, merged_dimensions)
+        @attributes_cache[element_name] = attributes_object if merged_dimensions == @dimensions
+        attributes_object
+      end
+
+      def action(name)
+        Action.new(self, name)
+      end
+
+      private
+
+      def build_attributes_for(element_name, dimensions)
+        element_def = @definition.elements.fetch(element_name)
+        initial_classes = element_def.attributes.classes
+        class_list = HTML::ClassList.new(initial_classes)
+
+        element_def.dimensions.each do |name, dim|
+          value = dimensions.fetch(name, dim[:default])
+          next if value.nil?
+          classes_for_option = dim.fetch(:options, {}).fetch(value, nil)
+          class_list.add(classes_for_option)
+        end
+
+        data_map = HTML::DataMap.new
+        Stimulus::Compiler.call(
+          definition: element_def.stimulus,
+          data_map: data_map,
+          root_definition: @definition,
+          component: @component_instance
+        )
+
+        HTML::Attributes.new(
+          { class: class_list, data: data_map },
+          element_name: element_def.name
+        )
+      end
+    end
+  end
+end

data/lib/tailmix/runtime/facade_builder.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Tailmix
+  module Runtime
+    class FacadeBuilder
+      def self.build(definition)
+        Class.new(Tailmix::Runtime::Context) do
+          definition.elements.each_key do |element_name|
+            define_method(element_name) do |runtime_dimensions = {}|
+              attributes_for(element_name, runtime_dimensions)
+            end
+          end
+
+          def inspect
+            component_name = @component_instance.class.name || "AnonymousComponent"
+            elements_list = @definition.elements.keys.join(", ")
+            "#<Tailmix::UI for #{component_name} elements=[#{elements_list}] dimensions=#{@dimensions.inspect}>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tailmix/runtime/stimulus/compiler.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Tailmix
+  module Runtime
+    module Stimulus
+      class Compiler
+
+        def self.call(definition:, data_map:, root_definition:, component:)
+          (definition.definitions || []).each do |rule|
+            builder = data_map.stimulus
+
+            case rule[:type]
+            when :controller
+              builder.controller(rule[:name])
+            when :action
+              action_data = rule[:data]
+              controller_name = rule[:controller]
+
+              action_string = case action_data[:type]
+              when :raw
+                action_data[:content]
+              when :hash
+                action_data[:content].map { |event, method| "#{event}->#{controller_name}##{method}" }.join(" ")
+              when :tuple
+                event, method = action_data[:content]
+                "#{event}->#{controller_name}##{method}"
+              end
+
+              builder.context(controller_name).action(action_string)
+            when :target
+              builder.context(rule[:controller]).target(rule[:name])
+            when :value
+              source = rule[:source]
+
+              resolved_value = case source[:type]
+              when :literal
+                source[:content]
+              when :proc
+                source[:content].call
+              when :method
+                component.public_send(source[:content])
+              else
+                # type code here
+              end
+
+              builder.context(rule[:controller]).value(rule[:name], resolved_value)
+
+            when :param
+              builder.context(rule[:controller]).param(rule[:params])
+            when :action_payload
+              action = root_definition.actions.fetch(rule[:action_name])
+              builder.context(rule[:controller]).value(rule[:value_name], action.to_h)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tailmix/runtime.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "set"
+require_relative "runtime/context"
+require_relative "runtime/facade_builder"
+require_relative "runtime/stimulus/compiler"
+require_relative "html/attributes"
+require_relative "runtime/action"
+
+
+module Tailmix
+  module Runtime
+  end
+end

data/lib/tailmix/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tailmix
-  VERSION = "0.1.0"
+  VERSION = "0.4.5"
 end

data/lib/tailmix.rb

@@ -1,37 +1,67 @@
 # frozen_string_literal: true
 
 require_relative "tailmix/version"
-require_relative "tailmix/schema"
-require_relative "tailmix/resolver"
-require_relative "tailmix/manager"
-require_relative "tailmix/part"
-require_relative "tailmix/dimension"
-require_relative "tailmix/element"
-require_relative "tailmix/utils"
+require_relative "tailmix/definition"
+require_relative "tailmix/runtime"
+require_relative "tailmix/dev/tools"
 
 module Tailmix
-  def self.included(base)
-    base.extend(ClassMethods)
-    base.instance_variable_set(:@tailmix_schema, nil)
+  class Error < StandardError; end
 
-    base.define_singleton_method(:tailmix_schema) do
-      @tailmix_schema
-    end
+  class << self
+    attr_writer :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
 
-    base.define_singleton_method(:tailmix_schema=) do |value|
-      @tailmix_schema = value
+  class Configuration
+    attr_accessor :element_selector_attribute
+
+    def initialize
+      element_selector_attribute = nil
     end
   end
 
   module ClassMethods
     def tailmix(&block)
-      self.tailmix_schema = Schema.new(&block)
+      child_context = Definition::ContextBuilder.new
+      child_context.instance_eval(&block)
+      child_definition = child_context.build_definition
+
+      if superclass.respond_to?(:tailmix_definition) && (parent_definition = superclass.tailmix_definition)
+        @tailmix_definition = Definition::Merger.call(parent_definition, child_definition)
+      else
+        @tailmix_definition = child_definition
+      end
+    end
+
+    def tailmix_definition
+      @tailmix_definition || raise(Error, "Tailmix definition not found in #{name}")
+    end
+
+    def tailmix_facade_class
+      @_tailmix_facade_class ||= Runtime::FacadeBuilder.build(tailmix_definition)
+    end
+
+    def dev
+      Dev::Tools.new(self)
     end
   end
 
-  private
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
 
   def tailmix(options = {})
-    Manager.new(self.class.tailmix_schema, options)
+    facade_class = self.class.tailmix_facade_class
+    facade_class.new(self, self.class.tailmix_definition, options)
   end
 end
+
+require_relative "tailmix/engine" if defined?(Rails)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tailmix
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.4.5
 platform: ruby
 authors:
 - Alexander Fokin
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-08-14 00:00:00.000000000 Z
+date: 2025-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -68,15 +68,38 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- examples/status_badge_component.rb
+- app/javascript/tailmix/finder.js
+- app/javascript/tailmix/index.js
+- app/javascript/tailmix/mutator.js
+- app/javascript/tailmix/runner.js
+- app/javascript/tailmix/stimulus_adapter.js
+- examples/_modal_component.arb
+- examples/modal_component.rb
+- lib/generators/tailmix/install_generator.rb
 - lib/tailmix.rb
-- lib/tailmix/dimension.rb
-- lib/tailmix/element.rb
-- lib/tailmix/manager.rb
-- lib/tailmix/part.rb
-- lib/tailmix/resolver.rb
-- lib/tailmix/schema.rb
-- lib/tailmix/utils.rb
+- lib/tailmix/definition.rb
+- lib/tailmix/definition/context_builder.rb
+- lib/tailmix/definition/contexts/action_builder.rb
+- lib/tailmix/definition/contexts/actions/element_builder.rb
+- lib/tailmix/definition/contexts/attribute_builder.rb
+- lib/tailmix/definition/contexts/dimension_builder.rb
+- lib/tailmix/definition/contexts/element_builder.rb
+- lib/tailmix/definition/contexts/stimulus_builder.rb
+- lib/tailmix/definition/merger.rb
+- lib/tailmix/definition/result.rb
+- lib/tailmix/dev/docs.rb
+- lib/tailmix/dev/stimulus_generator.rb
+- lib/tailmix/dev/tools.rb
+- lib/tailmix/engine.rb
+- lib/tailmix/html/attributes.rb
+- lib/tailmix/html/class_list.rb
+- lib/tailmix/html/data_map.rb
+- lib/tailmix/html/stimulus_builder.rb
+- lib/tailmix/runtime.rb
+- lib/tailmix/runtime/action.rb
+- lib/tailmix/runtime/context.rb
+- lib/tailmix/runtime/facade_builder.rb
+- lib/tailmix/runtime/stimulus/compiler.rb
 - lib/tailmix/version.rb
 - sig/tailmix.rbs
 homepage: https://github.com/alexander-s-f/tailmix