view_component_atomix 0.1.0

data/lib/view_component/atomix/configuration.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Atomix
+    class Configuration
+      DEFAULT_PSEUDO_MAP = {
+        hover: ":hover",
+        focus: ":focus",
+        focus_visible: ":focus-visible",
+        focus_within: ":focus-within",
+        active: ":active",
+        visited: ":visited",
+        link: ":link",
+        target: ":target",
+        disabled: ":disabled",
+        enabled: ":enabled",
+        checked: ":checked",
+        indeterminate: ":indeterminate",
+        required: ":required",
+        optional: ":optional",
+        valid: ":valid",
+        invalid: ":invalid",
+        read_only: ":read-only",
+        placeholder_shown: ":placeholder-shown",
+        empty: ":empty",
+        first_child: ":first-child",
+        last_child: ":last-child",
+        only_child: ":only-child",
+        first_of_type: ":first-of-type",
+        last_of_type: ":last-of-type",
+        before: "::before",
+        after: "::after",
+        placeholder: "::placeholder",
+        selection: "::selection",
+        marker: "::marker",
+        dark: "@media (prefers-color-scheme: dark)",
+        light: "@media (prefers-color-scheme: light)",
+        reduced_motion: "@media (prefers-reduced-motion: reduce)",
+        print: "@media print"
+      }.freeze
+
+      CLASS_PREFIX = /\A[a-zA-Z_][a-zA-Z0-9_-]*\z/
+
+      attr_accessor :vars, :eager_load_paths, :autoload_roots, :use_layers, :inline, :output_path
+      attr_reader :styles_method, :breakpoints, :class_prefix, :pseudo_map
+      alias inline? inline
+
+      def initialize
+        reset!
+      end
+
+      def reset!
+        @class_prefix = "vc"
+        @breakpoints = {}
+        @pseudo_map = DEFAULT_PSEUDO_MAP.dup
+        @output_path = "app/assets/builds/view_component_atomix.css"
+        @vars = nil
+        @eager_load_paths = ["app/components", "app/components/styles", "app/styles"]
+        @autoload_roots = ["app/components/styles"]
+        @use_layers = false
+        @inline = true
+        @styles_method = :styles
+      end
+
+      def styles_method=(name)
+        @styles_method = name.to_sym
+      end
+
+      def class_prefix=(prefix)
+        prefix = prefix.to_s
+        unless prefix.match?(CLASS_PREFIX)
+          raise ArgumentError, "class_prefix must start with a letter or underscore and contain only " \
+                               "letters, digits, hyphens and underscores, got #{prefix.inspect}"
+        end
+
+        @class_prefix = prefix
+      end
+
+      def pseudo_map=(map)
+        ConditionResolver.validate_pseudo_map!(map)
+        ConditionResolver.validate_breakpoints!(breakpoints, pseudo_map: map)
+        @pseudo_map = map.dup
+      end
+
+      def breakpoints=(map)
+        validate_breakpoints!(map)
+        @breakpoints = map.dup
+      end
+
+      def validate_breakpoints!(map)
+        ConditionResolver.validate_breakpoints!(map, pseudo_map: pseudo_map)
+      end
+
+      def condition_resolver(breakpoints = self.breakpoints)
+        ConditionResolver.new(breakpoints: breakpoints, pseudo_map: pseudo_map)
+      end
+
+      def resolve_condition(key, breakpoints = self.breakpoints)
+        condition_resolver(breakpoints).resolve(key)
+      end
+    end
+  end
+end

data/lib/view_component/atomix/declaration_queue.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Atomix
+    class DeclarationQueue
+      MAX_DRAIN_PASSES = 1000
+      StyleDeclaration = Struct.new(:block, :source, keyword_init: true)
+      VariableDeclaration = Struct.new(:label, :block, :source, keyword_init: true)
+      ThemeDeclaration = Struct.new(:vars, :overrides, :block, :source, keyword_init: true)
+
+      def initialize
+        @pending = []
+      end
+
+      def <<(declaration)
+        @pending << declaration
+        self
+      end
+
+      # Successful declarations stay consumed. On failure, retry the failed
+      # declaration and its successors before work enqueued during evaluation.
+      # Owners serialize access with the reentrant resolution monitor.
+      def drain
+        ResolutionSession.with do |session|
+          session.nested do
+            until @pending.empty?
+              session.consume!
+              drain_batch { |declaration| yield declaration }
+            end
+          end
+        end
+      end
+
+      private
+
+      def drain_batch
+        pending = @pending
+        @pending = []
+        pending.each_with_index do |declaration, index|
+          begin
+            yield declaration
+          rescue StandardError
+            @pending = pending.drop(index) + @pending
+            raise
+          end
+        end
+      end
+    end
+  end
+end

data/lib/view_component/atomix/dynamic_properties/literal_key.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+module ViewComponent
+  module Atomix
+    module DynamicProperties
+      module LiteralKey
+        module_function
+
+        def read(node)
+          return unless node.is_a?(Array)
+
+          case node.first
+          when :@label
+            node[1].delete_suffix(":")
+          when :symbol_literal
+            token = find_token(node, :@ident) || find_token(node, :@op) || find_token(node, :@kw)
+            token&.[](1)
+          when :string_literal, :dyna_symbol
+            decode_literal_string(node)
+          end
+        end
+
+        def decode_literal_string(node)
+          contents = node[1].drop(1)
+          return unless text_tokens?(contents)
+
+          quote = node[2] || '"'
+          quote = quote.delete_prefix(":") if quote.start_with?(":")
+          quote = quote.sub(/\A%s/, "%q")
+          literal = reconstruct_string(quote, contents)
+          return unless literal
+
+          # Reparse immediately before evaluating: only one text-only string is
+          # allowed. Interpolation, calls, and extra expressions cannot pass.
+          expressions = Ripper.sexp(literal)&.[](1)
+          return unless expressions&.one? && expressions.first.first == :string_literal
+          return unless text_tokens?(expressions.first[1].drop(1))
+
+          eval(literal, TOPLEVEL_BINDING, __FILE__, __LINE__) # rubocop:disable Security/Eval
+        end
+
+        def reconstruct_string(quote, contents)
+          return unless ["'", '"'].include?(quote) || quote.match?(/\A%(?:q|Q)?.\z/)
+
+          closing = { "(" => ")", "[" => "]", "{" => "}", "<" => ">" }.fetch(quote[-1], quote[-1])
+          quote + contents.map { |part| part[1] }.join + closing
+        end
+
+        def text_tokens?(contents)
+          contents.all? { |part| part.first == :@tstring_content }
+        end
+
+        def find_token(node, type)
+          return node if node.is_a?(Array) && node.first == type
+          return unless node.is_a?(Array)
+
+          node.each do |child|
+            found = find_token(child, type)
+            return found if found
+          end
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/view_component/atomix/dynamic_properties/source_cache.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Atomix
+    module DynamicProperties
+      class SourceCache
+        LIMIT = 128
+
+        def initialize
+          @cache = {}
+          @mutex = Mutex.new
+        end
+
+        def fetch(path)
+          stat = File.stat(path)
+          cache_key = [stat.mtime.to_f, stat.size]
+          @mutex.synchronize do
+            cached = @cache[path]
+            return cached.last if cached&.first == cache_key
+
+            parser = SourceParser.new(File.read(path), path)
+            parsed = parser.parse && parser.lambdas
+            @cache.shift if !@cache.key?(path) && @cache.size >= LIMIT
+            @cache[path] = [cache_key, parsed]
+            parsed
+          end
+        end
+      end
+    end
+  end
+end

data/lib/view_component/atomix/dynamic_properties/source_parser.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+module ViewComponent
+  module Atomix
+    module DynamicProperties
+      # Associate each lambda with its opening token while parsing, before
+      # modifier expressions can reorder nodes in the resulting syntax tree.
+      class SourceParser < Ripper::SexpBuilderPP
+        attr_reader :lambdas
+
+        def initialize(*)
+          super
+          @lambda_lines = []
+          @lambdas = {}
+          @string_quotes = []
+        end
+
+        def on_heredoc_beg(token)
+          @string_quotes << token
+          super
+        end
+
+        def on_tstring_beg(token)
+          @string_quotes << token
+          super
+        end
+
+        def on_symbeg(token)
+          # Bare symbols have no string body; quoted and percent symbols do.
+          @string_quotes << token unless token == ":"
+          super
+        end
+
+        def on_dyna_symbol(content)
+          node = super
+          node << @string_quotes.pop
+          node
+        end
+
+        def on_string_literal(content)
+          node = super
+          node << @string_quotes.pop
+          node
+        end
+
+        def on_tlambda(token)
+          @lambda_lines << lineno
+          super
+        end
+
+        def on_lambda(params, body)
+          node = super
+          (@lambdas[@lambda_lines.pop] ||= []) << node
+          node
+        end
+      end
+    end
+  end
+end

data/lib/view_component/atomix/dynamic_properties.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "dynamic_properties/source_parser"
+require_relative "dynamic_properties/source_cache"
+require_relative "dynamic_properties/literal_key"
+
+module ViewComponent
+  module Atomix
+    module DynamicProperties
+      class Unsupported < ArgumentError; end
+
+      SOURCE_CACHE = SourceCache.new
+
+      module_function
+
+      def extract(fn, name:, set:)
+        path, line = fn.source_location
+        raise unsupported(name, set, "source is unavailable") unless path && File.file?(path)
+
+        lambdas = SOURCE_CACHE.fetch(path)
+        raise unsupported(name, set, "source could not be parsed") unless lambdas
+
+        candidates = lambdas.fetch(line, [])
+        if candidates.length != 1
+          detail = candidates.empty? ? "lambda could not be located at #{path}:#{line}" :
+                                      "multiple lambdas start at #{path}:#{line}; put each on its own line"
+          raise unsupported(name, set, detail)
+        end
+
+        properties_from(candidates.first, name, set)
+      rescue Errno::ENOENT, Errno::EACCES => e
+        raise unsupported(name, set, e.message)
+      end
+
+      def properties_from(lambda_node, name, set)
+        body = returned_hash(lambda_node, name, set)
+        hash_associations(body).map do |association|
+          unless association.is_a?(Array) && association.first == :assoc_new
+            raise unsupported(name, set, "hash splats and computed entries are not supported")
+          end
+
+          LiteralKey.read(association[1]) ||
+            raise(unsupported(name, set, "every property key must be a literal label, Symbol, or String"))
+        end.map { |key| Property.normalize_key(key) }.uniq.freeze
+      end
+
+      def returned_hash(lambda_node, name, set)
+        statements = lambda_node[2]
+        statements = statements[1] if statements&.first == :bodystmt
+        meaningful = Array(statements).reject { |node| node.is_a?(Array) && node.first == :void_stmt }
+        body = meaningful.one? ? meaningful.first : nil
+        body = body[1] if body&.first == :paren
+
+        unless body&.first == :hash
+          raise unsupported(name, set, "lambda must return one literal Hash")
+        end
+
+        body
+      end
+
+      def hash_associations(hash_node)
+        # Ripper represents a hash as [:hash, [:assoclist_from_args, entries]].
+        hash_node.dig(1, 1) || []
+      end
+
+      def unsupported(name, set, detail)
+        Unsupported.new(
+          "Dynamic trait #{name}.#{set} cannot be compiled: #{detail}. " \
+          "Return one literal Hash with static property keys, or declare " \
+          "`trait :#{set}, dynamic: %i[...], using: -> { ... }`."
+        )
+      end
+    end
+  end
+end

data/lib/view_component/atomix/dynamic_style.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Atomix
+    class DynamicStyle
+      attr_reader :name, :set
+
+      def initialize(name:, set:, fn:, properties: nil)
+        @name = Immutable.copy(name)
+        @set = Immutable.copy(set)
+        @fn = fn
+        @required_arguments = fn.parameters.any? { |kind, _| kind == :req || kind == :keyreq }
+        @vars = {}
+        @mutex = Mutex.new
+        @declared_properties = normalize_properties(properties)
+        @compiled_properties = @declared_properties
+        compile! if Atomix.config.inline?
+        Atomix.registry.after_commit { Atomix.dynamic_styles << self }
+      end
+
+      def source_path
+        @fn.source_location&.first
+      end
+
+      def arity
+        @fn.arity
+      end
+
+      def call(*args, **kwargs)
+        return Style::EMPTY if args.empty? && kwargs.empty? && required_arguments?
+        result = @fn.call(*args, **kwargs)
+        unless result.is_a?(Hash)
+          raise ArgumentError, "Dynamic trait #{set.inspect} must return a Hash, got #{result.class}"
+        end
+
+        classes = {}
+        inline = {}
+        result.each do |key, value|
+          property = Property.normalize_key(key)
+          if @compiled_properties && !@compiled_properties.include?(property)
+            raise ArgumentError,
+                  "Dynamic trait #{name}.#{set} returned undeclared property #{property.inspect}. " \
+                  "Compiled properties: #{@compiled_properties.inspect}"
+          end
+          if value.nil? || value == false
+            classes[property] = nil
+            next
+          end
+
+          if value.is_a?(Hash)
+            raise ArgumentError,
+                  "Dynamic trait #{name}.#{set} cannot use conditions for #{property.inspect}. " \
+                  "Declare conditions in a static trait referencing a CSS variable instead."
+          end
+
+          if value.is_a?(Array)
+            raise ArgumentError,
+                  "Dynamic trait #{name}.#{set} cannot use an Array for #{property.inspect}. " \
+                  "Declare fallback arrays in a static trait; dynamic values must be single CSS values."
+          end
+
+          var, class_name = identifiers(property)
+          classes[property] = [class_name]
+          inline[var] = Property.normalize_value(property, value)
+        end
+        Style.new(classes, inline)
+      end
+
+      def compile!
+        @mutex.synchronize do
+          @compiled_properties ||= DynamicProperties.extract(@fn, name: name, set: set)
+        end
+        Atomix.registry.with_source(@fn.source_location&.first) do
+          @compiled_properties.each { |property| ensure_registered(property) }
+        end
+        self
+      end
+
+      private
+
+      def required_arguments?
+        @required_arguments
+      end
+
+      def normalize_properties(properties)
+        return unless properties
+
+        Immutable.copy(properties.map { |property| Property.normalize_key(property) }.uniq)
+      end
+
+      def identifiers(property)
+        @mutex.synchronize { @vars[property] ||= build_identifiers(property) }
+      end
+
+      def ensure_registered(property)
+        var, class_name = identifiers(property)
+        Atomix.registry.add(
+          Rule.new(selector: ".#{class_name}", property: property, value: "var(#{var})")
+        )
+      end
+
+      def build_identifiers(property)
+        var = Hashing.var_name(name, set, property)
+        value = "var(#{var})"
+        [var, Hashing.class_name(property, value)].freeze
+      end
+    end
+  end
+end

data/lib/view_component/atomix/enumerated_style.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Atomix
+    class EnumeratedStyle
+      attr_reader :name, :members, :default
+
+      def initialize(name:, members:, default: nil)
+        @name = Immutable.copy(name)
+        @members = Immutable.copy(members)
+        @default = Immutable.copy(default)
+        freeze
+      end
+
+      def call(value = nil)
+        value = default if value.nil? || value == false
+        return Style::EMPTY if value.nil?
+
+        unless value.respond_to?(:to_sym)
+          raise KeyError, "Unknown member #{value.inspect} for trait #{name.inspect}. Available: #{members.keys.inspect}"
+        end
+
+        key = value.to_sym
+        return members[key] if members.key?(key)
+
+        raise KeyError, "Unknown member #{value.inspect} for trait #{name.inspect}. Available: #{members.keys.inspect}"
+      end
+      alias [] call
+
+      def member_names
+        members.keys
+      end
+
+      def empty?
+        members.empty?
+      end
+    end
+  end
+end

data/lib/view_component/atomix/hashing.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "digest/sha1"
+
+module ViewComponent
+  module Atomix
+    module Hashing
+      # Twelve base-36 characters retain roughly 62 bits of SHA1. This keeps
+      # selectors compact while making collisions impractical for application
+      # sized stylesheets.
+      LENGTH = 12
+
+      module_function
+
+      def digest(*parts)
+        input = parts.map { |part| serialize(part) }.join
+        Digest::SHA1.hexdigest(input).to_i(16).to_s(36)[0, LENGTH]
+      end
+
+      def serialize(value)
+        case value
+        when Array
+          encoded = value.map { |item| serialize(item) }.join
+          "a#{value.length}:#{encoded.bytesize}:#{encoded}"
+        when Symbol
+          serialize_scalar("y", value.to_s)
+        when nil
+          "n"
+        else
+          serialize_scalar("s", value.to_s)
+        end
+      end
+
+      def serialize_scalar(type, value)
+        "#{type}#{value.bytesize}:#{value}"
+      end
+
+      def class_name(property, value, conditions = [])
+        "#{Atomix.config.class_prefix}#{digest(property, value, *conditions)}"
+      end
+
+      def var_name(*parts)
+        "--#{Atomix.config.class_prefix}#{digest(*parts)}"
+      end
+    end
+  end
+end

data/lib/view_component/atomix/helper.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Atomix
+    module Helper
+      include AttributeHelpers
+
+      def view_component_atomix_tag(**options)
+        config = ViewComponent::Atomix.config
+        options[:nonce] = content_security_policy_nonce if options[:nonce] == true
+
+        if config.inline?
+          css = ViewComponent::Atomix.registry.to_css
+          css = css.gsub("</", "<\\/") if css.include?("</")
+          content_tag(:style, css.html_safe, { "data-view-component-atomix": "true" }.merge(options))
+        else
+          stylesheet_link_tag(stylesheet_logical_path(config.output_path),
+                              { "data-turbo-track": "reload" }.merge(options))
+        end
+      end
+
+      private
+
+      def stylesheet_logical_path(output_path)
+        path = output_path.to_s.delete_suffix(".css")
+        path = path.delete_prefix("#{Rails.root}/") if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+        path.sub(%r{\Aapp/assets/(?:builds|stylesheets)/}, "")
+      end
+    end
+  end
+end

data/lib/view_component/atomix/immutable.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Atomix
+    # Value objects own their containers and strings. Domain objects stored in
+    # sheets (including callable dynamic styles) retain their own lifecycle.
+    module Immutable
+      module_function
+
+      def copy(value)
+        case value
+        when Hash then value.to_h { |key, item| [copy(key), copy(item)] }.freeze
+        when Array then value.map { |item| copy(item) }.freeze
+        when String then value.frozen? ? value : value.dup.freeze
+        else value
+        end
+      end
+    end
+  end
+end