homura-runtime 0.3.2 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b09e022b298cf614eddee1e206a91e8f1e8ac62dbd649bbaf493c17bd9867dc
-  data.tar.gz: 8e79929b358d8273307da2522890afdd6ab2c19c9e7281cf66eb4cca0c858878
+  metadata.gz: deee61a6cf85e633844b5e18df6da9658294bd10db266c1d2525760369610d98
+  data.tar.gz: a40ad24b9012f798ee0eb90e1b11bc819e9cd8d8aa418c73482208d3ffc58303
 SHA512:
-  metadata.gz: 4869cd52bc0e24b9a4427145bce641c678d1ffd8de391e984a0dd6238df2fc2ac2bcd67108326f079a44c23b17ce77ef7310717941575860efd024311083d92c
-  data.tar.gz: 44a8fd2d0846fb0939b79da88ce792ce574114a22046b5cb4b6bc9420559c2b780d813a75fba2c177d489996d963142136f2bdeafb95cb347314c308dbc07e8e
+  metadata.gz: 5ddc0b574901b97a3c50db3389c41acbcff7ea5e2990483c4edb46cd08ddf4d2c2ee7e950acec6b4d6ea0ad09f3e470c423428cbbadc5c271bbf2cf3c1532095
+  data.tar.gz: 38959a44892a5ddac26d1d31e4087ee333efda1d840aed96abab9f3971449f96aa7012c22068b3da6a260c57ffb4d7e564c2d7baf753bb20c4574b185d9ac5b3

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.3.4 (2026-05-02)
+
+- Package the Rack vendor files in `homura-runtime` itself. The 0.3.3
+  release made Sinatra optional in the build path, but Rack-only apps
+  still needed `rack/request` through `homura/runtime/multipart`; that
+  worked from the monorepo checkout and failed from the published gem.
+
+## 0.3.3 (2026-05-02)
+
+- Make standalone Rack-only builds work without `sinatra-homura` in the
+  bundle. `BuildSupport.standalone_load_paths` now treats Sinatra load
+  paths as optional while keeping the existing Sinatra app path unchanged.
+- Keep generated empty ERB registries Sinatra-free. Apps with no `.erb`
+  templates no longer emit the Sinatra ERB hook, so a Rack-only app can
+  compile with `homura-runtime` alone.
+- Guard static-asset middleware auto-installation so the generated asset
+  bundle only calls `Sinatra::Base.use` when a real Sinatra app is loaded.
+
 ## 0.3.2 (2026-04-30)
 
 - README: replace the leftover `require 'cloudflare_workers'` line and

data/exe/compile-assets

@@ -151,8 +151,8 @@ File.open(out_path, 'w') do |io|
 
   io.puts <<~RUBY
 
-    # Auto-install the middleware on Sinatra::Base if Sinatra is loaded.
-    if defined?(::Sinatra::Base)
+    # Auto-install the middleware on Sinatra::Base if a real Sinatra app is loaded.
+    if defined?(::Sinatra::Base) && ::Sinatra::Base.respond_to?(:use)
       ::Sinatra::Base.use #{ns}::Middleware
     end
   RUBY

data/exe/compile-erb

@@ -515,11 +515,9 @@ template_root = positional.find { |a| File.directory?(a) } || options[:input_dir
 write_file = !options[:stdout] && (positional.empty? || options[:output])
 out_path = options[:output]
 
-# An app with zero ERB templates (e.g. an example that builds HTML
-# inline with Ruby heredocs) is a valid case: still emit the registry
-# header + Sinatra dispatcher patch so `erb :foo` raises a clear error
-# at runtime instead of silently disappearing, and so the build
-# pipeline doesn't fail when there is nothing to compile.
+# An app with zero ERB templates is valid, including Rack-only apps
+# that do not ship sinatra-homura at all. Emit the empty registry, but
+# skip the Sinatra hook so `homura-runtime` remains Sinatra-free.
 if inputs.empty?
   warn "compile-erb: no .erb files under #{options[:input_dir]}/ — writing empty registry"
 end
@@ -529,11 +527,11 @@ if write_file
   File.open(out_path, 'w') do |io|
     emit_header(io, namespace)
     emit_templates(io, inputs, namespace, template_root)
-    emit_sinatra_patch(io, namespace)
+    emit_sinatra_patch(io, namespace) unless inputs.empty?
   end
   warn "compile-erb: wrote #{out_path} (#{inputs.size} templates)"
 else
   emit_header($stdout, namespace)
   emit_templates($stdout, inputs, namespace, template_root)
-  emit_sinatra_patch($stdout, namespace)
+  emit_sinatra_patch($stdout, namespace) unless inputs.empty?
 end

data/lib/homura/runtime/build_support.rb

@@ -39,6 +39,23 @@ module HomuraRuntime
         nil
       end
 
+      def maybe_gem_lib(name, loaded_specs: Gem.loaded_specs)
+        spec = loaded_spec(name, loaded_specs: loaded_specs)
+        return nil unless spec
+
+        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')
+        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)
       end
@@ -71,8 +88,8 @@ module HomuraRuntime
         [
           gem_lib(RUNTIME_GEM_NAME, loaded_specs: loaded_specs),
           gem_vendor(RUNTIME_GEM_NAME, loaded_specs: loaded_specs),
-          gem_lib(SINATRA_GEM_NAME, loaded_specs: loaded_specs),
-          gem_vendor(SINATRA_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

data/lib/homura/runtime/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HomuraRuntime
-  VERSION = '0.3.2'
+  VERSION = '0.3.4'
 end

data/vendor/rack/auth/abstract/handler.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative '../../constants'
+
+module Rack
+  module Auth
+    # Rack::Auth::AbstractHandler implements common authentication functionality.
+    #
+    # +realm+ should be set for all handlers.
+
+    class AbstractHandler
+
+      attr_accessor :realm
+
+      def initialize(app, realm = nil, &authenticator)
+        @app, @realm, @authenticator = app, realm, authenticator
+      end
+
+
+      private
+
+      def unauthorized(www_authenticate = challenge)
+        return [ 401,
+          { CONTENT_TYPE => 'text/plain',
+            CONTENT_LENGTH => '0',
+            'www-authenticate' => www_authenticate.to_s },
+          []
+        ]
+      end
+
+      def bad_request
+        return [ 400,
+          { CONTENT_TYPE => 'text/plain',
+            CONTENT_LENGTH => '0' },
+          []
+        ]
+      end
+
+    end
+  end
+end

data/vendor/rack/auth/abstract/request.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# XXX: Remove when removing AbstractRequest#request
+require_relative '../../request'
+
+module Rack
+  module Auth
+    class AbstractRequest
+
+      def initialize(env)
+        @env = env
+      end
+
+      def request
+        warn "Rack::Auth::AbstractRequest#request is deprecated and will be removed in a future version of rack.", uplevel: 1
+        @request ||= Request.new(@env)
+      end
+
+      def provided?
+        !authorization_key.nil? && valid?
+      end
+
+      def valid?
+        !@env[authorization_key].nil?
+      end
+
+      def parts
+        @parts ||= @env[authorization_key].split(' ', 2)
+      end
+
+      def scheme
+        @scheme ||= parts.first&.downcase
+      end
+
+      def params
+        @params ||= parts.last
+      end
+
+
+      private
+
+      AUTHORIZATION_KEYS = ['HTTP_AUTHORIZATION', 'X-HTTP_AUTHORIZATION', 'X_HTTP_AUTHORIZATION']
+
+      def authorization_key
+        @authorization_key ||= AUTHORIZATION_KEYS.detect { |key| @env.has_key?(key) }
+      end
+
+    end
+
+  end
+end

data/vendor/rack/auth/basic.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative 'abstract/handler'
+require_relative 'abstract/request'
+
+module Rack
+  module Auth
+    # Rack::Auth::Basic implements HTTP Basic Authentication, as per RFC 2617.
+    #
+    # Initialize with the Rack application that you want protecting,
+    # and a block that checks if a username and password pair are valid.
+
+    class Basic < AbstractHandler
+
+      def call(env)
+        auth = Basic::Request.new(env)
+
+        return unauthorized unless auth.provided?
+
+        return bad_request unless auth.basic?
+
+        if valid?(auth)
+          env['REMOTE_USER'] = auth.username
+
+          return @app.call(env)
+        end
+
+        unauthorized
+      end
+
+
+      private
+
+      def challenge
+        'Basic realm="%s"' % realm
+      end
+
+      def valid?(auth)
+        @authenticator.call(*auth.credentials)
+      end
+
+      class Request < Auth::AbstractRequest
+        def basic?
+          "basic" == scheme && credentials.length == 2
+        end
+
+        def credentials
+          @credentials ||= params.unpack1('m').split(':', 2)
+        end
+
+        def username
+          credentials.first
+        end
+      end
+
+    end
+  end
+end

data/vendor/rack/bad_request.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Rack
+  # Represents a 400 Bad Request error when input data fails to meet the
+  # requirements.
+  module BadRequest
+  end
+end

data/vendor/rack/body_proxy.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Rack
+  # Proxy for response bodies allowing calling a block when
+  # the response body is closed (after the response has been fully
+  # sent to the client).
+  class BodyProxy
+    # Set the response body to wrap, and the block to call when the
+    # response has been fully sent.
+    def initialize(body, &block)
+      @body = body
+      @block = block
+      @closed = false
+    end
+
+    # Return whether the wrapped body responds to the method.
+    def respond_to_missing?(method_name, include_all = false)
+      case method_name
+      when :to_str
+        false
+      else
+        super or @body.respond_to?(method_name, include_all)
+      end
+    end
+
+    # If not already closed, close the wrapped body and
+    # then call the block the proxy was initialized with.
+    def close
+      return if @closed
+      @closed = true
+      begin
+        @body.close if @body.respond_to?(:close)
+      ensure
+        @block.call
+      end
+    end
+
+    # Whether the proxy is closed.  The proxy starts as not closed,
+    # and becomes closed on the first call to close.
+    def closed?
+      @closed
+    end
+
+    # Delegate missing methods to the wrapped body.
+    def method_missing(method_name, *args, &block)
+      case method_name
+      when :to_str
+        super
+      when :to_ary
+        begin
+          @body.__send__(method_name, *args, &block)
+        ensure
+          close
+        end
+      else
+        @body.__send__(method_name, *args, &block)
+      end
+    end
+    # :nocov:
+    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+    # :nocov:
+  end
+end

data/vendor/rack/builder.rb

@@ -0,0 +1,315 @@
+# backtick_javascript: true
+# frozen_string_literal: true
+
+require_relative 'urlmap'
+
+module Rack; end
+Rack::BUILDER_TOPLEVEL_BINDING = ->(builder){builder.instance_eval{binding}}
+
+module Rack
+  # Rack::Builder provides a domain-specific language (DSL) to construct Rack
+  # applications. It is primarily used to parse +config.ru+ files which
+  # instantiate several middleware and a final application which are hosted
+  # by a Rack-compatible web server.
+  #
+  # Example:
+  #
+  #   app = Rack::Builder.new do
+  #     use Rack::CommonLogger
+  #     map "/ok" do
+  #       run lambda { |env| [200, {'content-type' => 'text/plain'}, ['OK']] }
+  #     end
+  #   end
+  #
+  #   run app
+  #
+  # Or
+  #
+  #   app = Rack::Builder.app do
+  #     use Rack::CommonLogger
+  #     run lambda { |env| [200, {'content-type' => 'text/plain'}, ['OK']] }
+  #   end
+  #
+  #   run app
+  #
+  # +use+ adds middleware to the stack, +run+ dispatches to an application.
+  # You can use +map+ to construct a Rack::URLMap in a convenient way.
+  class Builder
+
+    # https://stackoverflow.com/questions/2223882/whats-the-difference-between-utf-8-and-utf-8-without-bom
+    UTF_8_BOM = '\xef\xbb\xbf'
+
+    # Parse the given config file to get a Rack application.
+    #
+    # If the config file ends in +.ru+, it is treated as a
+    # rackup file and the contents will be treated as if
+    # specified inside a Rack::Builder block.
+    #
+    # If the config file does not end in +.ru+, it is
+    # required and Rack will use the basename of the file
+    # to guess which constant will be the Rack application to run.
+    #
+    # Examples:
+    #
+    #   Rack::Builder.parse_file('config.ru')
+    #   # Rack application built using Rack::Builder.new
+    #
+    #   Rack::Builder.parse_file('app.rb')
+    #   # requires app.rb, which can be anywhere in Ruby's
+    #   # load path. After requiring, assumes App constant
+    #   # is a Rack application
+    #
+    #   Rack::Builder.parse_file('./my_app.rb')
+    #   # requires ./my_app.rb, which should be in the
+    #   # process's current directory.  After requiring,
+    #   # assumes MyApp constant is a Rack application
+    def self.parse_file(path, **options)
+      if path.end_with?('.ru')
+        return self.load_file(path, **options)
+      else
+        require path
+        return Object.const_get(::File.basename(path, '.rb').split('_').map(&:capitalize).join(''))
+      end
+    end
+
+    # Load the given file as a rackup file, treating the
+    # contents as if specified inside a Rack::Builder block.
+    #
+    # Ignores content in the file after +__END__+, so that
+    # use of +__END__+ will not result in a syntax error.
+    #
+    # Example config.ru file:
+    #
+    #   $ cat config.ru
+    #
+    #   use Rack::ContentLength
+    #   require './app.rb'
+    #   run App
+    def self.load_file(path, **options)
+      config = ::File.read(path)
+      config.slice!(/\A#{UTF_8_BOM}/) if config.encoding == Encoding::UTF_8
+
+      if config[/^#\\(.*)/]
+        fail "Parsing options from the first comment line is no longer supported: #{path}"
+      end
+
+      config.sub!(/^__END__\n.*\Z/m, '')
+
+      return new_from_string(config, path, **options)
+    end
+
+    # Evaluate the given +builder_script+ string in the context of
+    # a Rack::Builder block, returning a Rack application.
+    def self.new_from_string(builder_script, path = "(rackup)", **options)
+      builder = self.new(**options)
+
+      # We want to build a variant of TOPLEVEL_BINDING with self as a Rack::Builder instance.
+      # We cannot use instance_eval(String) as that would resolve constants differently.
+      binding = BUILDER_TOPLEVEL_BINDING.call(builder)
+      eval(builder_script, binding, path)
+
+      return builder.to_app
+    end
+
+    # Initialize a new Rack::Builder instance.  +default_app+ specifies the
+    # default application if +run+ is not called later.  If a block
+    # is given, it is evaluated in the context of the instance.
+    def initialize(default_app = nil, **options, &block)
+      @use = []
+      @map = nil
+      @run = default_app
+      @warmup = nil
+      @freeze_app = false
+      @options = options
+
+      instance_eval(&block) if block_given?
+    end
+
+    # Any options provided to the Rack::Builder instance at initialization.
+    # These options can be server-specific. Some general options are:
+    #
+    # * +:isolation+: One of +process+, +thread+ or +fiber+. The execution
+    #   isolation model to use.
+    attr :options
+
+    # Create a new Rack::Builder instance and return the Rack application
+    # generated from it.
+    def self.app(default_app = nil, &block)
+      self.new(default_app, &block).to_app
+    end
+
+    # Specifies middleware to use in a stack.
+    #
+    #   class Middleware
+    #     def initialize(app)
+    #       @app = app
+    #     end
+    #
+    #     def call(env)
+    #       env["rack.some_header"] = "setting an example"
+    #       @app.call(env)
+    #     end
+    #   end
+    #
+    #   use Middleware
+    #   run lambda { |env| [200, { "content-type" => "text/plain" }, ["OK"]] }
+    #
+    # All requests through to this application will first be processed by the middleware class.
+    # The +call+ method in this example sets an additional environment key which then can be
+    # referenced in the application if required.
+    def use(middleware, *args, &block)
+      if @map
+        mapping, @map = @map, nil
+        @use << proc { |app| generate_map(app, mapping) }
+      end
+      @use << proc { |app| middleware.new(app, *args, &block) }
+
+      nil
+    end
+    # :nocov:
+    ruby2_keywords(:use) if respond_to?(:ruby2_keywords, true)
+    # :nocov:
+
+    # Takes a block or argument that is an object that responds to #call and
+    # returns a Rack response.
+    #
+    # You can use a block:
+    #
+    #   run do |env|
+    #     [200, { "content-type" => "text/plain" }, ["Hello World!"]]
+    #   end
+    #
+    # You can also provide a lambda:
+    #
+    #   run lambda { |env| [200, { "content-type" => "text/plain" }, ["OK"]] }
+    #
+    # You can also provide a class instance:
+    #
+    #   class Heartbeat
+    #     def call(env)
+    #      [200, { "content-type" => "text/plain" }, ["OK"]]
+    #     end
+    #   end
+    #
+    #   run Heartbeat.new
+    #
+    def run(app = nil, &block)
+      raise ArgumentError, "Both app and block given!" if app && block_given?
+
+      @run = app || block
+
+      nil
+    end
+
+    # Takes a lambda or block that is used to warm-up the application. This block is called
+    # before the Rack application is returned by to_app.
+    #
+    #   warmup do |app|
+    #     client = Rack::MockRequest.new(app)
+    #     client.get('/')
+    #   end
+    #
+    #   use SomeMiddleware
+    #   run MyApp
+    def warmup(prc = nil, &block)
+      @warmup = prc || block
+    end
+
+    # Creates a route within the application.  Routes under the mapped path will be sent to
+    # the Rack application specified by run inside the block.  Other requests will be sent to the
+    # default application specified by run outside the block.
+    #
+    #   class App
+    #     def call(env)
+    #       [200, {'content-type' => 'text/plain'}, ["Hello World"]]
+    #     end
+    #   end
+    #
+    #   class Heartbeat
+    #     def call(env)
+    #       [200, { "content-type" => "text/plain" }, ["OK"]]
+    #     end
+    #   end
+    #
+    #   app = Rack::Builder.app do
+    #     map '/heartbeat' do
+    #       run Heartbeat.new
+    #     end
+    #     run App.new
+    #   end
+    #
+    #   run app
+    #
+    # The +use+ method can also be used inside the block to specify middleware to run under a specific path:
+    #
+    #   app = Rack::Builder.app do
+    #     map '/heartbeat' do
+    #       use Middleware
+    #       run Heartbeat.new
+    #     end
+    #     run App.new
+    #   end
+    #
+    # This example includes a piece of middleware which will run before +/heartbeat+ requests hit +Heartbeat+.
+    #
+    # Note that providing a +path+ of +/+ will ignore any default application given in a +run+ statement
+    # outside the block.
+    def map(path, &block)
+      @map ||= {}
+      @map[path] = block
+
+      nil
+    end
+
+    # Freeze the app (set using run) and all middleware instances when building the application
+    # in to_app.
+    def freeze_app
+      @freeze_app = true
+    end
+
+    # Return the Rack application generated by this instance.
+    def to_app
+      app = @map ? generate_map(@run, @map) : @run
+      fail "missing run or map statement" unless app
+      app.freeze if @freeze_app
+      # homura patch: neither Array#inject nor an `each` block with
+      # a closured local variable reliably threads the middleware
+      # accumulator through the chain on Opal (the closure copy of
+      # `acc` does not propagate). Use an index-based loop so the
+      # accumulator lives in a single function scope without closures.
+      list = @use.reverse
+      app = wrap_middleware_chain(list, app)
+      @warmup.call(app) if @warmup
+      app
+    end
+
+    def wrap_middleware_chain(list, initial)
+      acc = initial
+      i = 0
+      n = list.length
+      while i < n
+        acc = list[i].call(acc)
+        acc.freeze if @freeze_app
+        i += 1
+      end
+      acc
+    end
+
+    # Call the Rack application generated by this builder instance. Note that
+    # this rebuilds the Rack application and runs the warmup code (if any)
+    # every time it is called, so it should not be used if performance is important.
+    def call(env)
+      to_app.call(env)
+    end
+
+    private
+
+    # Generate a URLMap instance by generating new Rack applications for each
+    # map block in this instance.
+    def generate_map(default_app, mapping)
+      mapped = default_app ? { '/' => default_app } : {}
+      mapping.each { |r, b| mapped[r] = self.class.new(default_app, &b).to_app }
+      URLMap.new(mapped)
+    end
+  end
+end