homura-runtime 0.3.9 → 0.3.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d14417c1dedeec08cd1ee906d177d1c70dacb4d2a8e8d5979f815dd17340fc4
-  data.tar.gz: 0d3e76edc794a886048959f63f258f581d4f8f8aae43fbe74807ab6417f2fd88
+  metadata.gz: c59a63b90f082b8a76fa50e58260b441620a134cec49b4b2e405e85d8a0f9d83
+  data.tar.gz: 345d24c902e7d4a22b36f5274cc14803bc55c49867a4b9edcf20fe9c38462df8
 SHA512:
-  metadata.gz: a4aaa01b5c0a5953f5c5b4e57ece0344ab2de76081dc7f04c1844729fe1e3447f8e60935845808adfb8d12f7970a8a062134e9c11f02159d628d3a42f178ba4a
-  data.tar.gz: 79be638101406487bf5409d0a6b2e4b6a516f75acf113b3b3bd7f2d9ac2e0532cd493579a22993b6dd9932d198748f3d2f3355ac9c9a58864b01c6ead3155dc8
+  metadata.gz: adff0dff8e7081b0ae2302dad372f5d16b5427341ed4d675121ce97f4906554967300ef232be08b8a530cd9322e79754eb9b6f7bda4885b550dfde663ca96d7d
+  data.tar.gz: cb1741f695090248426e9e5a57b4ec9cfecd4a294b85d20fa78d62e256d48941ef6375039360c1bdc395ab1d1c22fb3c7cd5c92411209ed06a2afb67dcf4a1f6

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.3.10 (2026-06-25)
+
+- Package the Phlex, Literal, and Zeitwerk Opal compatibility files in
+  `homura-runtime` itself. Published examples can now resolve those compat
+  requires from the runtime gem without depending on an unpublished
+  `opal-homura` stdlib change.
+
 ## 0.3.9 (2026-06-25)
 
 - Add the Homura Opal gem prelude for published Phlex/Literal apps. The build

data/lib/homura/runtime/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HomuraRuntime
-  VERSION = "0.3.9"
+  VERSION = "0.3.10"
 end

data/lib/literal/opal_compat.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "zeitwerk/opal_compat"
+require "literal" unless defined?(Literal)
+
+module Literal
+  class OpalBuffer
+    def initialize(value = "")
+      @value = value.to_s
+    end
+
+    def <<(value)
+      @value += value.to_s
+      self
+    end
+
+    def to_s
+      @value
+    end
+
+    alias to_str to_s
+
+    def encoding
+      @value.encoding
+    end
+
+    def force_encoding(_encoding)
+      @value
+    end
+
+    def method_missing(name, ...)
+      if @value.respond_to?(name)
+        @value.public_send(name, ...)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @value.respond_to?(name, include_private) || super
+    end
+  end
+end
+
+module Literal::Properties
+  private def __define_literal_methods__(new_property)
+    extension = __literal_extension__
+
+    extension.define_method(:initialize) do |*args, **kwargs, &block|
+      positional_index = 0
+      properties = self.class.literal_properties
+
+      properties.each do |property|
+        value = case property.kind
+        when :positional
+          if positional_index < args.length
+            args[positional_index]
+          elsif property.default?
+            Literal::Undefined
+          elsif property.type === nil
+            nil
+          else
+            Literal::Undefined
+          end
+            .tap { positional_index += 1 }
+        when :*
+          args[positional_index..] || []
+        when :keyword
+          if kwargs.key?(property.name)
+            kwargs.delete(property.name)
+          elsif property.default?
+            Literal::Undefined
+          elsif property.type === nil
+            nil
+          else
+            Literal::Undefined
+          end
+
+        when :**
+          kwargs
+        when :&
+          block
+        else
+          raise "You should never see this error."
+        end
+
+        value = property.default_value(self) if property.default? && Literal::Undefined == value
+        value = property.coerce(value, context: self) if property.coercion
+        property.check_initializer(self, value)
+        instance_variable_set(:"@#{property.name}", value)
+      end
+
+      after_initialize if respond_to?(:after_initialize, true)
+    rescue Literal::TypeError => error
+      error.set_backtrace(caller(2))
+      raise
+    end
+
+    extension.define_method(:to_h) do
+      self.class.literal_properties.each.each_with_object({}) do |property, hash|
+        hash[property.name] = instance_variable_get(:"@#{property.name}")
+      end
+    end
+
+    extension.alias_method(:to_hash, :to_h)
+
+    define_literal_reader(extension, new_property) if new_property.reader
+    define_literal_writer(extension, new_property) if new_property.writer
+    define_literal_predicate(extension, new_property) if new_property.predicate
+  end
+
+  private def define_literal_reader(extension, property)
+    extension.define_method(property.name) do
+      instance_variable_get(:"@#{property.name}")
+    end
+
+    extension.__send__(property.reader, property.name)
+  end
+
+  private def define_literal_writer(extension, property)
+    method_name = :"#{property.name}="
+    extension.define_method(method_name) do |value|
+      property.check_writer(self, value)
+      instance_variable_set(:"@#{property.name}", value)
+    rescue Literal::TypeError => error
+      error.set_backtrace(caller(1))
+      raise
+    end
+
+    extension.__send__(property.writer, method_name)
+  end
+
+  private def define_literal_predicate(extension, property)
+    method_name = :"#{property.name}?"
+    extension.define_method(method_name) do
+      !!instance_variable_get(:"@#{property.name}")
+    end
+
+    extension.__send__(property.predicate, method_name)
+  end
+end

data/lib/phlex/opal_compat.rb

@@ -0,0 +1,403 @@
+# frozen_string_literal: true
+
+require "corelib/pattern_matching"
+require "zeitwerk/opal_compat"
+require "phlex" unless defined?(Phlex)
+
+Phlex::SGML
+Phlex::SGML::State
+Phlex::SGML::Attributes
+Phlex::SGML::Elements
+
+module Phlex
+  class OpalBuffer
+    def initialize(value = "")
+      @value = value.to_s
+    end
+
+    def <<(value)
+      @value += value.to_s
+      self
+    end
+
+    def bytesize
+      @value.bytesize
+    end
+
+    def byteslice(offset, length = nil)
+      length ? @value.byteslice(offset, length) : @value.byteslice(offset)
+    end
+
+    def clear
+      @value = ""
+      self
+    end
+
+    def dup
+      self.class.new(@value)
+    end
+
+    def empty?
+      @value.empty?
+    end
+
+    def gsub(...)
+      @value.gsub(...)
+    end
+
+    def encoding
+      @value.encoding
+    end
+
+    def force_encoding(_encoding)
+      @value
+    end
+
+    def valid_encoding?
+      true
+    end
+
+    def length
+      @value.length
+    end
+
+    alias size length
+
+    def to_s
+      @value
+    end
+
+    alias to_str to_s
+
+    def inspect
+      @value.inspect
+    end
+
+    def ==(other)
+      @value == other.to_s
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      @value.hash
+    end
+
+    def method_missing(name, ...)
+      if @value.respond_to?(name)
+        @value.public_send(name, ...)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @value.respond_to?(name, include_private) || super
+    end
+  end
+end
+
+if defined?(Phlex::SGML)
+  class Phlex::SGML
+    def call(buffer = Phlex::OpalBuffer.new, context: {}, fragments: nil, &)
+      buffer = Phlex::OpalBuffer.new(buffer) if buffer.is_a?(String)
+      state = Phlex::SGML::State.new(
+        user_context: context,
+        output_buffer: buffer,
+        fragments: fragments&.to_set
+      )
+
+      internal_call(parent: nil, state:, &)
+
+      state.output_buffer << state.buffer
+    end
+
+    private def __homura_normalize_comma_separated_tokens__(method_name, attributes)
+      case method_name
+      when :img
+        if Array === (srcset_attribute = attributes[:srcset])
+          attributes[:srcset] = Phlex::SGML::Attributes.generate_nested_tokens(
+            srcset_attribute,
+            ", ",
+            ",",
+            "%2C"
+          )
+        end
+
+      when :input
+        if Array === (accept_attribute = attributes[:accept])
+          type_attribute = attributes[:type] || attributes["type"]
+          if "file" == type_attribute || :file == type_attribute
+            attributes[:accept] = Phlex::SGML::Attributes.generate_nested_tokens(
+              accept_attribute,
+              ", ",
+              ",",
+              "%2C"
+            )
+          end
+        end
+
+      when :link
+        if Array === (media_attribute = attributes[:media])
+          attributes[:media] = Phlex::SGML::Attributes.generate_nested_tokens(
+            media_attribute,
+            ", ",
+            ",",
+            "%2C"
+          )
+        end
+
+        if Array === (sizes_attribute = attributes[:sizes])
+          attributes[:sizes] = Phlex::SGML::Attributes.generate_nested_tokens(
+            sizes_attribute,
+            ", ",
+            ",",
+            "%2C"
+          )
+        end
+
+        if Array === (imagesrcset_attribute = attributes[:imagesrcset])
+          rel_attribute = attributes[:rel] || attributes["rel"]
+          as_attribute = attributes[:as] || attributes["as"]
+          if ("preload" == rel_attribute || :preload == rel_attribute) &&
+              ("image" == as_attribute || :image == as_attribute)
+            attributes[:imagesrcset] = Phlex::SGML::Attributes.generate_nested_tokens(
+              imagesrcset_attribute,
+              ", ",
+              ",",
+              "%2C"
+            )
+          end
+        end
+      end
+    end
+  end
+
+  class Phlex::SGML::State
+    def initialize(user_context: {}, output_buffer:, fragments:)
+      @buffer = Phlex::OpalBuffer.new
+      @capturing = false
+      @user_context = user_context
+      @fragments = fragments
+      @fragment_depth = 0
+      @cache_stack = []
+      @halt_signal = nil
+      @output_buffer = output_buffer
+    end
+
+    def capture
+      new_buffer = Phlex::OpalBuffer.new
+      original_buffer = @buffer
+      original_capturing = @capturing
+      original_fragments = @fragments
+
+      begin
+        @buffer = new_buffer
+        @capturing = true
+        @fragments = nil
+        yield
+      ensure
+        @buffer = original_buffer
+        @capturing = original_capturing
+        @fragments = original_fragments
+      end
+
+      new_buffer
+    end
+  end
+
+  module Phlex::SGML::Elements
+    def register_element(method_name, tag: method_name.name.tr("_", "-"))
+      define_method(method_name) do |**attributes, &content|
+        state = @_state
+        buffer = state.buffer
+        has_content = !content.nil?
+
+        unless state.should_render?
+          content.call(self) if has_content
+          return nil
+        end
+
+        if attributes.length > 0
+          buffer << "<#{tag}"
+          begin
+            __homura_normalize_comma_separated_tokens__(method_name, attributes)
+            buffer << (Phlex::ATTRIBUTE_CACHE[attributes] ||= Phlex::SGML::Attributes.generate_attributes(attributes))
+          ensure
+            buffer << ">"
+          end
+
+          if has_content
+            begin
+              original_length = buffer.bytesize
+              rendered_content = content.call(self)
+              __implicit_output__(rendered_content) if original_length == buffer.bytesize
+            ensure
+              buffer << "</#{tag}>"
+            end
+          else
+            buffer << "</#{tag}>"
+          end
+        elsif has_content
+          buffer << "<#{tag}>"
+          begin
+            original_length = buffer.bytesize
+            rendered_content = content.call(self)
+            __implicit_output__(rendered_content) if original_length == buffer.bytesize
+          ensure
+            buffer << "</#{tag}>"
+          end
+        else
+          buffer << "<#{tag}></#{tag}>"
+        end
+
+        flush if tag == "head"
+        nil
+      end
+
+      __registered_elements__[method_name] = tag
+      method_name
+    end
+
+    def __register_void_element__(method_name, tag: method_name.name.tr("_", "-"))
+      define_method(method_name) do |**attributes|
+        state = @_state
+        return unless state.should_render?
+
+        buffer = state.buffer
+
+        if attributes.length > 0
+          buffer << "<#{tag}"
+          begin
+            __homura_normalize_comma_separated_tokens__(method_name, attributes)
+            buffer << (Phlex::ATTRIBUTE_CACHE[attributes] ||= Phlex::SGML::Attributes.generate_attributes(attributes))
+          ensure
+            buffer << ">"
+          end
+        else
+          buffer << "<#{tag}>"
+        end
+
+        nil
+      end
+
+      __registered_elements__[method_name] = tag
+      method_name
+    end
+  end
+
+  module Phlex::SGML::Attributes
+    class << self
+      alias __homura_generate_attributes__ generate_attributes
+      alias __homura_generate_nested_attributes__ generate_nested_attributes
+
+      def generate_attributes(attributes, buffer = Phlex::OpalBuffer.new)
+        __homura_generate_attributes__(attributes, buffer)
+      end
+
+      def generate_nested_attributes(attributes, base_name, buffer = Phlex::OpalBuffer.new)
+        __homura_generate_nested_attributes__(attributes, base_name, buffer)
+      end
+
+      def generate_nested_tokens(tokens, sep = " ", gsub_from = nil, gsub_to = "")
+        buffer = Phlex::OpalBuffer.new
+
+        i, length = 0, tokens.length
+
+        while i < length
+          token = tokens[i]
+
+          case token
+          when String
+            token = token.gsub(gsub_from, gsub_to) if gsub_from
+            i > 0 ? buffer << sep << token : buffer << token
+          when Symbol
+            value = token.name.tr("_", "-")
+            i > 0 ? buffer << sep << value : buffer << value
+          when Integer, Float, Phlex::SGML::SafeObject
+            i > 0 ? buffer << sep << token.to_s : buffer << token.to_s
+          when Array
+            if token.length > 0 && (value = generate_nested_tokens(token, sep, gsub_from, gsub_to))
+              i > 0 ? buffer << sep << value : buffer << value
+            end
+
+          when Set
+            if token.length > 0 && (value = generate_nested_tokens(token.to_a, sep, gsub_from, gsub_to))
+              i > 0 ? buffer << sep << value : buffer << value
+            end
+
+          when nil
+            nil
+          else
+            raise Phlex::ArgumentError.new("Invalid token type: #{token.class}.")
+          end
+
+          i += 1
+        end
+
+        return if buffer.empty?
+
+        buffer.gsub("\"", "&quot;")
+      end
+
+      def generate_styles(styles)
+        case styles
+        when Array, Set
+          styles
+            .filter_map do |s|
+              case s
+              when String
+                s == "" || s.end_with?(";") ? s : "#{s};"
+              when Phlex::SGML::SafeObject
+                value = s.to_s
+                value.end_with?(";") ? value : "#{value};"
+              when Hash
+                next generate_styles(s)
+              when nil
+                next nil
+              else
+                raise Phlex::ArgumentError.new("Invalid style: #{s.inspect}.")
+              end
+            end
+            .join(" ")
+        when Hash
+          buffer = Phlex::OpalBuffer.new
+          i = 0
+          styles.each do |k, v|
+            prop = case k
+            when String
+              k
+            when Symbol
+              k.name.tr("_", "-")
+            else
+              raise Phlex::ArgumentError.new("Style keys should be Strings or Symbols.")
+            end
+
+            value = case v
+            when String
+              v
+            when Symbol
+              v.name.tr("_", "-")
+            when Integer, Float, Phlex::SGML::SafeObject
+              v.to_s
+            when nil
+              nil
+            else
+              raise Phlex::ArgumentError.new("Invalid style value: #{v.inspect}")
+            end
+
+            if value
+              i == 0 ? buffer << prop << ": " << value << ";" : buffer << " " << prop << ": " << value << ";"
+            end
+
+            i += 1
+          end
+
+          buffer
+        end
+      end
+    end
+  end
+end

data/lib/zeitwerk/opal_compat.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+
+module Zeitwerk
+  class << self
+    attr_accessor :__homura_next_gem_root
+
+    def __homura_next_loader_tag
+      @__homura_loader_tag_sequence ||= 0
+      @__homura_loader_tag_sequence += 1
+      "homura-#{@__homura_loader_tag_sequence}"
+    end
+  end
+
+  class Inflector
+    def camelize(basename, _abspath)
+      overrides[basename] || basename.split("_").map(&:capitalize).join
+    end
+  end
+
+  class Loader
+    class << self
+      alias __homura_original_for_gem__ for_gem
+
+      def for_gem(warn_on_extra_files: true)
+        if (root_file = Zeitwerk.__homura_next_gem_root)
+          Zeitwerk.__homura_next_gem_root = nil
+          Registry.loader_for_gem(
+            root_file,
+            namespace: Object,
+            warn_on_extra_files: false
+          )
+        else
+          __homura_original_for_gem__(warn_on_extra_files: warn_on_extra_files)
+        end
+      end
+    end
+
+    module Config
+      def initialize
+        @inflector = Zeitwerk::Inflector.new
+        @logger = self.class.default_logger
+        @tag = Zeitwerk.__homura_next_loader_tag
+        @initialized_at = Time.now
+        @roots = {}
+        @nsfile = nil
+        @ignored_glob_patterns = Set.new
+        @ignored_paths = Set.new
+        @collapse_glob_patterns = Set.new
+        @collapse_dirs = Set.new
+        @collapse_parents = Set.new
+        @eager_load_exclusions = Set.new
+        @reloading_enabled = false
+        @on_setup_callbacks = []
+        @on_load_callbacks = {}
+        @on_unload_callbacks = {}
+      end
+    end
+
+    private def define_autoloads_for_dir(dir, mod, external:)
+      @fs.ls(dir) do |basename, abspath, ftype|
+        if ftype == :file
+          if basename == @nsfile
+            if external
+              cpath = real_mod_name(mod)
+              location = Object.const_source_location(cpath)&.join(":")
+              location = nil if location&.empty?
+              raise(
+                Zeitwerk::ConflictingNamespaceDefinitionError.new(
+                  cpath,
+                  location: location,
+                  conflicting_file: abspath
+                )
+              )
+            end
+
+            next
+          end
+
+          basename = basename.delete_suffix(".rb")
+          cref = Cref.new(mod, cname_for(basename, abspath))
+          visit_file(cref, abspath)
+        else
+          cref = Cref.new(mod, cname_for(basename, abspath))
+          visit_subdir(cref, abspath, external: external)
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: homura-runtime
 version: !ruby/object:Gem::Version
-  version: 0.3.9
+  version: 0.3.10
 platform: ruby
 authors:
 - Kazuhiro Homma
@@ -71,7 +71,10 @@ files:
 - lib/homura_vendor_tempfile.rb
 - lib/homura_vendor_tilt.rb
 - lib/homura_vendor_zlib.rb
+- lib/literal/opal_compat.rb
 - lib/opal_patches.rb
+- lib/phlex/opal_compat.rb
+- lib/zeitwerk/opal_compat.rb
 - runtime/patch-opal-evals.mjs
 - runtime/setup-node-crypto.mjs
 - runtime/worker.mjs