compex 0.1.1

data/lib/compex/component_registry.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module CompEx
+  class ComponentRegistry
+    Node = Struct.new(:name, :children, :component) do
+      def initialize(*)
+        super
+        self.children ||= []
+      end
+    end
+
+    class << self
+      attr_reader :components, :tree
+
+      def register(component)
+        @components ||= {}
+        @tree ||= Struct.new(:children).new(children: [])
+
+        stable_id = CompEx::Base.stable_class_id(component)
+        @components[stable_id] = component
+
+        names = stable_id.split("::")
+        node = @tree
+        until names.empty?
+          name = names.shift
+          target = node.children.find { it.name == name }
+          unless target
+            target = Node.new(name)
+            node.children << target
+          end
+          if names.empty?
+            warn "[CompEx] Component name collision: #{component.name} vs #{target.component.name}" if target.component
+            target.component = component
+          end
+          node = target
+        end
+      end
+
+      def find_by_path(path, base = nil)
+        base ||= @tree
+        return base if path.empty?
+
+        ret = base.children.find { it.name == path.first }
+        return nil unless ret
+
+        find_by_path(path[1...], ret)
+      end
+
+      def resolve(name, context: nil)
+        return nil if name.nil? || name.empty?
+
+        # Normalize
+        absolute = name.start_with?("::")
+        path = name.gsub(/^::/, "").split("::")
+
+        # Absolute lookup always from root
+        if absolute
+          node = find_by_path(path, @tree)
+          return node&.component
+        end
+
+        # Relative lookup: walk up context nesting
+        if context
+          namespaces = context.name.split("::")
+          until namespaces.empty?
+            base = find_by_path(namespaces, @tree)
+            if base
+              node = find_by_path(path, base)
+              return node&.component if node&.component
+            end
+            namespaces.pop
+          end
+        end
+
+        # Fallback: top-level
+        node = find_by_path(path, @tree)
+        node&.component
+      end
+    end
+  end
+end

data/lib/compex/config.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module CompEx
+  module_function
+
+  CONFIG_MU = Mutex.new
+
+  def configure(&)
+    CONFIG_MU.synchronize do
+      @config ||= Config.new
+      yield @config if block_given?
+      @config
+    end
+  end
+
+  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
+
+    CACHE_MODES = {
+      memcached: Cache::MemcachedBackend,
+      redis: Cache::RedisBackend,
+      memory: Cache::MemoryBackend,
+      disabled: Cache::NoopBackend
+    }.freeze
+
+    def initialize
+      @on_multiple_root = :wrap
+      @multiple_root_wrap_element = "div"
+      @on_non_element = :wrap
+      self.cache_mode = :memory
+
+      return unless defined?(Rails)
+
+      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
+
+      # Anonymous classes can't be looked up since we can't define its path
+      unless cname
+        @lookup_cache[lookup_key] = nil
+        return nil
+      end
+
+      ret = case type
+      when :template
+        File.join(@template_search_path || "", "#{cname}.html.crb")
+      when :style
+        File.join(@style_search_path || "", "#{cname}.css")
+      when :js
+        File.join(@js_search_path || "", "#{cname}.js")
+      else
+        raise "Unexpected lookup type #{type.inspect}"
+      end
+
+      @lookup_cache[lookup_key] = ret
+    end
+  end
+end

data/lib/compex/js_rewriter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module CompEx
+  class JSRewriter
+    def self.rewrite(component, raw_js)
+      return nil unless raw_js
+
+      class_name = component.js_class_id
+      source = raw_js.strip.gsub(/\Aclass\s+[^\s]+\s*{/, "").gsub(/}\z/, "")
+      <<~JS
+        ((Runtime, Component) => {
+          class #{class_name} extends Component {#{source}}
+          Runtime.register(#{class_name.inspect}, #{class_name});
+        })(window.CompEx.Runtime, window.CompEx.Component);
+      JS
+    end
+  end
+end

data/lib/compex/string_refinements.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module CompEx
+  module StringRefinements
+    refine String do
+      def underscore
+        gsub("::", "/")
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .tr("-", "_")
+          .downcase
+      end
+    end
+  end
+end

data/lib/compex/style.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+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)
+
+    def self.hash_string(str)
+      value = 2906
+      str.chars.map(&:ord).each do |v|
+        value = (value * 33) ^ v
+      end
+
+      (value & 0xFFFFFFFF).to_s(36)
+    end
+
+    def initialize(klass, root_classes = nil)
+      @comp = klass
+      @style = klass.style
+      @ast = MiniCSS.parse(@style)
+      @root_classes = root_classes || []
+    end
+
+    def id_for_component = self.class.component_prefix(@comp)
+
+    def compile
+      @ast.each do |v|
+        case v
+        when MiniCSS::AST::Rule
+          next unless v.valid_selector?
+
+          v.selector = prefix_selector(v.selector)
+        when MiniCSS::AST::AtRule
+          next unless %w[media supports].include?(v.name)
+
+          v.child_rules = v.child_rules.map do |rule|
+            next rule unless rule.is_a? MiniCSS::AST::Rule
+            next rule unless rule.valid_selector?
+
+            rule.selector = prefix_selector(rule.selector)
+            rule
+          end
+        else
+          raise "Unexpected AST element #{v}"
+        end
+      end
+      MiniCSS.serialize(@ast)
+    end
+
+    def prefix_selector(sel)
+      case sel[:type]
+      when :class
+        {
+          type: :complex,
+          combinator: @root_classes.include?(sel[:content].gsub(/^\./, "")) ? "" : " ",
+          left: { type: :class, content: ".#{id_for_component}" },
+          right: sel
+        }
+      when :type, :attribute, :universal, :id
+        {
+          type: :complex,
+          combinator: " ",
+          left: { type: :class, content: ".#{id_for_component}" },
+          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
+    end
+  end
+end

data/lib/compex/template/assembler.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module CompEx
+  class Template
+    class Assembler
+      HTML_VOID_TAG = %w[area base br col embed hr img input link meta param source track wbr].freeze
+      ELEMENTS_WITH_SELF_CLOSING_CHILDREN = %w[svg math].freeze
+
+      attr_accessor :context_id, :embeddings, :components, :result
+
+      def initialize(ast, context_id)
+        @ast = ast
+        @embeddings = {}
+        @components = {}
+        @result = []
+        @literal = +""
+        @context_id = context_id
+        @embedding_id = 0
+        @component_id = 0
+      end
+
+      def assemble
+        @ast.each { assemble_one(it) }
+        push_literal
+        @result
+      end
+
+      def push_literal
+        return if @literal.empty?
+
+        @result << { kind: :literal, value: @literal }
+        @literal = +""
+      end
+
+      COMPONENT_NAME_PATTERN = /^(::)?[A-Z]\w*+(::[A-Z]\w*)*$/
+
+      def component?(node) = COMPONENT_NAME_PATTERN.match?(node.name)
+
+      def make_component(node)
+        name = "compex-component-#{@component_id}"
+        @component_id += 1
+        @components[name] = node.name
+        name
+      end
+
+      def assemble_one(node)
+        case node
+        when MiniHTML::AST::PlainText
+          @literal << node.literal
+        when MiniHTML::AST::Tag
+          name = component?(node) ? make_component(node) : node.name
+          @literal << "<#{name}"
+          has_attrs = !node.attributes.empty?
+          if has_attrs
+            @literal << " "
+            process_custom_events(node)
+            node.attributes.each { assemble_attr(it) }
+          end
+
+          if node.self_closing? && (@allow_self_closing || HTML_VOID_TAG.include?(name))
+            @literal << " " if has_attrs
+            @literal << "/>"
+            return
+          elsif node.self_closing?
+            @literal << "></#{name}>"
+            return
+          end
+
+          @literal << ">"
+
+          if ELEMENTS_WITH_SELF_CLOSING_CHILDREN.include?(name)
+            assemble_children_self_closing(node)
+          else
+            node.children.each { assemble_one(it) }
+          end
+
+          @literal << "</#{name}>"
+
+        when MiniHTML::AST::Executable
+          push_literal
+          id = "__cx_embedding_#{@context_id}_#{@embedding_id}__"
+          @embedding_id += 1
+          @embeddings[id] = node.source
+          @result << { kind: :executable, id:, source: node.source }
+        else
+          raise "Unexpected node type #{node.class}"
+        end
+      end
+
+      def assemble_attr(at)
+        @literal << at.name
+        if at.value.nil?
+          @literal << " "
+          return
+        end
+        @literal << "="
+        case at.value
+        when MiniHTML::AST::String
+          @literal << at.value.quote
+          @literal << at.value.literal
+          @literal << at.value.quote
+
+        when MiniHTML::AST::Executable
+          push_literal
+          id = @embedding_id
+          @embedding_id += 1
+          @result << { kind: :executable, id: "__cx_embedding_quoted_#{@context_id}_#{id}__", source: at.value.source }
+
+        when MiniHTML::AST::Interpolation
+          assemble_interpolation(at.value)
+
+        when MiniHTML::AST::Literal
+          @literal << at.value.value
+
+        else
+          raise "Unexpected attr value node type #{at.value.class}"
+        end
+      end
+
+      def assemble_children_self_closing(node)
+        old_self_closing = @allow_self_closing
+        @allow_self_closing = true
+        node.children.each { assemble_one(it) }
+      ensure
+        @allow_self_closing = old_self_closing
+      end
+
+      def assemble_interpolation(int)
+        @literal << int.values.first.quote
+        @literal << int.values.first.literal
+
+        int.values[1...].each do |v|
+          case v
+          when MiniHTML::AST::String
+            @literal << v.literal
+          when MiniHTML::AST::Executable
+            push_literal
+            id = @embedding_id
+            @embedding_id += 1
+            @result << { kind: :executable, id: "__cx_embedding_#{@context_id}_#{id}__", source: v.source }
+          end
+        end
+
+        @literal << int.values.first.quote
+      end
+
+      def process_custom_events(node)
+        events = []
+        to_remove = []
+        node.attributes.each do |at|
+          next unless at.name.start_with?("cx-on:")
+
+          name = at.name.split(":", 2).last
+          next unless name
+
+          handler = at.value.literal
+          to_remove << at.name
+          if handler.include? ","
+            warn "[CompEx] Ignoring custom event definition containing commas: #{at.name}=#{at.value.inspect}"
+            next
+          end
+          events << { name:, handler: }
+        end
+
+        node.attributes.reject! { to_remove.include? it.name }
+        return if events.empty?
+
+        @literal << "cx-custom-handlers="
+        @literal << events.map { "#{it[:name]}->#{it[:handler]}" }.join(",").inspect
+        @literal << " "
+      end
+    end
+  end
+end

data/lib/compex/template/renderer.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module CompEx
+  class Template
+    class Renderer
+      # 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])
+
+      attr_accessor :tokens, :embeddings, :frag, :root_classes
+
+      def initialize(assembler, context)
+        @tokens = assembler.result
+        @embeddings = assembler.embeddings
+        @inner_components = assembler.components
+        @frag = nil
+        @root_classes = []
+        @context = context
+        @context_id = @context.component_id
+        prepare_template
+      end
+
+      def prepare_template
+        embeddings.transform_values! do |v|
+          RubyVM::InstructionSequence.compile("-> { #{v} }").eval
+        end
+
+        source = @tokens.map do |item|
+          case item[:kind]
+          when :literal
+            item[:value]
+          when :executable
+            item[:id]
+          else
+            raise "[BUG] Unexpected token kind #{item[:kind]}"
+          end
+        end.join
+
+        @frag = Nokogiri::HTML5.fragment(source.strip)
+
+        return if @frag.children.empty?
+
+        if @frag.children.length > 1
+          handle_multiple_root
+        elsif !@frag.children.first.element?
+          handle_non_element
+        end
+
+        @root_classes = @frag.children.first.classes.uniq
+        handle_inner_components
+        @frag
+      end
+
+      def handle_inner_components
+        walk(@frag.children.first) do |node|
+          next unless node.name.start_with? "compex-component-"
+
+          inner_name = @inner_components[node.name]
+          next unless inner_name
+
+          c_node = CompEx::ComponentRegistry.resolve(inner_name, context: @context)
+          next unless c_node
+
+          args = c_node.defined_args.map(&:to_s)
+          component_props = node.attributes.slice(*args)
+          component_props.each_key { node.remove_attribute(it) }
+          child = node.children
+          replacement = Nokogiri::HTML5.fragment("<#{node.name}></#{node.name}>")
+          node.attributes.each_value { replacement.set_attribute(it.name, it.value) }
+          node.replace(replacement)
+          @inner_components[node.name] = {
+            name: node.name,
+            attrs: node.attributes.values,
+            children: child,
+            args: component_props.values.to_h { [it.name.to_sym, it.value] },
+            component: c_node
+          }
+        end
+      end
+
+      def walk(node, &)
+        return unless node.element?
+
+        yield node # give caller a chance to handle/replace this node
+
+        node.children.each do |child|
+          walk(child, &)
+        end
+      end
+
+      def define_css_prefix(prefix)
+        @frag.children.first.add_class(prefix)
+      end
+
+      def define_js_module(name)
+        @frag.children.first.set_attribute("cx-controller", name)
+      end
+
+      def render(&)
+        dom = @frag.dup
+        @inner_components.each do |k, v|
+          embed = dom.at_css(k)
+          next unless embed
+
+          result = Nokogiri::HTML5.fragment(yield v).children.first
+          v[:attrs].each do |attr|
+            val = attr.value
+            val = "#{result.get_attribute(attr.name)} #{val}" if MERGEABLE_ATTRIBUTES.include?(attr.name) && result.has_attribute?(attr.name)
+            result.set_attribute(attr.name, val)
+          end
+          embed.replace(result)
+        end
+
+        @embeddings.each do |k, v|
+          next if k.start_with? "__cx_embedding"
+
+          embed = dom.at_css("compex-embedding[id=\"#{k}\"]")
+          next unless embed
+
+          result = yield v
+          embed.replace(result)
+        end
+
+        dom.to_html
+          .gsub(/__cx_embedding_#{@context_id}_\d+__/) { process_embeddings(it, false, &) }
+          .gsub(/__cx_embedding_quoted_#{@context_id}_\d+__/) { process_embeddings(it, true, &) }
+      end
+
+      def process_embeddings(key, quoted)
+        return key unless @embeddings.key? key
+
+        ret = yield @embeddings[key]
+        ret = ret.inspect if quoted
+        ret
+      end
+
+      def handle_multiple_root
+        raise MultipleRootError, "Element contains multiple root elements" if CompEx.config.on_multiple_root == :raise
+
+        wrapper = @frag.document.create_element(CompEx.config.multiple_root_wrap_element)
+        @frag.children.each { wrapper << it }
+        @frag.add_child(wrapper)
+      end
+
+      def handle_non_element
+        raise NonElementRootError, "Element contains multiple root elements" if CompEx.config.on_non_element == :raise
+
+        wrapper = @frag.document.create_element(CompEx.config.multiple_root_wrap_element)
+        @frag.children.first.wrap(wrapper)
+      end
+    end
+  end
+end

data/lib/compex/template.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "template/renderer"
+require_relative "template/assembler"
+
+module CompEx
+  class Template
+    def self.parse(value, context)
+      p = MiniHTML::Parser.new(value)
+      ast = p.parse
+      assembler = Assembler.new(ast, context.component_id)
+      assembler.assemble
+      Renderer.new(assembler, context)
+    end
+  end
+end

data/lib/compex/unsafe_string.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module CompEx
+  class UnsafeString
+    attr_reader :raw, :escaped
+
+    def initialize(value)
+      if value.is_a? UnsafeString
+        @raw = value.raw
+        @escaped = value.escaped
+      else
+        @raw = value
+        @escaped = ERB::Util.html_escape(raw)
+      end
+    end
+
+    def to_s = @escaped
+  end
+end

data/lib/compex/version.rb

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

data/lib/compex.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "digest/sha1"
+require "digest/sha2"
+require "json"
+
+require "nokogiri"
+require "minicss"
+require "minihtml"
+
+require_relative "compex/version"
+require_relative "compex/template"
+require_relative "compex/string_refinements"
+require_relative "compex/cache"
+require_relative "compex/style"
+require_relative "compex/bag"
+require_relative "compex/js_rewriter"
+require_relative "compex/component_registry"
+require_relative "compex/base"
+require_relative "compex/unsafe_string"
+require_relative "compex/config"
+require_relative "compex/asset_provider"
+
+module CompEx
+  class Error < StandardError; end
+
+  class ParsingError < Error
+    attr_reader :errors
+
+    def initialize(errors)
+      @errors = errors
+      super("Errors were detected parsing the template: #{@errors.map { it[:error] }.join(", ")}")
+    end
+  end
+
+  class MultipleRootError < Error; end
+  class NonElementRootError < Error; end
+end