ruby-http-session 1.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0787793708be50172480874386353726e9c1ea3c84a78dd3850772d8f5e0a5df'
-  data.tar.gz: '0519180cc38ad17de9f85cb24758c9e057f6e847868b05203ac4b566eecf9329'
+  metadata.gz: cfd1a068f4386cf1a7965a369a01283836a314425141cdfedfdd14edb0330d88
+  data.tar.gz: 6efc3597fa28d442fd793a24a9dc9a1020a1effc123bdad55fbd116470f2c641
 SHA512:
-  metadata.gz: 734e2a67d0719a07fec84366fbb3bdd1417302a38b3c881db1a832870ecb3ade5006419f49041b4e29e55f8c310e4b77b92e824d9fef1815a20f7bb20bf6ac0e
-  data.tar.gz: ee8338fc2a6ab4026d41fa9cd8f3e96cb61662d54e5b5c26c9f57df1ca8c9a005989d8529764b5638760723ec8c819e452d13fc24edfd72ec650ec6f6ad385d8
+  metadata.gz: 4b03ee19f4e6cbdb1f74ff6046e0f11edae268821ee76408614c505a9adcb8c06614415d0b042acf84db09a833eda46623cb4d1e906bc4f3db3afb0133edae9f
+  data.tar.gz: c1fdd8b754c9fa7fbbcb18d4f7383ffee61dcc7a296a5f2c170a700606afcc8e46b92971196dc92994b8f4e34f54db12a46932578095bd77eff78706b00f676d

data/Gemfile

@@ -8,6 +8,7 @@ gemspec
 # optional dependencies
 gem "activesupport", "~> 7.0"
 gem "brotli", platforms: :ruby
+gem "sqlite3", platforms: :ruby
 
 # rake
 gem "rake", "~> 13.0"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ruby-http-session (1.0.1)
+    ruby-http-session (2.1.0)
       http (~> 5.1, >= 5.1.1)
 
 GEM
@@ -125,6 +125,7 @@ GEM
       thor (~> 1.0)
       tilt (~> 2.0)
       yard (~> 0.9, >= 0.9.24)
+    sqlite3 (1.6.7-x86_64-linux)
     standard (1.31.1)
       language_server-protocol (~> 3.17.0.2)
       lint_roller (~> 1.0)
@@ -169,6 +170,7 @@ DEPENDENCIES
   rubocop (~> 1.29)
   ruby-http-session!
   solargraph
+  sqlite3
   standard (~> 1.3)
   timecop
   vcr

data/README.md

@@ -1,6 +1,23 @@
 # HTTP::Session
 
-HTTP::Session - a session abstraction for [http.rb] in order to support **cookies** and **caching**.
+HTTP::Session - a session abstraction for [http.rb] in order to support **Cookies** and **Caching**.
+
+```ruby
+require "http-session"
+require "logger"
+
+http = HTTP.session(
+  cookies: true,
+  cache: {private: true, store: [:file_store, "./tmp/cache"]},
+  persistent: {pools: {"https://httpbin.org" => true}}
+)
+  .timeout(8)
+  .follow
+  .use(logging: {logger: Logger.new($stdout)})
+  .freeze
+
+http.get("https://httpbin.org/get")
+```
 
 
 ## Quickstart
@@ -15,81 +32,55 @@ gem 'ruby-http-session', require: "http-session"
 
 ### Cookies
 
-The cookies are set automatically each time a request is made:
+Use `cookies: true` to enable this feature. Once enabled, the cookies are
+automatically set each time a request is made.
 
 ```ruby
 require "http-session"
 
 http = HTTP.session(cookies: true)
-  .follow
   .freeze
 
-r = http.get("https://httpbin.org/cookies/set/mycookies/abc")
+r = http.get("https://httpbin.org/cookies/set/mycookies/abc", follow: true)
 pp JSON.parse(r.body)["cookies"]  # -> {"mycookies"=>"abc"}
 
 r = http.get("https://httpbin.org/cookies")
 pp JSON.parse(r.body)["cookies"]  # -> {"mycookies"=>"abc"}
-
-http.jar.map { |c| pp [c.domain, c.path, c.to_s] }  # => ["httpbin.org", "/", "mycookies=abc"]
 ```
 
 ### Caching
 
-When responses can be reused from a cache, taking into account [HTTP RFC 9111] rules for user agents and
-shared caches. The following headers are used to determine whether the response is cacheable or not:
-
-* `Cache-Control` request header
-  * `no-store`
-  * `no-cache`
-* `Cache-Control` response header
-  * `no-store`
-  * `no-cache`
-  * `private`
-  * `public`
-  * `max-age`
-  * `s-maxage`
-* `Etag` & `Last-Modified` response header for conditional requests
-* `Vary` response header for content negotiation
-
-**This takes 60 times to deliver the request to the origin server:**
+Use `cache: true` to enable this feature. Once enabled, the `Cache-Control`
+will be used to determine whether the response is cacheable or not.
 
 ```ruby
-require "active_support/all"
-require "http"
-
-ActiveSupport::Notifications.subscribe('start_request.http') do |name, start, finish, id, payload|
-  pp start: start, req: payload[:request].inspect
-end
+require "http-session"
 
-http = HTTP
-  .follow
-  .timeout(8)
-  .use(instrumentation: { instrumenter: ActiveSupport::Notifications.instrumenter })
+http = HTTP.session(cache: true)
+  .freeze
 
+# takes only 1 time to deliver the request to the origin server
 60.times do
-  http.get("https://cdn.jsdelivr.net/npm/jquery@3.6.4/dist/jquery.min.js", headers: {"Accept-Encoding" => ""})
+  http.get("https://cdn.jsdelivr.net/npm/jquery@3.6.4/dist/jquery.min.js")
 end
 ```
 
-**This only takes 1 time to deliver the request to the origin server:**
+### Persistent Connections (Keep-Alive)
+
+Use `persistent: true` to enable this feature. Once enabled, the connection pools
+will be used to manage persistent connections.
 
 ```ruby
-require "active_support/all"
 require "http-session"
 
-ActiveSupport::Notifications.subscribe('start_request.http') do |name, start, finish, id, payload|
-  pp start: start, req: payload[:request].inspect
-end
-
-http = HTTP.session(cache: true)
-  .follow
-  .timeout(8)
-  .use(instrumentation: { instrumenter: ActiveSupport::Notifications.instrumenter })
+http = HTTP.session(persistent: true)
   .freeze
 
-60.times do
-  http.get("https://cdn.jsdelivr.net/npm/jquery@3.6.4/dist/jquery.min.js", headers: {"Accept-Encoding" => ""})
-end
+http.get("https://httpbin.org/get") # create a persistent connection#1
+http.get("https://httpbin.org/get") # reuse connection#1
+
+http.get("https://example.org")     # create a persistent connection#2
+http.get("https://example.org")     # reuse connection#2
 ```
 
 
@@ -97,29 +88,45 @@ end
 
 ### Caching
 
+When responses can be reused from a cache, taking into account [HTTP RFC 9111] rules for user agents and
+shared caches. The following headers are used to determine whether the response is cacheable or not:
+
+* `Cache-Control` request header
+  * `no-store`
+  * `no-cache`
+* `Cache-Control` response header
+  * `no-store`
+  * `no-cache`
+  * `private`
+  * `public`
+  * `max-age`
+  * `s-maxage`
+* `Etag` & `Last-Modified` response header for conditional requests
+* `Vary` response header for content negotiation
+
 #### Shared Cache
 
 A [shared cache] is a cache that stores responses for **reuse by more than one user**; shared caches
 are usually (but not always) deployed as a part of an intermediary. **This is used by default**.
 
+**Note**: Responses for requests with **Authorization** header fields will not be stored in a shared
+cache unless explicitly allowed. Read [rfc9111#section-3.5] for more.
+
 ```ruby
 http = HTTP.session(cache: true) # or HTTP.session(cache: {shared: true})
-  .follow
-  .timeout(4)
-  .use(hsf_auto_inflate: {br: true})
   .freeze
 
 res = http.get("https://cdn.jsdelivr.net/npm/jquery@3.6.4/dist/jquery.min.js")
-p "cache-status: #{res.headers["x-httprb-cache-status"]}" # => miss
+pp "Cache-Status: #{res.headers["X-Httprb-Cache-Status"]}" # -> "Cache-Status: MISS"
 
 res = http.get("https://cdn.jsdelivr.net/npm/jquery@3.6.4/dist/jquery.min.js")
-p "cache-status: #{res.headers["x-httprb-cache-status"]}" # => hit
+pp "Cache-Status: #{res.headers["X-Httprb-Cache-Status"]}" # -> "Cache-Status: HIT"
 
-res = http.get("https://cdn.jsdelivr.net/npm/jquery@3.6.4/dist/jquery.min.js", headers: {"cache-control" => "no-cache"})
-p "cache-status: #{res.headers["x-httprb-cache-status"]}" # => revalidated
+res = http.get("https://cdn.jsdelivr.net/npm/jquery@3.6.4/dist/jquery.min.js", headers: {"Cache-Control" => "no-cache"})
+pp "Cache-Status: #{res.headers["X-Httprb-Cache-Status"]}" # -> "Cache-Status: REVALIDATED"
 
-res = http.get("https://cdn.jsdelivr.net/npm/jquery@3.6.4/dist/jquery.min.js", headers: {"cache-control" => "no-store"})
-p "cache-status: #{res.headers["x-httprb-cache-status"]}" # => uncacheable
+res = http.get("https://cdn.jsdelivr.net/npm/jquery@3.6.4/dist/jquery.min.js", headers: {"Cache-Control" => "no-store"})
+pp "Cache-Status: #{res.headers["X-Httprb-Cache-Status"]}" # -> "Cache-Status: UNCACHEABLE"
 ```
 
 #### Private Cache
@@ -129,9 +136,6 @@ component of a user agent.
 
 ```ruby
 http = HTTP.session(cache: {private: true})
-  .follow
-  .timeout(4)
-  .use(hsf_auto_inflate: {br: true})
   .freeze
 ```
 
@@ -143,9 +147,6 @@ can use ths `:store` option to set another store, e.g. `ActiveSupport::Cache::Me
 ```ruby
 store = ActiveSupport::Cache::MemCacheStore.new("localhost", "server-downstairs.localnetwork:8229")
 http = HTTP.session(cache: {store: store})
-  .follow
-  .timeout(4)
-  .use(hsf_auto_inflate: {br: true})
   .freeze
 ```
 
@@ -159,14 +160,109 @@ The following value is used in the `X-Httprb-Cache-Status` response header:
 * **MISS**: not found in cache, served from the origin server
 * **UNCACHEABLE**: the request can not use cached response
 
+### Persistent Connections (Keep-Alive)
+
+```ruby
+http = HTTP.session(persistent: {
+  pools: {
+    "https://example.org" => false,
+    "https://httpbin.org" => {maxsize: 2},
+    "*" => true
+  }
+}).freeze
+
+# match host: "https://example.org"
+#   -> create a non-persistent connection
+http.get("https://example.org")
+
+# match host: "https://httpbin.org"
+#   -> create a connection pool with maxsize 2, and return a persistent connection
+http.get("https://httpbin.org/get")
+
+# match host: "*"
+#   -> create a connection pool with maxsize 5, and return a persistent connection
+http.get("https://github.com")
+```
+
+### Thread Safe
+
+The following **HTTP::Session** methods are thread-safe:
+
+* **head**
+* **get**
+* **post**
+* **put**
+* **delete**
+* **trace**
+* **options**
+* **connect**
+* **patch**
+* **request**
+
 ### HTTP::Features
 
-The following features are available with `http-session`:
+#### logging
+
+Log requests and responses.
+
+```ruby
+require "http-session"
+require "logger"
+
+http = HTTP.session
+  .use(logging: { logger: Logger.new($stdout) })
+  .freeze
 
-* [logging]: Log requests and responses.
-* [instrumentation]: Instrument requests and responses. Expects an ActiveSupport::Notifications-compatible instrumenter.
-* [hsf_auto_inflate]: Simlar to [auto_inflate], used for automatically decompressing the response body.
-* etc.
+http.get("https://httpbin.org/get")
+# I, [2023-10-07T13:17:42.208296 #2708620]  INFO -- : > GET https://httpbin.org/get
+# D, [2023-10-07T13:17:42.208349 #2708620] DEBUG -- : Connection: close
+# Host: httpbin.org
+# User-Agent: http.rb/5.1.1
+# ...
+```
+
+#### instrumentation
+
+Instrument requests and responses. Expects an ActiveSupport::Notifications-compatible instrumenter.
+
+```ruby
+require "http-session"
+require "active_support/all"
+
+ActiveSupport::Notifications.subscribe('start_request.http') do |name, start, finish, id, payload|
+  pp start: start, req: payload[:request].inspect
+end
+
+ActiveSupport::Notifications.subscribe('request.http') do |name, start, finish, id, payload|
+  pp start: start, req: payload[:request].inspect, res: payload[:response].inspect
+end
+
+http = HTTP.session
+  .use(instrumentation: { instrumenter: ActiveSupport::Notifications.instrumenter })
+  .freeze
+
+http.get("https://httpbin.org/get")
+# {:start=>2023-10-07 13:14:36.953487129 +0800, :req=>"#<HTTP::Request/1.1 GET https://httpbin.org/get>"}
+# {:start=>2023-10-07 13:14:36.954112865 +0800,
+#  :req=>"nil",
+#  :res=>"#<HTTP::Response/1.1 200 OK {\"Date\"=>\"Sat, 07 Oct 2023 05:14:37 GMT\", \"Content-Type\"=>\"application/json\", \"Content-Length\"=>\"236\", \"Connection\"=>\"close\", \"Server\"=>\"gunicorn/19.9.0\", \"Access-Control-Allow-Origin\"=>\"*\", \"Access-Control-Allow-Credentials\"=>\"true\", \"X-Httprb-Cache-Status\"=>\"MISS\"}>"}
+```
+
+#### hsf_auto_inflate
+
+Simlar to `auto_inflate`, used for automatically decompressing the response body.
+
+```ruby
+require "http-session"
+require "brotli"
+
+http = HTTP.session
+  .use(hsf_auto_inflate: {br: true})
+  .freeze
+
+res = http.get("https://cdn.jsdelivr.net/npm/jquery@3.6.4/dist/jquery.min.js", headers: {"Accept-Encoding" => "br"})
+pp res.body.to_s  # => "/*! jQuery v3.6.4 | ...
+```
 
 ### Intergate with WebMock
 
@@ -198,10 +294,7 @@ Everyone interacting in the HTTP::Session project's codebases, issue trackers, c
 
 
 [HTTP RFC 9111]:https://datatracker.ietf.org/doc/html/rfc9111/
+[rfc9111#section-3.5]:https://datatracker.ietf.org/doc/html/rfc9111/#section-3.5
 [shared cache]:https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching#shared_cache
 [private cache]:https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching#private_caches
 [http.rb]:https://github.com/httprb/http
-[logging]:https://github.com/httprb/http/wiki/Logging-and-Instrumentation#logging
-[instrumentation]:https://github.com/httprb/http/wiki/Logging-and-Instrumentation#instrumentation
-[auto_inflate]:https://github.com/httprb/http/wiki/Compression#automatic-inflating
-[hsf_auto_inflate]:https://github.com/souk4711/http-session/blob/main/lib/http/session/features/auto_inflate.rb

data/http-session.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.authors = ["John Doe"]
   spec.email = ["johndoe@example.com"]
 
-  spec.summary = "HTTP::Session - a session abstraction for http.rb in order to support cookies and caching."
-  spec.description = "HTTP::Session - a session abstraction for http.rb in order to support cookies and caching."
+  spec.summary = "HTTP::Session - a session abstraction for http.rb in order to support Cookies and Caching."
+  spec.description = "HTTP::Session - a session abstraction for http.rb in order to support Cookies and Caching."
   spec.homepage = "https://github.com/souk4711/http-session"
   spec.license = "MIT"
   spec.required_ruby_version = ">= 2.6.0"

data/lib/http/session/cache.rb

@@ -1,18 +1,33 @@
 class HTTP::Session
   class Cache
+    extend Forwardable
     include MonitorMixin
 
+    # @!method enabled?
+    #   True when it is enabled.
+    #   @return [Boolean]
+    def_delegator :@options, :enabled?
+
+    # @!method shared_cache?
+    #   True when it is a shared cache.
+    #   @return [Boolean]
+    def_delegator :@options, :shared_cache?
+
+    # @!method private_cache?
+    #   True when it is a private cache.
+    #   @return [Boolean]
+    def_delegator :@options, :private_cache?
+
     # @param [Options::CacheOption] options
     def initialize(options)
       super()
-
       @options = options
     end
 
     # Read an entry from cache.
     #
     # @param [Request] req
-    # @return [Entry]
+    # @return [nil, Entry]
     def read(req)
       synchronize do
         key = cache_key_for(req)
@@ -37,21 +52,6 @@ class HTTP::Session
       end
     end
 
-    # True when it is a shared cache.
-    def shared?
-      @options.shared_cache?
-    end
-
-    # True when it is a private cache.
-    def private?
-      @options.private_cache?
-    end
-
-    # @!visibility private
-    def store
-      @options.store
-    end
-
     private
 
     def entry_matched?(entry, req)
@@ -91,5 +91,10 @@ class HTTP::Session
     def cache_key_for(req)
       Digest::SHA256.hexdigest(req.uri)
     end
+
+    # Only available when #enbled? has the value true.
+    def store
+      @options.store
+    end
   end
 end

data/lib/http/session/client/perform.rb

@@ -40,6 +40,12 @@ class HTTP::Session
         raise
       end
 
+      def close
+        @connection&.close
+        @connection = nil
+        @state = :clean
+      end
+
       private
 
       def verify_connection!(uri)
@@ -50,12 +56,6 @@ class HTTP::Session
         close if @state == :dirty
       end
 
-      def close
-        @connection&.close
-        @connection = nil
-        @state = :clean
-      end
-
       def build_response(req, options)
         res = HTTP::Response.new(
           status: @connection.status_code,
@@ -77,7 +77,7 @@ class HTTP::Session
       end
 
       def build_request(verb, uri, opts = {})
-        opts = @default_options.merge(opts)
+        opts = default_options.merge(opts)
         uri = make_request_uri(uri, opts)
         headers = make_request_headers(opts)
         body = make_request_body(opts, headers)

data/lib/http/session/client.rb

@@ -9,69 +9,93 @@ class HTTP::Session
       @session = session
     end
 
+    # Make an HTTP request.
+    #
     # @param verb
     # @param uri
     # @param [Hash] opts
+    # @param [nil, Context] ctx
     # @return [Response]
-    def request(verb, uri, opts)
-      data = @session.make_http_request_data
-      hist = []
-
-      opts = @default_options.merge(opts)
-      opts = _hs_handle_http_request_options_cookies(opts, data[:cookies])
-      opts = _hs_handle_http_request_options_follow(opts, hist)
-
-      req = build_request(verb, uri, opts)
-      res = perform(req, opts)
-      return res unless opts.follow
-
-      HTTP::Redirector.new(opts.follow).perform(req, res) do |request|
-        request = HTTP::Session::Request.new(request)
-        perform(request, opts)
-      end.tap do |res|
-        res.history = hist
-      end
+    def request(verb, uri, opts, ctx)
+      opts = default_options.merge(opts)
+      opts = _hs_handle_http_request_options_cookies(uri, opts)
+
+      req = _hs_build_request(verb, uri, opts, ctx)
+      res = _hs_perform(req, opts)
+      _hs_cookies_save(res)
+
+      res
     end
 
     private
 
-    # Make an HTTP request.
-    #
-    # @param [Request] req
-    # @param [HTTP::Options] opts
-    # @return [Response]
-    def perform(req, opts)
-      req = wrap_request(req, opts)
-      wrap_response(_hs_perform(req, opts), opts)
+    # Add session cookies to the request's :cookies.
+    def _hs_handle_http_request_options_cookies(uri, opts)
+      cookies = _hs_cookies_load(uri)
+      cookies.nil? ? opts : opts.with_cookies(cookies)
     end
 
-    # Add session cookie to the request's :cookies.
-    def _hs_handle_http_request_options_cookies(opts, cookies)
-      return opts if cookies.nil?
-      opts.with_cookies(cookies)
+    # Load cookies.
+    def _hs_cookies_load(uri)
+      return unless @session.cookies_mgr.enabled?
+      @session.cookies_mgr.read(uri)
     end
 
-    # Wrap the :on_redirect method in the request's :follow.
-    def _hs_handle_http_request_options_follow(opts, hist)
-      return opts unless opts.follow
+    # Save cookies.
+    def _hs_cookies_save(res)
+      return unless @session.cookies_mgr.enabled?
+      @session.cookies_mgr.write(res)
+    end
 
-      follow = (opts.follow == true) ? {} : opts.follow
-      opts.with_follow(follow.merge(
-        on_redirect: _hs_handle_http_request_options_follow_hijack(follow[:on_redirect], hist)
-      ))
+    # Build a HTTP request.
+    def _hs_build_request(verb, uri, opts, ctx)
+      return build_request(verb, uri, opts) unless ctx&.follow
+      _hs_build_redirection_request(verb, uri, opts, ctx.follow)
     end
 
-    # Wrap the :on_redirect method.
-    def _hs_handle_http_request_options_follow_hijack(fn, hist)
-      lambda do |res, req|
-        hist << res
-        fn.call(res, req) if fn.respond_to?(:call)
+    # Build a HTTP request for redirection.
+    def _hs_build_redirection_request(verb, uri, opts, ctx)
+      opts = default_options.merge(opts)
+      headers = make_request_headers(opts)
+      body = make_request_body(opts, headers)
+
+      # Drop body when non-GET methods changed to GET.
+      if ctx.should_drop_body?
+        body = nil
+        headers.delete(HTTP::Headers::CONTENT_TYPE)
+        headers.delete(HTTP::Headers::CONTENT_LENGTH)
+      end
+
+      # Remove Authorization header when rediecting cross site.
+      if ctx.cross_origin?
+        headers.delete(HTTP::Headers::AUTHORIZATION)
       end
+
+      # Build a request.
+      req = HTTP::Request.new(
+        verb: verb,
+        uri: uri,
+        uri_normalizer: opts.feature(:normalize_uri)&.normalizer,
+        proxy: opts.proxy,
+        headers: headers,
+        body: body
+      )
+      HTTP::Session::Request.new(req)
     end
 
-    # Make an HTTP request using cache.
+    # Perform a single HTTP request.
+    #
+    # @param [Request] req
+    # @param [HTTP::Options] opts
+    # @return [Response]
     def _hs_perform(req, opts)
-      if @session.default_options.cache.enabled?
+      req = wrap_request(req, opts)
+      wrap_response(_hs_perform_no_features(req, opts), opts)
+    end
+
+    # Perform a single HTTP request without any features.
+    def _hs_perform_no_features(req, opts)
+      if @session.cache_mgr.enabled?
         req.cacheable? ? _hs_cache_lookup(req, opts) : _hs_cache_pass(req, opts)
       else
         _hs_forward(req, opts)
@@ -86,10 +110,10 @@ class HTTP::Session
     #     entry with the backend using conditional GET.
     #   * When no matching cache entry is found, trigger miss processing.
     def _hs_cache_lookup(req, opts)
-      entry = @session.cache.read(req)
+      entry = @session.cache_mgr.read(req)
       if entry.nil?
         _hs_cache_fetch(req, opts)
-      elsif entry.response.fresh?(shared: @session.cache.shared?) &&
+      elsif entry.response.fresh?(shared: @session.cache_mgr.shared_cache?) &&
           !entry.response.no_cache? &&
           !req.no_cache?
         _hs_cache_reuse(req, opts, entry)
@@ -144,14 +168,16 @@ class HTTP::Session
 
     # Store the response to cache.
     def _hs_cache_entry_store(req, res)
-      if res.cacheable?(shared: @session.cache.shared?, req: req)
-        @session.cache.write(req, res)
+      if res.cacheable?(shared: @session.cache_mgr.shared_cache?, req: req)
+        @session.cache_mgr.write(req, res)
       end
     end
 
     # Delegate the request to the backend and create the response.
     def _hs_forward(req, opts)
-      httprb_perform(req, opts)
+      res = httprb_perform(req, opts)
+      res.flush if default_options.persistent?
+      res
     end
   end
 end

data/lib/http/session/configurable.rb

@@ -135,8 +135,7 @@ class HTTP::Session
     private
 
     # :nodoc:
-    def branch(default_options)
-      raise FrozenError, "can't modify frozen #{self.class.name}" if frozen?
+    def branch(_default_options)
       self
     end
   end