homura-runtime 0.3.8 → 0.3.9

data/lib/homura/runtime/async_registry.rb

@@ -87,38 +87,43 @@ module HomuraRuntime
             .each do |path|
               next unless File.read(path).include?("register_async_source")
 
-              require_path =
-                path.sub(Regexp.new("^#{Regexp.escape(lib_dir)}/"), "").sub(
-                  /\.rb\z/,
-                  ""
-                )
+              require_path = path.sub(Regexp.new("^#{Regexp.escape(lib_dir)}/"), "").sub(
+                /\.rb\z/,
+                ""
+              )
               begin
                 require require_path
+
                 loaded += 1
                 if debug
-                  puts "[auto-await] loaded async source from #{spec.name}: #{require_path}"
+                  puts("[auto-await] loaded async source from #{spec.name}: #{require_path}")
                 end
+
               rescue LoadError, StandardError => e
                 if debug
-                  warn "[auto-await] Warning: failed to load async source from #{spec.name}/#{require_path}: #{e.message}"
+                  warn(
+                    "[auto-await] Warning: failed to load async source from #{spec.name}/#{require_path}: #{e.message}"
+                  )
                 end
               end
             end
         end
 
         if debug && loaded.positive?
-          puts "[auto-await] auto-loaded #{loaded} async source file(s)"
+          puts("[auto-await] auto-loaded #{loaded} async source file(s)")
         end
       end
     end
 
-    attr_reader :async_classes,
-                :async_methods,
-                :async_factories,
-                :taint_returns,
-                :async_accessors,
-                :async_helpers,
-                :helper_factories
+    attr_reader(
+      :async_classes,
+      :async_methods,
+      :async_factories,
+      :taint_returns,
+      :async_accessors,
+      :async_helpers,
+      :helper_factories
+    )
 
     def initialize
       @async_classes = {}
@@ -135,10 +140,12 @@ module HomuraRuntime
       methods = @async_methods[class_name]
       return true if methods&.include?(method_name)
       except = @async_classes[class_name]
-      if except && !except.include?(method_name.to_s) &&
-           !except.include?(method_name.to_sym)
+      if except &&
+          !except.include?(method_name.to_s) &&
+          !except.include?(method_name.to_sym)
         return true
       end
+
       false
     end
 
@@ -151,8 +158,10 @@ module HomuraRuntime
     end
 
     def tainted_class?(class_name)
-      @async_classes.key?(class_name) || @async_methods.key?(class_name) ||
-        @async_factories.key?(class_name) || @taint_returns.key?(class_name)
+      @async_classes.key?(class_name) ||
+        @async_methods.key?(class_name) ||
+        @async_factories.key?(class_name) ||
+        @taint_returns.key?(class_name)
     end
   end
 end
@@ -161,100 +170,106 @@ end
 # Each binding declares which methods return Promises so the
 # build-time analyzer can insert .__await__ automatically.
 HomuraRuntime::AsyncRegistry.register_async_source do
-  async_method "Cloudflare::D1Database", :execute
-  async_method "Cloudflare::D1Database", :get_first_row
-  async_method "Cloudflare::D1Database", :execute_insert
-  async_method "Cloudflare::D1Database", :execute_batch
-  taint_return "Cloudflare::D1Database", :prepare, "Cloudflare::D1Statement"
-  taint_return "Cloudflare::D1Database", :[], "Cloudflare::D1Statement"
-
-  async_method "Cloudflare::D1Statement", :all
-  async_method "Cloudflare::D1Statement", :first
-  async_method "Cloudflare::D1Statement", :run
+  async_method("Cloudflare::D1Database", :execute)
+  async_method("Cloudflare::D1Database", :get_first_row)
+  async_method("Cloudflare::D1Database", :execute_insert)
+  async_method("Cloudflare::D1Database", :execute_batch)
+  taint_return("Cloudflare::D1Database", :prepare, "Cloudflare::D1Statement")
+  taint_return("Cloudflare::D1Database", :[], "Cloudflare::D1Statement")
+
+  async_method("Cloudflare::D1Statement", :all)
+  async_method("Cloudflare::D1Statement", :first)
+  async_method("Cloudflare::D1Statement", :run)
   # `bind` returns a new D1Statement for further chaining. Tainting the
   # return preserves the type so the auto-await pass keeps chaining
   # `.run` / `.all` / `.first` on the bound statement (otherwise
   # `db.prepare(sql).bind(...).run` drops await on `.run` and
   # `flatten_meta` ends up receiving a JS Promise instead of the
   # metadata Hash).
-  taint_return "Cloudflare::D1Statement", :bind, "Cloudflare::D1Statement"
-
-  async_method "Cloudflare::KVNamespace", :get
-  async_method "Cloudflare::KVNamespace", :get_with_metadata
-  async_method "Cloudflare::KVNamespace", :put
-  async_method "Cloudflare::KVNamespace", :delete
-  async_method "Cloudflare::KVNamespace", :list
-
-  async_method "Cloudflare::R2Bucket", :get
-  async_method "Cloudflare::R2Bucket", :get_binary
-  async_method "Cloudflare::R2Bucket", :put
-  async_method "Cloudflare::R2Bucket", :delete
-  async_method "Cloudflare::R2Bucket", :list
-  async_method "Cloudflare::R2Bucket", :head
-
-  async_method "Cloudflare::AI", :run
-  async_method "Cloudflare::AI", :speak
-  async_method "Cloudflare::AI", :speak_data_url
-  taint_return "Cloudflare::AI", :run_stream, "Cloudflare::AI::Stream"
-  async_method "Cloudflare::AI::Binding", :run
-  async_method "Cloudflare::AI::Binding", :chat
-  async_method "Cloudflare::AI::Binding", :chat_text
-  async_method "Cloudflare::AI::Binding", :transcribe
-  async_method "Cloudflare::AI::Binding", :transcribe_text
-  async_method "Cloudflare::AI::Binding", :speak
-  async_method "Cloudflare::AI::Binding", :speak_data_url
-  taint_return "Cloudflare::AI::Binding", :run_stream, "Cloudflare::AI::Stream"
-
-  async_method "Cloudflare::Cache", :match
-  async_method "Cloudflare::Cache", :put
-  async_method "Cloudflare::Cache", :delete
-
-  async_factory "Cloudflare::Email", :new
-  async_method "Cloudflare::Email", :send
-
-  async_method "Cloudflare::Queue", :send
-  async_method "Cloudflare::Queue", :send_batch
-
-  async_factory "Cloudflare::DurableObjectNamespace", :new
-  taint_return "Cloudflare::DurableObjectNamespace",
-               :get,
-               "Cloudflare::DurableObjectStub"
-  taint_return "Cloudflare::DurableObjectNamespace",
-               :get_by_name,
-               "Cloudflare::DurableObjectStub"
-  taint_return "Cloudflare::DurableObjectState",
-               :storage,
-               "Cloudflare::DurableObjectStorage"
-  async_method "Cloudflare::DurableObjectStub", :fetch
-  async_method "Cloudflare::DurableObjectStub", :request
-  async_method "Cloudflare::DurableObjectStub", :get
-  async_method "Cloudflare::DurableObjectStub", :post
-  async_method "Cloudflare::DurableObjectStub", :put
-  async_method "Cloudflare::DurableObjectStub", :delete
-
-  async_method "Cloudflare::DurableObjectStorage", :get
-  async_method "Cloudflare::DurableObjectStorage", :put
-  async_method "Cloudflare::DurableObjectStorage", :delete
-  async_method "Cloudflare::DurableObjectStorage", :list
-  async_method "Cloudflare::DurableObjectStorage", :transaction
-
-  async_method "Cloudflare::HTTP", :fetch
-
-  async_method "Faraday::Connection", :get
-  async_method "Faraday::Connection", :post
-  async_method "Faraday::Connection", :put
-  async_method "Faraday::Connection", :delete
-  async_method "Faraday::Connection", :patch
-  async_method "Faraday::Connection", :head
-
-  helper_factory :d1, "Cloudflare::D1Database"
-  helper_factory :db, "Cloudflare::D1Database"
-  helper_factory :kv, "Cloudflare::KVNamespace"
-  helper_factory :bucket, "Cloudflare::R2Bucket"
-  helper_factory :ai, "Cloudflare::AI::Binding"
-  helper_factory :send_email, "Cloudflare::Email"
-  helper_factory :jobs_queue, "Cloudflare::Queue"
-  helper_factory :jobs_dlq, "Cloudflare::Queue"
-  helper_factory :do_counter, "Cloudflare::DurableObjectNamespace"
-  helper_factory :durable_object, "Cloudflare::DurableObjectStub"
+  taint_return("Cloudflare::D1Statement", :bind, "Cloudflare::D1Statement")
+
+  async_method("Cloudflare::KVNamespace", :get)
+  async_method("Cloudflare::KVNamespace", :get_with_metadata)
+  async_method("Cloudflare::KVNamespace", :put)
+  async_method("Cloudflare::KVNamespace", :delete)
+  async_method("Cloudflare::KVNamespace", :list)
+
+  async_method("Cloudflare::R2Bucket", :get)
+  async_method("Cloudflare::R2Bucket", :get_binary)
+  async_method("Cloudflare::R2Bucket", :put)
+  async_method("Cloudflare::R2Bucket", :delete)
+  async_method("Cloudflare::R2Bucket", :list)
+  async_method("Cloudflare::R2Bucket", :head)
+
+  async_method("Cloudflare::AI", :run)
+  async_method("Cloudflare::AI", :speak)
+  async_method("Cloudflare::AI", :speak_data_url)
+  taint_return("Cloudflare::AI", :run_stream, "Cloudflare::AI::Stream")
+  async_method("Cloudflare::AI::Binding", :run)
+  async_method("Cloudflare::AI::Binding", :chat)
+  async_method("Cloudflare::AI::Binding", :chat_text)
+  async_method("Cloudflare::AI::Binding", :transcribe)
+  async_method("Cloudflare::AI::Binding", :transcribe_text)
+  async_method("Cloudflare::AI::Binding", :speak)
+  async_method("Cloudflare::AI::Binding", :speak_data_url)
+  taint_return("Cloudflare::AI::Binding", :run_stream, "Cloudflare::AI::Stream")
+
+  async_method("Cloudflare::Cache", :match)
+  async_method("Cloudflare::Cache", :put)
+  async_method("Cloudflare::Cache", :delete)
+
+  async_factory("Cloudflare::Email", :new)
+  async_method("Cloudflare::Email", :send)
+
+  async_method("Cloudflare::Queue", :send)
+  async_method("Cloudflare::Queue", :send_batch)
+
+  async_factory("Cloudflare::DurableObjectNamespace", :new)
+  taint_return(
+    "Cloudflare::DurableObjectNamespace",
+    :get,
+    "Cloudflare::DurableObjectStub"
+  )
+  taint_return(
+    "Cloudflare::DurableObjectNamespace",
+    :get_by_name,
+    "Cloudflare::DurableObjectStub"
+  )
+  taint_return(
+    "Cloudflare::DurableObjectState",
+    :storage,
+    "Cloudflare::DurableObjectStorage"
+  )
+  async_method("Cloudflare::DurableObjectStub", :fetch)
+  async_method("Cloudflare::DurableObjectStub", :request)
+  async_method("Cloudflare::DurableObjectStub", :get)
+  async_method("Cloudflare::DurableObjectStub", :post)
+  async_method("Cloudflare::DurableObjectStub", :put)
+  async_method("Cloudflare::DurableObjectStub", :delete)
+
+  async_method("Cloudflare::DurableObjectStorage", :get)
+  async_method("Cloudflare::DurableObjectStorage", :put)
+  async_method("Cloudflare::DurableObjectStorage", :delete)
+  async_method("Cloudflare::DurableObjectStorage", :list)
+  async_method("Cloudflare::DurableObjectStorage", :transaction)
+
+  async_method("Cloudflare::HTTP", :fetch)
+
+  async_method("Faraday::Connection", :get)
+  async_method("Faraday::Connection", :post)
+  async_method("Faraday::Connection", :put)
+  async_method("Faraday::Connection", :delete)
+  async_method("Faraday::Connection", :patch)
+  async_method("Faraday::Connection", :head)
+
+  helper_factory(:d1, "Cloudflare::D1Database")
+  helper_factory(:db, "Cloudflare::D1Database")
+  helper_factory(:kv, "Cloudflare::KVNamespace")
+  helper_factory(:bucket, "Cloudflare::R2Bucket")
+  helper_factory(:ai, "Cloudflare::AI::Binding")
+  helper_factory(:send_email, "Cloudflare::Email")
+  helper_factory(:jobs_queue, "Cloudflare::Queue")
+  helper_factory(:jobs_dlq, "Cloudflare::Queue")
+  helper_factory(:do_counter, "Cloudflare::DurableObjectNamespace")
+  helper_factory(:durable_object, "Cloudflare::DurableObjectStub")
 end

data/lib/homura/runtime/auto_await/analyzer.rb

@@ -44,6 +44,7 @@ module HomuraRuntime
           process_def(node)
           return
         end
+
         if node.type == :block
           process_block(node)
           return
@@ -55,6 +56,7 @@ module HomuraRuntime
         node.children.each do |child|
           process_node(child) if child.is_a?(Parser::AST::Node)
         end
+
         case node.type
         when :lvasgn
           process_lvasgn(node)
@@ -96,7 +98,7 @@ module HomuraRuntime
         @method_returns[method_name] = return_cls if return_cls
         body_source = node.loc.expression&.source.to_s
         if @await_nodes.length > before_awaits ||
-             body_source.include?(".__await__")
+            body_source.include?(".__await__")
           @async_local_methods << method_name
         end
 
@@ -121,12 +123,13 @@ module HomuraRuntime
       def process_send(node)
         receiver, method_name = *node
         if receiver.nil? &&
-             (factory_cls = @registry.helper_factories[method_name])
+            (factory_cls = @registry.helper_factories[method_name])
           @env[method_name] = factory_cls
         end
+
         if should_await?(node)
           @await_nodes << node
-          debug "await target: #{node.loc.expression.source}"
+          debug("await target: #{node.loc.expression.source}")
         end
       end
 
@@ -153,8 +156,10 @@ module HomuraRuntime
             if @method_returns.key?(method_name)
               return @method_returns[method_name]
             end
+
             return @env[method_name] if @env.key?(method_name)
           end
+
           infer_send_class(node)
         when :index
           infer_index_class(node)
@@ -178,16 +183,17 @@ module HomuraRuntime
         if method_name == :new && receiver&.type == :const
           return const_path(receiver)
         end
+
         if receiver
           if method_name == :[]
             key_node = node.children[2]
             if key_node&.type == :str
               key = key_node.children[0]
-              mapped =
-                @registry.async_accessors[[env_name(receiver), key.to_sym]]
+              mapped = @registry.async_accessors[[env_name(receiver), key.to_sym]]
               return mapped if mapped
             end
           end
+
           accessor_cls = infer_env_accessor(receiver, method_name)
           return accessor_cls if accessor_cls
           recv_cls = infer_class(receiver)
@@ -202,6 +208,7 @@ module HomuraRuntime
             return @method_returns[method_name]
           end
         end
+
         nil
       end
 
@@ -209,17 +216,18 @@ module HomuraRuntime
         return {} unless durable_object_define_call?(call_node)
         return {} unless args_node&.type == :args
 
-        arg_names =
-          args_node.children.filter_map do |arg|
-            next unless arg&.type == :arg
-            arg.children[0]
-          end
+        arg_names = args_node.children.filter_map do |arg|
+          next unless arg&.type == :arg
+          arg.children[0]
+        end
+
         return {} if arg_names.empty?
 
-        bindings = { arg_names[0] => "Cloudflare::DurableObjectState" }
-        bindings[
-          arg_names[1]
-        ] = "Cloudflare::DurableObjectRequest" if arg_names.length > 1
+        bindings = {arg_names[0] => "Cloudflare::DurableObjectState"}
+        if arg_names.length > 1
+          bindings[arg_names[1]] = "Cloudflare::DurableObjectRequest"
+        end
+
         bindings
       end
 
@@ -244,6 +252,7 @@ module HomuraRuntime
           mapped = @registry.async_accessors[[lvar, method_name.to_sym]]
           return mapped if mapped
         end
+
         if receiver_node.type == :send
           recv, meth = *receiver_node
           if meth == :[] && env_node?(recv)
@@ -253,6 +262,7 @@ module HomuraRuntime
               mapped = @registry.async_accessors[[env_name(recv), key.to_sym]]
               return mapped if mapped
             end
+
             lvar = env_name(recv)
             mapped = @registry.async_accessors[[lvar, method_name.to_sym]]
             return mapped if mapped
@@ -262,6 +272,7 @@ module HomuraRuntime
             mapped = @registry.async_accessors[[lvar, method_name.to_sym]]
             return mapped if mapped
           end
+
           parent_cls = infer_env_accessor(recv, meth) if recv&.type == :send
           return parent_cls if parent_cls
         elsif receiver_node.type == :lvar
@@ -269,6 +280,7 @@ module HomuraRuntime
           mapped = @registry.async_accessors[[lvar, method_name.to_sym]]
           return mapped if mapped
         end
+
         nil
       end
 
@@ -288,11 +300,12 @@ module HomuraRuntime
           parts.unshift(n.children[1])
           n = n.children[0]
         end
+
         parts.join("::")
       end
 
       def debug(msg)
-        puts "[auto-await] #{msg}" if @debug
+        puts("[auto-await] #{msg}") if @debug
       end
     end
   end

data/lib/homura/runtime/auto_await/transformer.rb

@@ -13,6 +13,7 @@ module HomuraRuntime
           next if already_awaited?(buffer, range)
           rewriter.replace(range, "#{range.source}.__await__")
         end
+
         rewriter.process
       end
 

data/lib/homura/runtime/build_support.rb

@@ -8,6 +8,11 @@ module HomuraRuntime
     RUNTIME_GEM_NAME = "homura-runtime"
     SINATRA_GEM_NAME = "sinatra-homura"
     SEQUEL_D1_GEM_NAME = "sequel-d1"
+    SUPPORTED_OPAL_ENTRY_GEMS = %w[phlex literal].freeze
+    OPAL_ENTRY_COMPAT_REQUIRES = {
+      "phlex" => "phlex/opal_compat",
+      "literal" => "literal/opal_compat"
+    }.freeze
 
     class << self
       def loaded_spec(name, loaded_specs: Gem.loaded_specs)
@@ -66,7 +71,8 @@ module HomuraRuntime
         runtime_root(
           current_file: current_file,
           loaded_specs: loaded_specs
-        ).join("runtime", *names)
+        )
+          .join("runtime", *names)
       end
 
       def ensure_standalone_runtime(
@@ -137,8 +143,7 @@ module HomuraRuntime
         # app code.
         opal_gem_paths(root, loaded_specs: loaded_specs).each do |gem_path|
           basename = gem_path.basename.to_s
-          rewritten_lib =
-            root.join("build", "auto_await", "gem_#{basename}", "lib")
+          rewritten_lib = root.join("build", "auto_await", "gem_#{basename}", "lib")
           load_paths << rewritten_lib.to_s if rewritten_lib.directory?
           %w[lib vendor].each do |sub|
             dir = gem_path.join(sub)
@@ -165,12 +170,9 @@ module HomuraRuntime
         return unless gf.file?
 
         txt = gf.read
-        unless (
-                 m =
-                   txt.match(
-                     /#{Regexp.escape(RUNTIME_GEM_NAME)}['"]\s*,\s*path:\s*['"]([^'"]+)['"]/
-                   )
-               )
+        unless (m = txt.match(
+            /#{Regexp.escape(RUNTIME_GEM_NAME)}['"]\s*,\s*path:\s*['"]([^'"]+)['"]/
+          ))
           return
         end
 
@@ -190,6 +192,10 @@ module HomuraRuntime
         out = []
         out.concat(path_gemfile_entries(project_root))
 
+        entry_specs = opal_entry_gem_specs(loaded_specs: loaded_specs)
+        out.concat(entry_specs.map { |spec| Pathname(spec.full_gem_path) if spec.full_gem_path }.compact)
+        out.concat(opal_dependency_paths(entry_specs, loaded_specs: loaded_specs))
+
         loaded_specs.each_value do |spec|
           next if wired.include?(spec.name)
           meta = spec.metadata
@@ -204,6 +210,78 @@ module HomuraRuntime
         out.uniq
       end
 
+      def opal_entry_gem_specs(loaded_specs: Gem.loaded_specs)
+        names = SUPPORTED_OPAL_ENTRY_GEMS + env_opal_gem_names
+        names.uniq.filter_map { |name| loaded_specs[name] }
+      end
+
+      def opal_dependency_paths(specs, loaded_specs: Gem.loaded_specs)
+        seen = {}
+        out = []
+        queue = specs.flat_map { |spec| spec.runtime_dependencies.map(&:name) }
+
+        until queue.empty?
+          name = queue.shift
+          next if seen[name]
+          seen[name] = true
+
+          spec = loaded_specs[name]
+          next unless spec&.full_gem_path
+
+          path = Pathname(spec.full_gem_path)
+          out << path if path.directory?
+          queue.concat(spec.runtime_dependencies.map(&:name))
+        end
+
+        out
+      end
+
+      def write_opal_gems_prelude(project_root, loaded_specs: Gem.loaded_specs)
+        entry_specs = opal_entry_gem_specs(loaded_specs: loaded_specs)
+        return nil if entry_specs.empty?
+
+        root = Pathname(project_root)
+        out = root.join("build", "homura_opal_gems.rb")
+        lines = ["# frozen_string_literal: true", ""]
+        entry_specs.each do |spec|
+          next unless spec.full_gem_path
+
+          lib = Pathname(spec.full_gem_path).join("lib")
+          next unless lib.directory?
+
+          lines << "require_tree #{lib.to_s.inspect}, autoload: true"
+        end
+
+        lines << ""
+        lines << "require \"zeitwerk/opal_compat\""
+        entry_specs.each do |spec|
+          compat = OPAL_ENTRY_COMPAT_REQUIRES[spec.name]
+          next unless compat && spec.full_gem_path
+
+          lib = Pathname(spec.full_gem_path).join("lib")
+          root_file = lib.join("#{spec.name}.rb")
+          next unless root_file.file?
+
+          root_require = root_file.to_s.delete_suffix(".rb")
+          lines << "Zeitwerk.__homura_next_gem_root = #{root_file.to_s.inspect}"
+          lines << "require #{root_require.inspect}"
+          lines << "`Opal.loaded([#{spec.name.inspect}])`"
+          lines << "require #{compat.inspect}"
+        end
+
+        FileUtils.mkdir_p(out.dirname)
+        File.write(out, lines.join("\n") << "\n")
+        out
+      end
+
+      def env_opal_gem_names(env = ENV)
+        env
+          .fetch("HOMURA_OPAL_GEMS", "")
+          .split(/[\s,]+/)
+          .map(&:strip)
+          .reject(&:empty?)
+      end
+
       # Returns absolute Pathnames for every `path:`-declared gem in the
       # project's Gemfile that should ship in the Workers bundle.
       #
@@ -235,11 +313,11 @@ module HomuraRuntime
           next if stripped.empty? || stripped.start_with?("#")
 
           if (m = stripped.match(/\Agroup\s+(.+?)\s+do\b/))
-            groups =
-              m[1].scan(/[:'"]([A-Za-z0-9_]+)['"]?/).flatten.map(&:to_sym)
+            groups = m[1].scan(/[:'"]([A-Za-z0-9_]+)['"]?/).flatten.map(&:to_sym)
             group_stack.push(groups)
             next
           end
+
           if stripped == "end"
             group_stack.pop unless group_stack.empty?
             next
@@ -256,6 +334,7 @@ module HomuraRuntime
           gem_path = Pathname.new(rel).expand_path(project_root)
           out << gem_path if gem_path.directory?
         end
+
         out.uniq
       end
     end