homura-runtime 0.3.6 → 0.3.7

data/lib/homura/runtime/build_support.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require 'fileutils'
-require 'pathname'
+require "fileutils"
+require "pathname"
 
 module HomuraRuntime
   module BuildSupport
-    RUNTIME_GEM_NAME = 'homura-runtime'
-    SINATRA_GEM_NAME = 'sinatra-homura'
-    SEQUEL_D1_GEM_NAME = 'sequel-d1'
+    RUNTIME_GEM_NAME = "homura-runtime"
+    SINATRA_GEM_NAME = "sinatra-homura"
+    SEQUEL_D1_GEM_NAME = "sequel-d1"
 
     class << self
       def loaded_spec(name, loaded_specs: Gem.loaded_specs)
@@ -18,22 +18,24 @@ module HomuraRuntime
         spec = loaded_spec(name, loaded_specs: loaded_specs)
         return spec.full_gem_path if spec
 
-        raise("homura build: gem #{name} not loaded; use bundle exec from app root")
+        raise(
+          "homura build: gem #{name} not loaded; use bundle exec from app root"
+        )
       end
 
       def runtime_root(current_file:, loaded_specs: Gem.loaded_specs)
         spec = loaded_spec(RUNTIME_GEM_NAME, loaded_specs: loaded_specs)
         return Pathname(spec.full_gem_path) if spec
 
-        Pathname(current_file).expand_path.join('../..')
+        Pathname(current_file).expand_path.join("../..")
       end
 
       def gem_lib(name, loaded_specs: Gem.loaded_specs)
-        File.join(gem_root(name, loaded_specs: loaded_specs), 'lib')
+        File.join(gem_root(name, loaded_specs: loaded_specs), "lib")
       end
 
       def gem_vendor(name, loaded_specs: Gem.loaded_specs)
-        vendor = File.join(gem_root(name, loaded_specs: loaded_specs), 'vendor')
+        vendor = File.join(gem_root(name, loaded_specs: loaded_specs), "vendor")
         return vendor if Dir.exist?(vendor)
 
         nil
@@ -43,64 +45,82 @@ module HomuraRuntime
         spec = loaded_spec(name, loaded_specs: loaded_specs)
         return nil unless spec
 
-        File.join(spec.full_gem_path, 'lib')
+        File.join(spec.full_gem_path, "lib")
       end
 
       def maybe_gem_vendor(name, loaded_specs: Gem.loaded_specs)
         spec = loaded_spec(name, loaded_specs: loaded_specs)
         return nil unless spec
 
-        vendor = File.join(spec.full_gem_path, 'vendor')
+        vendor = File.join(spec.full_gem_path, "vendor")
         return vendor if Dir.exist?(vendor)
 
         nil
       end
 
-      def runtime_file(*names, current_file: __FILE__, loaded_specs: Gem.loaded_specs)
-        runtime_root(current_file: current_file, loaded_specs: loaded_specs).join('runtime', *names)
+      def runtime_file(
+        *names,
+        current_file: __FILE__,
+        loaded_specs: Gem.loaded_specs
+      )
+        runtime_root(
+          current_file: current_file,
+          loaded_specs: loaded_specs
+        ).join("runtime", *names)
       end
 
-      def ensure_standalone_runtime(project_root, current_file: __FILE__, loaded_specs: Gem.loaded_specs)
+      def ensure_standalone_runtime(
+        project_root,
+        current_file: __FILE__,
+        loaded_specs: Gem.loaded_specs
+      )
         # The homura runtime needs two .mjs glue files alongside the
         # generated `worker.entrypoint.mjs`. Until 0.2.22 we wrote them
         # to `cf-runtime/` at the project root, which made every Ruby
         # repo carry two opaque JS files in source control. Hide them
         # under `build/cf-runtime/` so the build artifact tree owns
         # them — `build/` is already in the example .gitignore template.
-        target_dir = Pathname(project_root).join('build', 'cf-runtime')
+        target_dir = Pathname(project_root).join("build", "cf-runtime")
         FileUtils.mkdir_p(target_dir)
 
         %w[setup-node-crypto.mjs worker_module.mjs].each do |name|
-          FileUtils.cp(runtime_file(name, current_file: current_file, loaded_specs: loaded_specs), target_dir.join(name))
+          FileUtils.cp(
+            runtime_file(
+              name,
+              current_file: current_file,
+              loaded_specs: loaded_specs
+            ),
+            target_dir.join(name)
+          )
         end
 
         target_dir
       end
 
-      def standalone_load_paths(project_root, with_db:, loaded_specs: Gem.loaded_specs)
+      def standalone_load_paths(
+        project_root,
+        with_db:,
+        loaded_specs: Gem.loaded_specs
+      )
         root = Pathname(project_root)
         load_paths = []
 
         hv = vendor_from_gemfile(root)
         load_paths << hv.to_s if hv
 
-        load_paths += ['.', 'build/auto_await', 'build/auto_await/app', 'app']
+        load_paths += %w[. build/auto_await build/auto_await/app app]
         [
           gem_lib(RUNTIME_GEM_NAME, loaded_specs: loaded_specs),
           gem_vendor(RUNTIME_GEM_NAME, loaded_specs: loaded_specs),
           maybe_gem_lib(SINATRA_GEM_NAME, loaded_specs: loaded_specs),
           maybe_gem_vendor(SINATRA_GEM_NAME, loaded_specs: loaded_specs)
-        ].compact.each do |path|
-          load_paths << path
-        end
+        ].compact.each { |path| load_paths << path }
 
         if with_db
           [
             gem_vendor(SEQUEL_D1_GEM_NAME, loaded_specs: loaded_specs),
             gem_lib(SEQUEL_D1_GEM_NAME, loaded_specs: loaded_specs)
-          ].compact.each do |path|
-            load_paths << path
-          end
+          ].compact.each { |path| load_paths << path }
         end
 
         # Pick up any other gems that should ship in the Workers bundle:
@@ -117,7 +137,8 @@ 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)
@@ -125,8 +146,8 @@ module HomuraRuntime
           end
         end
 
-        load_paths << 'vendor' if root.join('vendor').directory?
-        load_paths << 'build'
+        load_paths << "vendor" if root.join("vendor").directory?
+        load_paths << "build"
         load_paths.uniq
       end
 
@@ -134,20 +155,27 @@ module HomuraRuntime
         base = Pathname(project_root).basename.to_s
         parts = base.split(/[^A-Za-z0-9]+/).reject(&:empty?)
         module_name = parts.map { |part| part[0].upcase + part[1..].to_s }.join
-        module_name = 'App' if module_name.empty?
+        module_name = "App" if module_name.empty?
         module_name = "App#{module_name}" if module_name.match?(/\A\d/)
         "#{module_name}#{suffix}"
       end
 
       def vendor_from_gemfile(project_root)
-        gf = Pathname(project_root).join('Gemfile')
+        gf = Pathname(project_root).join("Gemfile")
         return unless gf.file?
 
         txt = gf.read
-        return 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
 
         runtime_path = Pathname.new(m[1]).expand_path(project_root)
-        vend = runtime_path.join('..', '..', 'vendor').expand_path
+        vend = runtime_path.join("..", "..", "vendor").expand_path
         vend if vend.directory?
       end
 
@@ -166,8 +194,8 @@ module HomuraRuntime
           next if wired.include?(spec.name)
           meta = spec.metadata
           next unless meta.is_a?(Hash)
-          flag = meta['homura.auto_await']
-          next unless flag == 'true' || flag == true
+          flag = meta["homura.auto_await"]
+          next unless flag == "true" || flag == true
           next if spec.full_gem_path.nil?
           gem_path = Pathname(spec.full_gem_path)
           out << gem_path if gem_path.directory?
@@ -185,10 +213,17 @@ module HomuraRuntime
       # * `require: false` gems (dev tooling like `gem 'rspec', path: ..., require: false`)
       # * gems declared inside `group :development do … end` /
       #   `group :test do … end` blocks (they don't ship to production)
-      EXCLUDED_GROUPS = %i[development test dev_test development_test ci tools].freeze
+      EXCLUDED_GROUPS = %i[
+        development
+        test
+        dev_test
+        development_test
+        ci
+        tools
+      ].freeze
 
       def path_gemfile_entries(project_root)
-        gf = Pathname(project_root).join('Gemfile')
+        gf = Pathname(project_root).join("Gemfile")
         return [] unless gf.file?
 
         wired = [RUNTIME_GEM_NAME, SINATRA_GEM_NAME, SEQUEL_D1_GEM_NAME]
@@ -197,14 +232,15 @@ module HomuraRuntime
 
         gf.read.each_line do |line|
           stripped = line.strip
-          next if stripped.empty? || stripped.start_with?('#')
+          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'
+          if stripped == "end"
             group_stack.pop unless group_stack.empty?
             next
           end

data/lib/homura/runtime/cache.rb

@@ -50,7 +50,7 @@ module Cloudflare
     attr_reader :operation
     def initialize(message, operation: nil)
       @operation = operation
-      super("[Cloudflare::Cache] op=#{operation || 'match'}: #{message}")
+      super("[Cloudflare::Cache] op=#{operation || "match"}: #{message}")
     end
   end
 
@@ -62,7 +62,10 @@ module Cloudflare
     # Returns a fresh wrapper each call; the underlying JS object is a
     # singleton per isolate.
     def self.default
-      Cache.new(`(typeof caches !== 'undefined' && caches ? caches.default : null)`, 'default')
+      Cache.new(
+        `(typeof caches !== 'undefined' && caches ? caches.default : null)`,
+        "default"
+      )
     end
 
     # caches.open(name) — named cache partitions. Returns a JS Promise
@@ -71,12 +74,13 @@ module Cloudflare
     # don't re-open the handle.
     def self.open(name)
       name_str = name.to_s
-      js_promise = `(typeof caches !== 'undefined' && caches && caches.open ? caches.open(#{name_str}) : Promise.resolve(null))`
+      js_promise =
+        `(typeof caches !== 'undefined' && caches && caches.open ? caches.open(#{name_str}) : Promise.resolve(null))`
       js_cache = js_promise.__await__
       Cache.new(js_cache, name_str)
     end
 
-    def initialize(js_cache, name = 'default')
+    def initialize(js_cache, name = "default")
       @js_cache = js_cache
       @name = name.to_s
     end
@@ -109,19 +113,22 @@ module Cloudflare
       # JS Request. Derive the URL from the same shapes supported by
       # `request_to_js` so the `url` field on the returned
       # HTTPResponse is always a real URL.
-      url_str = if request_or_url.is_a?(String)
-                  request_or_url
-                elsif defined?(Cloudflare::HTTPResponse) && request_or_url.is_a?(Cloudflare::HTTPResponse)
-                  request_or_url.url.to_s
-                elsif `(#{request_or_url} != null && typeof #{request_or_url} === 'object' && typeof #{request_or_url}.url === 'string')`
-                  `String(#{request_or_url}.url)`
-                else
-                  request_or_url.to_s
-                end
+      url_str =
+        if request_or_url.is_a?(String)
+          request_or_url
+        elsif defined?(Cloudflare::HTTPResponse) &&
+              request_or_url.is_a?(Cloudflare::HTTPResponse)
+          request_or_url.url.to_s
+        elsif `(#{request_or_url} != null && typeof #{request_or_url} === 'object' && typeof #{request_or_url}.url === 'string')`
+          `String(#{request_or_url}.url)`
+        else
+          request_or_url.to_s
+        end
 
       # Single-line backtick IIFE — see `put` for the Opal multi-line
       # x-string quirk that silently drops the returned Promise.
-      js_promise = `(async function(js, req, Kernel, err_klass) { if (js == null || js === Opal.nil) return null; var cached; try { cached = await js.match(req); } catch (e) { Kernel.$raise(err_klass.$new(e && e.message ? e.message : String(e), Opal.hash({ operation: 'match' }))); } if (cached == null) return null; var text = ''; try { text = await cached.text(); } catch (_) { text = ''; } var hk = []; var hv = []; if (cached.headers && typeof cached.headers.forEach === 'function') { cached.headers.forEach(function(v, k) { hk.push(String(k).toLowerCase()); hv.push(String(v)); }); } return { status: cached.status|0, text: text, hkeys: hk, hvals: hv }; })(#{js}, #{req}, #{Kernel}, #{err_klass})`
+      js_promise =
+        `(async function(js, req, Kernel, err_klass) { if (js == null || js === Opal.nil) return null; var cached; try { cached = await js.match(req); } catch (e) { Kernel.$raise(err_klass.$new(e && e.message ? e.message : String(e), Opal.hash({ operation: 'match' }))); } if (cached == null) return null; var text = ''; try { text = await cached.text(); } catch (_) { text = ''; } var hk = []; var hv = []; if (cached.headers && typeof cached.headers.forEach === 'function') { cached.headers.forEach(function(v, k) { hk.push(String(k).toLowerCase()); hv.push(String(v)); }); } return { status: cached.status|0, text: text, hkeys: hk, hvals: hv }; })(#{js}, #{req}, #{Kernel}, #{err_klass})`
       js_result = js_promise.__await__
       return nil if `#{js_result} == null`
 
@@ -135,10 +142,10 @@ module Cloudflare
         i += 1
       end
       response_klass.new(
-        status:  `#{js_result}.status`,
+        status: `#{js_result}.status`,
         headers: h,
-        body:    `#{js_result}.text`,
-        url:     url_str
+        body: `#{js_result}.text`,
+        url: url_str
       )
     end
 
@@ -203,17 +210,17 @@ module Cloudflare
     # support but the impl only covered JS Request-like objects — both
     # the docs AND the code now line up.)
     def request_to_js(request_or_url)
-      if request_or_url.is_a?(String)
-        return `new Request(#{request_or_url})`
-      end
-      if defined?(Cloudflare::HTTPResponse) && request_or_url.is_a?(Cloudflare::HTTPResponse)
+      return `new Request(#{request_or_url})` if request_or_url.is_a?(String)
+      if defined?(Cloudflare::HTTPResponse) &&
+           request_or_url.is_a?(Cloudflare::HTTPResponse)
         url_str = request_or_url.url.to_s
         return `new Request(#{url_str})`
       end
       if `(#{request_or_url} != null && typeof #{request_or_url} === 'object' && typeof #{request_or_url}.url === 'string')`
         return request_or_url
       end
-      raise ArgumentError, "Cloudflare::Cache request must be a String URL, Cloudflare::HTTPResponse, or JS Request (got #{request_or_url.class})"
+      raise ArgumentError,
+            "Cloudflare::Cache request must be a String URL, Cloudflare::HTTPResponse, or JS Request (got #{request_or_url.class})"
     end
 
     def ruby_headers_to_js(hash)