compex 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a05ce5e69574029faf2e79599fa9da036407cc795dbdbb0cdf1b61bee7207fa9
-  data.tar.gz: 2aafbe674927a37b3be6765eadb1728e034f0ccc5eb320c46c81cf67291d9e78
+  metadata.gz: 4b7cf8ba1fdb3025ced5fbd9ac131254f434f8c5b0fb9051db7ad99ecebbcff5
+  data.tar.gz: 5c999e47eecd15154c8bf51bf537fb579f970d73c19b3649e5f2e0752b195f53
 SHA512:
-  metadata.gz: c0b66d2086af516eff2747260fcde3d41442b9efac231b2f91d841f46e1022a1307ca0c3263a5eed4eba6ac94397cbaf73b404caeb346afd301ec2aa6d375321
-  data.tar.gz: ac8a634d182846d66e175a6fe99fced4ee9f9d0caf8500fe0ae0e6b077175690cff1cc5e6d9b97346d368b779db6a172176ad825ba0c7f7a98a7de051f4a898b
+  metadata.gz: 4282c8050c62201e2171969458e13facac1d9e8a02fe376531a671ddecefdd14a8c1d2a4137e9a9ae129fc5ce4b4dbfc5453b57a8f0af05ab4ac90eb67e2ebf5
+  data.tar.gz: 59055e79cc4caae458af50b83c296e959c3700b8c8538750494adc6dd9e8cd02b2cbab72dcbac5b0735456bca2e922aa4a8af2e52db3481fb7f5ea7a21232fee

data/lib/compex/asset_provider.rb

@@ -2,21 +2,18 @@
 
 module CompEx
   class AssetProvider
-    def self.provide(hashed)
-      return nil if !hashed.is_a?(String) || hashed.length < 2
-
-      case hashed[0]
-      when "j"
-        script = Cache.get_hashed_script(hashed[2...])
-        return nil unless script
+    def self.register(hash, value)
+      @assets ||= {}
+      CompEx::Cache.cache_asset(hash, value)
+      @assets[hash] = value
+    end
 
-        script[1]
-      when "c"
-        style = Cache.get_hashed_style(hashed[2...])
-        return nil unless style
+    def self.reset_cache!
+      @assets = {}
+    end
 
-        style[1]
-      end
+    def self.provide(hashed)
+      @assets[hashed] ||= CompEx::Cache.get_asset(hashed)
     end
   end
 end

data/lib/compex/bag.rb

@@ -3,7 +3,7 @@
 module CompEx
   class Bag
     def initialize(parent, **args)
-      parent.defined_args.each do |arg|
+      parent.args.each do |arg|
         next unless args.key? arg
 
         define_singleton_method(arg) { args[arg] }
@@ -12,8 +12,9 @@ module CompEx
       @_extra_js_hashes = []
     end
 
-    def extra_css_hashes = @_extra_css_hashes
-    def extra_js_hashes = @_extra_js_hashes
+    def required_hashes
+      [@_extra_css_hashes, @_extra_js_hashes].compact.flatten
+    end
 
     def render(klass, **args)
       inst = klass.new(**args)

data/lib/compex/base.rb

@@ -2,7 +2,14 @@
 
 module CompEx
   class Base
+    using CompEx::StringRefinements
+    using CompEx::ClassRefinements
+
     class << self
+      def descriptor
+        @descriptor ||= ComponentDescriptor.new(self)
+      end
+
       def args(first, *rest)
         [first, *rest].each { arg(it) }
         self
@@ -15,8 +22,7 @@ module CompEx
         define_method("#{name}=") do |value|
           instance_variable_set(var_name, UnsafeString.new(value))
         end
-        @args ||= []
-        @args << name
+        descriptor.args.add(name)
 
         return self if rest.empty?
 
@@ -26,131 +32,61 @@ module CompEx
       end
 
       def expose(first, *rest)
-        @exposed ||= []
-        @exposed << first
-        @exposed.append(*rest)
-        @exposed.uniq!
+        descriptor.exposed.add(first, *rest)
         nil
       end
 
       def html(source)
-        @html = source
+        descriptor.raw_html = source
         self
       end
 
       def style(source)
-        @style = source
+        descriptor.raw_style = source
         self
       end
 
       def js(source)
-        @js = source
+        descriptor.raw_js = source
         self
       end
 
-      def raw_component_id
-        @raw_component_id ||= name || hash.to_s(36)
-      end
-
-      def component_id
-        @component_id ||= hash_string(raw_component_id)
-      end
-
       def js_class_id
         return @js_class_id if @js_class_id
 
         class_id = name.split("::").map do |id|
           next id unless id.start_with? "#"
 
-          hash_string(id)
+          id.hashed
         end.join
         @js_class_id ||= ["CompEx_", class_id, "_", component_id.upcase].join
       end
 
-      def hash_string(str)
-        value = 2906
-        str.chars.map(&:ord).each do |v|
-          value = (value * 33) ^ v
-        end
-
-        (value & 0xFFFFFFFF).to_s(36)
-      end
-
       def inherited(subclass)
         super
         CompEx::ComponentRegistry.register(subclass)
       end
-
-      def stable_class_id(klass)
-        klass.name || Digest::SHA256.hexdigest(klass.inspect)
-      end
-
-      def defined_args
-        @args || []
-      end
-    end
-
-    using CompEx::StringRefinements
-
-    def html
-      @html ||= Cache.html(self.class) do
-        Template.parse(self.class.instance_variable_get(:@html) || find_template, self.class)
-      end
-    end
-
-    def style
-      self.class.instance_variable_get(:@style) || find_style
     end
 
-    attr_reader :css, :css_hash, :js_hash, :js
+    def descriptor = self.class.descriptor
 
     def initialize(**args)
-      @bag = Bag.new(self, **args)
+      @bag = Bag.new(descriptor, **args)
       @extra_hashes = []
-
-      initialize_css
-      initialize_js
     end
 
-    def exposed = self.class.instance_variable_get(:@exposed) || []
+    def exposed = self.class.descriptor.exposed
 
-    def initialize_css
-      css_id, css_source, css_hash = Cache.style(self.class) do
-        id, css = Style.compile(self, html.root_classes)
-        # Keeping define_css_prefix here, so we only define it once.
-        html.define_css_prefix(id)
-        css_hash = Digest::SHA1.hexdigest(css)
-        [id, css, "c_#{css_hash}"]
-      end
-      @css_id = css_id
-      @css = css_source
-      @css_hash = css_hash
-    end
-
-    def initialize_js
-      js = self.class.instance_variable_get(:@js) || find_js
-      return unless js
-
-      hash, src = Cache.script(self.class) do
-        js_hash = Digest::SHA1.hexdigest(js)
-        # Keeping define_js_module here, so we only define it once.
-        html.define_js_module(self.class.js_class_id)
-        ["j_#{js_hash}", JSRewriter.rewrite(self.class, js)]
-      end
-      @js = src
-      @js_hash = hash
-    end
-
-    def defined_args = self.class.defined_args
+    def defined_args = self.class.descriptor.args
 
-    def render_html
-      html.render do |v|
+    def render_html(children: nil)
+      self.class.descriptor.html.render do |v|
         case v
+        when :slot
+          children
         when Hash
           inst = v[:component].new(**v[:args])
-          ret = inst.render_html do
-            v[:children]
-          end
+          ret = inst.render_html(children: v[:children])
           @extra_hashes << inst.required_hashes
           ret
 
@@ -163,57 +99,10 @@ module CompEx
     end
 
     def required_hashes
-      [@css_hash, @js_hash, @bag.extra_css_hashes, @bag.extra_js_hashes, @extra_hashes]
+      [descriptor.required_hashes, @bag.required_hashes, @extra_hashes]
         .flatten
         .compact
         .uniq
     end
-
-    def component_name
-      return nil if self.class.name.nil?
-
-      @component_name ||= self.class.name.split("::").map do |item|
-        next item if item[0] == "#"
-
-        item.underscore
-      end.join("/")
-    end
-
-    private
-
-    def find_template
-      path = CompEx.config.lookup_template(self, :html)
-      begin
-        File.read(path)
-      rescue Errno::ENOENT
-        raise "No template defined by #{self.class.name} (through ::html), nor could be found at #{path}"
-      end
-    end
-
-    def find_style
-      cname = component_name
-      return nil unless cname
-
-      path = CompEx.config.lookup_template(self, :style)
-      begin
-        style = File.read(path)
-      rescue Errno::ENOENT
-        return nil
-      end
-
-      Style.compile(style)
-    end
-
-    def find_js
-      cname = component_name
-      return nil unless cname
-
-      path = CompEx.config.lookup_template(self, :js)
-      begin
-        File.read(path)
-      rescue Errno::ENOENT
-        nil
-      end
-    end
   end
 end

data/lib/compex/cache/memory_backend.rb

@@ -2,16 +2,16 @@
 
 module CompEx
   class Cache
-    class MemoryBackend < Base
-      def prepare!(*, **)
-        @keys = {}
+    class MemoryBackend
+      def initialize
+        @cache = {}
       end
 
       def set(key, value)
-        @keys[prefix(key)] = value
+        @cache[key] = value
       end
 
-      def get(key) = @keys[prefix(key)]
+      def get(key) = @keys[key]
     end
   end
 end

data/lib/compex/cache.rb

@@ -1,73 +1,24 @@
 # frozen_string_literal: true
 
-require_relative "cache/base"
-require_relative "cache/memcached_backend"
 require_relative "cache/memory_backend"
-require_relative "cache/noop_backend"
-require_relative "cache/redis_backend"
 
 module CompEx
   class Cache
+    using ClassRefinements
+
     class << self
       def backend = CompEx.config.cache_backend
-      def stable_class_id(comp) = CompEx::Base.stable_class_id(comp)
-
-      def style(component_class)
-        stable_id = stable_class_id(component_class)
-        stable_key = "style:#{stable_id}"
-        v = backend.get(stable_key)
-        return JSON.parse(v, symbolize_names: true) if v
 
-        r = yield
-        backend.set("style:#{r.last[2...]}", stable_id)
-        backend.set(stable_key, r.to_json)
-
-        r
+      def cache_asset(key, value)
+        backend.set(prefix(key), value)
       end
 
-      def get_hashed_style(hashed)
-        ptr = backend.get("style:#{hashed}")
-        return nil unless ptr
-
-        v = backend.get("style:#{ptr}")
-        return nil unless v
-
-        JSON.parse(v, symbolize_names: true)
+      def get_asset(key)
+        backend.get(prefix(key))
       end
 
-      def html(component_class)
-        stable_id = stable_class_id(component_class)
-        stable_key = "html:#{stable_id}"
-        v = backend.get(stable_key)
-        return v if v
-
-        html = yield
-        backend.set(stable_key, html)
-
-        html
-      end
-
-      def script(component_class)
-        stable_id = stable_class_id(component_class)
-        stable_key = "script:#{stable_id}"
-        v = backend.get(stable_key)
-        return JSON.parse(v, symbolize_names: true) if v
-
-        r = yield
-        backend.set(stable_key, r.to_json)
-        backend.set("script:#{r.first[2...]}", stable_id)
-
-        r
-      end
-
-      def get_hashed_script(hashed)
-        ptr = backend.get("script:#{hashed}")
-        return nil unless ptr
-
-        v = backend.get("script:#{ptr}")
-        return nil unless v
-
-        JSON.parse(v, symbolize_names: true)
+      def prefix(key)
+        "#{CompEx.config.cache_prefix}#{key}"
       end
     end
   end

data/lib/compex/component_descriptor.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module CompEx
+  class ComponentDescriptor
+    using CompEx::ClassRefinements
+    using CompEx::StringRefinements
+
+    attr_accessor :raw_style
+    attr_reader :args, :exposed, :css, :css_hash, :css_prefix
+    attr_writer :raw_html, :raw_js
+
+    def initialize(parent)
+      @parent = parent
+      @args = Set.new
+      @exposed = Set.new
+      @css_prefix = "cx_#{@parent.component_id}"
+    end
+
+    def html
+      prepare!
+      @html
+    end
+
+    def has_js? = !@js.nil?
+    def has_style? = !@css.nil?
+
+    def prepare!
+      return if @prepared
+
+      # prime cached templates
+      js_template
+      css_template
+
+      prepare_html
+      prepare_js
+      prepare_css
+      update_html_attrs
+
+      @prepared = true
+    end
+
+    def required_hashes
+      [@css_hash, @js_hash].compact
+    end
+
+    def js_class_id
+      return @js_class_id if @js_class_id
+
+      id = @parent.name.split("::")
+        .reject { it.start_with?("#") }
+        .map(&:hashed).join
+      @js_class_id = "CompEx_#{id}_#{@parent.component_id.upcase}"
+    end
+
+    def dynamically_defined?
+      @dynamically_defined ||= @parent.name.include?("#")
+    end
+
+    private
+
+    def find_template(kind)
+      if kind == :html && dynamically_defined?
+        # This is an error already. #find should only be called in case
+        # raw_html isn't called. Bail early.
+        raise MissingTemplateError, @parent
+      end
+
+      path = CompEx.config.lookup_template(@parent, kind)
+      if path.nil?
+        raise MissingTemplateError, @parent if kind == :html
+
+        return nil
+      end
+
+      begin
+        File.read(path)
+      rescue Errno::ENOENT
+        return nil unless kind == :html
+
+        raise MissingTemplateError, @parent
+      end
+    end
+
+    def prepare_js
+      return unless @js_template
+
+      js_hash = Digest::SHA1.hexdigest(@js_template)
+      @js = JSRewriter.rewrite(@parent, @js_template)
+      @js_hash = "j_#{js_hash}"
+      CompEx::AssetProvider.register(@js_hash, @js)
+    end
+
+    def prepare_html
+      @html_template ||= @raw_html || find_template(:html)
+      @html = Template.parse(@html_template, @parent)
+    end
+
+    def prepare_css
+      return unless css_template
+
+      @css = Style.compile(@parent, css_template, @html.root_classes)
+      @css_hash = "c_#{Digest::SHA1.hexdigest(@css)}"
+      CompEx::AssetProvider.register(@css_hash, @css)
+    end
+
+    def update_html_attrs
+      @html.define_css_prefix(css_prefix) if @css
+      @html.define_js_module(js_class_id) if @js
+    end
+
+    def js_template
+      @js_template ||= @raw_js || find_template(:js)
+    end
+
+    def css_template
+      @css_template ||= @raw_style || find_template(:style)
+    end
+  end
+end

data/lib/compex/component_registry.rb

@@ -2,6 +2,8 @@
 
 module CompEx
   class ComponentRegistry
+    using ClassRefinements
+
     Node = Struct.new(:name, :children, :component) do
       def initialize(*)
         super
@@ -12,11 +14,16 @@ module CompEx
     class << self
       attr_reader :components, :tree
 
+      def flush!
+        @components = {}
+        @tree = Struct.new(:children).new(children: [])
+      end
+
       def register(component)
         @components ||= {}
         @tree ||= Struct.new(:children).new(children: [])
 
-        stable_id = CompEx::Base.stable_class_id(component)
+        stable_id = component.stable_class_id
         @components[stable_id] = component
 
         names = stable_id.split("::")
@@ -47,6 +54,7 @@ module CompEx
       end
 
       def resolve(name, context: nil)
+        puts "resolve #{name}, #{context.inspect}"
         return nil if name.nil? || name.empty?
 
         # Normalize
@@ -76,6 +84,44 @@ module CompEx
         node = find_by_path(path, @tree)
         node&.component
       end
+
+      def walk(base, &)
+        base.children.each do |v|
+          if v.respond_to?(:component) && !v.component.nil?
+            yield v.component.descriptor
+          end
+
+          walk(v, &) if v.children && v.children.length > 0
+        end
+      end
+
+      def gather_scripts
+        scripts = []
+        walk(@tree) do |comp|
+          next unless comp.has_js?
+          scripts << {
+            component: comp,
+            source: comp.js,
+            hash: comp.js_hash
+          }
+        end
+
+        scripts
+      end
+
+      def gather_styles
+        styles = []
+        walk(@tree) do |comp|
+          next unless comp.has_style?
+          styles << {
+            component: comp,
+            source: comp.css,
+            hash: comp.css_hash
+          }
+        end
+
+        styles
+      end
     end
   end
 end

data/lib/compex/config.rb

@@ -16,56 +16,45 @@ module CompEx
   def config = configure
 
   class Config
-    attr_accessor :on_multiple_root, :multiple_root_wrap_element,
-                  :on_non_element, :cache_args, :cache_kwargs, :cache_prefix,
-                  :template_search_path, :js_search_path, :style_search_path
-    attr_reader :cache_mode, :cache_backend
+    using CompEx::ClassRefinements
 
-    CACHE_MODES = {
-      memcached: Cache::MemcachedBackend,
-      redis: Cache::RedisBackend,
-      memory: Cache::MemoryBackend,
-      disabled: Cache::NoopBackend
-    }.freeze
+    attr_accessor :on_multiple_root, :multiple_root_wrap_element,
+                  :on_non_element, :template_search_path, :js_search_path,
+                  :style_search_path, :cache_backend, :cache_prefix
 
     def initialize
       @on_multiple_root = :wrap
       @multiple_root_wrap_element = "div"
       @on_non_element = :wrap
-      self.cache_mode = :memory
+      self.cache_backend = Cache::MemoryBackend.new
+      self.cache_prefix = "compex.cache"
 
-      return unless defined?(Rails)
+      return unless defined?(::Rails)
 
-      root_path = File.join(Rails.root, "app", "views", "components")
+      root_path = File.join(::Rails.root, "app", "views", "components")
       @template_search_path = root_path
       @style_search_path = root_path
       @js_search_path = root_path
     end
 
-    def cache_mode=(value)
-      value = value.to_sym if value.is_a? String
-      raise ArgumentError, "Unknown cache mode #{value}, valid options are #{CACHE_MODES.keys.map(&:to_s).join(", ")}" unless CACHE_MODES.key? value
-
-      @cache_backend = CACHE_MODES[value].new
-      @cache_backend.prepare!(*cache_args, **cache_kwargs)
-    end
-
     def lookup_template(component, type)
       @lookup_cache ||= {}
       lookup_key = [component, type]
       return @lookup_cache[lookup_key] if @lookup_cache.key? lookup_key
 
-      cname = component.component_name
-      raise MissingTemplate, "No template defined by anonymous class #{self.class} (through ::#{type})" if type == :html && !cname
+      dynamically_defined = component.descriptor.dynamically_defined?
+      raise MissingTemplateError, "No template defined by anonymous class #{self.class} (through ::#{type})" if dynamically_defined && type == :html
 
       # Anonymous classes can't be looked up since we can't define its path
-      unless cname
+      if dynamically_defined
         @lookup_cache[lookup_key] = nil
         return nil
       end
 
+      cname = component.name
+
       ret = case type
-      when :template
+      when :html
         File.join(@template_search_path || "", "#{cname}.html.crb")
       when :style
         File.join(@style_search_path || "", "#{cname}.css")

data/lib/compex/js_rewriter.rb

@@ -5,7 +5,7 @@ module CompEx
     def self.rewrite(component, raw_js)
       return nil unless raw_js
 
-      class_name = component.js_class_id
+      class_name = component.descriptor.js_class_id
       source = raw_js.strip.gsub(/\Aclass\s+[^\s]+\s*{/, "").gsub(/}\z/, "")
       <<~JS
         ((Runtime, Component) => {

data/lib/compex/refinements/class_refinements.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CompEx
+  module ClassRefinements
+    refine Class do
+      using CompEx::StringRefinements
+
+      def stable_class_id
+        @stable_class_id ||= name || Digest::SHA256.hexdigest(inspect)
+      end
+
+      def raw_component_id
+        @raw_component_id ||= name || hash.to_s(36)
+      end
+
+      def component_id
+        @component_id ||= raw_component_id.hashed
+      end
+    end
+  end
+end

data/lib/compex/{string_refinements.rb → refinements/string_refinements.rb}

@@ -10,6 +10,15 @@ module CompEx
           .tr("-", "_")
           .downcase
       end
+
+      def hashed
+        value = 2906
+        chars.map(&:ord).each do |v|
+          value = (value * 33) ^ v
+        end
+
+        (value & 0xFFFFFFFF).to_s(36)
+      end
     end
   end
 end

data/lib/compex/style.rb

@@ -2,35 +2,20 @@
 
 module CompEx
   class Style
-    def self.compile(component_class, root_classes = nil)
-      [
-        component_prefix(component_class),
-        new(component_class, root_classes).compile
-      ]
-    end
-
-    def self.component_prefix(component) = "cx_#{hash_string(comp_id(component))}"
-
-    def self.comp_id(comp) = comp.class.name || comp.class.hash.to_s(36)
+    using CompEx::StringRefinements
+    using CompEx::ClassRefinements
 
-    def self.hash_string(str)
-      value = 2906
-      str.chars.map(&:ord).each do |v|
-        value = (value * 33) ^ v
-      end
-
-      (value & 0xFFFFFFFF).to_s(36)
+    def self.compile(component_class, source, root_classes = nil)
+      new(component_class, source, root_classes).compile
     end
 
-    def initialize(klass, root_classes = nil)
-      @comp = klass
-      @style = klass.style
+    def initialize(klass, source, root_classes = nil)
+      @style = source
       @ast = MiniCSS.parse(@style)
       @root_classes = root_classes || []
+      @component_prefix = klass.descriptor.css_prefix
     end
 
-    def id_for_component = self.class.component_prefix(@comp)
-
     def compile
       @ast.each do |v|
         case v
@@ -61,28 +46,33 @@ module CompEx
         {
           type: :complex,
           combinator: @root_classes.include?(sel[:content].gsub(/^\./, "")) ? "" : " ",
-          left: { type: :class, content: ".#{id_for_component}" },
+          left: { type: :class, content: ".#{@component_prefix}" },
           right: sel
         }
+
       when :type, :attribute, :universal, :id
         {
           type: :complex,
           combinator: " ",
-          left: { type: :class, content: ".#{id_for_component}" },
+          left: { type: :class, content: ".#{@component_prefix}" },
           right: sel
         }
+
       when :list
         sel.tap do |s|
           s[:list].map! { prefix_selector(it) }
         end
+
       when :complex
         sel.tap do |s|
           s[:left] = prefix_selector(s[:left])
         end
+
       when :compound
         sel.tap do |s|
           s[:list][0] = prefix_selector(s[:list].first)
         end
+
       else
         raise "Unexpected selector type #{sel[:type]}"
       end

data/lib/compex/template/assembler.rb

@@ -102,9 +102,10 @@ module CompEx
 
         when MiniHTML::AST::Executable
           push_literal
-          id = @embedding_id
+          id = "__cx_embedding_quoted_#{@context_id}_#{@embedding_id}__"
           @embedding_id += 1
-          @result << { kind: :executable, id: "__cx_embedding_quoted_#{@context_id}_#{id}__", source: at.value.source }
+          @embeddings[id] = at.value.source
+          @result << { kind: :executable, id: id, source: at.value.source }
 
         when MiniHTML::AST::Interpolation
           assemble_interpolation(at.value)
@@ -135,9 +136,10 @@ module CompEx
             @literal << v.literal
           when MiniHTML::AST::Executable
             push_literal
-            id = @embedding_id
+            id = "__cx_embedding_#{@context_id}_#{@embedding_id}__"
             @embedding_id += 1
-            @result << { kind: :executable, id: "__cx_embedding_#{@context_id}_#{id}__", source: v.source }
+            @embeddings[id] = v.source
+            @result << { kind: :executable, id: id, source: v.source }
           end
         end
 

data/lib/compex/template/renderer.rb

@@ -3,6 +3,8 @@
 module CompEx
   class Template
     class Renderer
+      using CompEx::ClassRefinements
+
       # The following attributes will have their values merged when we
       # find the same tag already defined by an embedded component
       MERGEABLE_ATTRIBUTES = Set.new(%w[class])
@@ -61,7 +63,7 @@ module CompEx
           c_node = CompEx::ComponentRegistry.resolve(inner_name, context: @context)
           next unless c_node
 
-          args = c_node.defined_args.map(&:to_s)
+          args = c_node.descriptor.args.map(&:to_s)
           component_props = node.attributes.slice(*args)
           component_props.each_key { node.remove_attribute(it) }
           child = node.children
@@ -121,13 +123,22 @@ module CompEx
           embed.replace(result)
         end
 
+        slot = dom.at_css("slot")
+
+        # WARNING: The safe navigation operator below WILL PREVENT yield when
+        #          slot is nil.
+        slot&.replace((yield :slot) || "")
+
         dom.to_html
-          .gsub(/__cx_embedding_#{@context_id}_\d+__/) { process_embeddings(it, false, &) }
-          .gsub(/__cx_embedding_quoted_#{@context_id}_\d+__/) { process_embeddings(it, true, &) }
+          .gsub(/__cx_embedding_#{@context_id}_\d+__/) { process_embedding(it, false, &) }
+          .gsub(/__cx_embedding_quoted_#{@context_id}_\d+__/) { process_embedding(it, true, &) }
       end
 
-      def process_embeddings(key, quoted)
-        return key unless @embeddings.key? key
+      def process_embedding(key, quoted)
+        unless @embeddings.key? key
+          warn "[CompEx] BUG: Embedding not found: #{key} @ #{@context}"
+          return key
+        end
 
         ret = yield @embeddings[key]
         ret = ret.inspect if quoted

data/lib/compex/template.rb

@@ -5,6 +5,8 @@ require_relative "template/assembler"
 
 module CompEx
   class Template
+    using CompEx::ClassRefinements
+
     def self.parse(value, context)
       p = MiniHTML::Parser.new(value)
       ast = p.parse

data/lib/compex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CompEx
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/compex.rb

@@ -9,8 +9,10 @@ require "minicss"
 require "minihtml"
 
 require_relative "compex/version"
+require_relative "compex/refinements/string_refinements"
+require_relative "compex/refinements/class_refinements"
+require_relative "compex/component_descriptor"
 require_relative "compex/template"
-require_relative "compex/string_refinements"
 require_relative "compex/cache"
 require_relative "compex/style"
 require_relative "compex/bag"
@@ -33,6 +35,7 @@ module CompEx
     end
   end
 
+  class MissingTemplateError < Error; end
   class MultipleRootError < Error; end
   class NonElementRootError < Error; end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: compex
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Vito Sartori
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2025-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minicss
@@ -74,15 +74,13 @@ files:
 - lib/compex/bag.rb
 - lib/compex/base.rb
 - lib/compex/cache.rb
-- lib/compex/cache/base.rb
-- lib/compex/cache/memcached_backend.rb
 - lib/compex/cache/memory_backend.rb
-- lib/compex/cache/noop_backend.rb
-- lib/compex/cache/redis_backend.rb
+- lib/compex/component_descriptor.rb
 - lib/compex/component_registry.rb
 - lib/compex/config.rb
 - lib/compex/js_rewriter.rb
-- lib/compex/string_refinements.rb
+- lib/compex/refinements/class_refinements.rb
+- lib/compex/refinements/string_refinements.rb
 - lib/compex/style.rb
 - lib/compex/template.rb
 - lib/compex/template/assembler.rb
@@ -110,7 +108,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.2
 specification_version: 4
 summary: View Component Extensions for Ruby
 test_files: []

data/lib/compex/cache/base.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module CompEx
-  class Cache
-    class Base
-      def prepare!(*, **) = nil
-      def prefix(key) = "#{CompEx.config.cache_prefix}#{key}"
-    end
-  end
-end

data/lib/compex/cache/memcached_backend.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module CompEx
-  class Cache
-    class MemcachedBackend
-      def prepare!(*, **)
-        begin
-          require "memcached"
-        rescue LoadError
-          raise "CompEx: Memcached cache mode requires the gem 'memcached' to be installed."
-        end
-        @instance = Memcached::Client.new(*, **)
-      end
-
-      def set(key, value) = @instance.set(prefix(key), value)
-      def get(key) = @instance.get(prefix(key))
-    end
-  end
-end

data/lib/compex/cache/noop_backend.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module CompEx
-  class Cache
-    class NoopBackend < Base
-      def get(*) = nil
-      def set(*) = nil
-    end
-  end
-end

data/lib/compex/cache/redis_backend.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module CompEx
-  class Cache
-    class RedisBackend < Base
-      def prepare!(*, **)
-        begin
-          require "redis"
-        rescue LoadError
-          raise "CompEx: Redis cache mode requires the gem 'redis' to be installed."
-        end
-        @instance = Redis.new(*, **)
-      end
-
-      def set(key, value) = @instance.set(prefix(key), value)
-      def get(key) = @instance.get(prefix(key))
-    end
-  end
-end