gemstack-http 0.2.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4cbadcf688b9a992018d023466d08ca082e49323441d528e23375ba26a0d89fc
-  data.tar.gz: ba64e5a829531d7ab7cd73ab70ea453dffa4a4cc0ecb9c66a67d444fe9ff4f19
+  metadata.gz: 76c2d6bc8341e9d2009eeabf8e1da44fc25fa8aece61edc88a18138a16441090
+  data.tar.gz: 4b6e6bb5adab8141ed61d05042004684a91293f4d1ee3574ddafc6c5e68f5a08
 SHA512:
-  metadata.gz: fc46b5f8dcc656eab4661289d22451475fa0999e94ec446e04ece6568e26bfefa08326da54bc1d26d594a55dc3d4c53254a8865ff03497a648b680b9b2915acc
-  data.tar.gz: 325a5da3292c61de2f4fad3bbee3d2c52ad7db1bb893056bbb09b3e407a7b0f508cb0112627843e434dfd6c42984b7709f6138f116a7577af45f8f01f90f33a6
+  metadata.gz: 5a1d7fd696f8113164fd6df369218bb6c870dea2704e4165984281ac23dfba1165a4c08ee6e3fb2fbc96a756352eb460f152be162183fd093ecba36fa83c6a12
+  data.tar.gz: e653dbef0def88b2cc877ffd1ff7725bd0ff57ca207798a5803d0e1dfc31360effaf2762196124338c53c458d08d320b5d39f0523fc586332208b648ca74a0d9

data/CHANGELOG.md

@@ -1,25 +1,5 @@
 # Changelog
 
-## 0.2.4
+## 0.3.0
 
-See the [GemStack changelog](https://github.com/gemstack-rb/gemstack/blob/main/CHANGELOG.md).
-
-## 0.2.3
-
-See the [GemStack changelog](https://github.com/gemstack-rb/gemstack/blob/main/CHANGELOG.md).
-
-## 0.2.2
-
-See the [GemStack changelog](https://github.com/gemstack-rb/gemstack/blob/main/CHANGELOG.md).
-
-## 0.2.1
-
-See the [GemStack changelog](https://github.com/gemstack-rb/gemstack/blob/main/CHANGELOG.md).
-
-## 0.2.0
-
-See the [GemStack changelog](https://github.com/gemstack-rb/gemstack/blob/main/CHANGELOG.md).
-
-## 0.1.0
-
-First release. See the [GemStack changelog](https://github.com/gemstack-rb/gemstack/blob/main/CHANGELOG.md).
+Merged into the gemstack gem; this version is a transition shim. See the [GemStack changelog](https://github.com/gemstack-rb/gemstack/blob/main/CHANGELOG.md).

data/README.md

@@ -1,25 +1,13 @@
 # gemstack-http
 
-GemStack HTTP: router, middleware, controllers, params and JSON for Rack.
+**Merged into [`gemstack`](https://rubygems.org/gems/gemstack) in GemStack 0.3.0.**
 
-The API layer of GemStack, built on Rack 3.
+This version is a transition shim: it depends on `gemstack` and loads `gemstack/http`, so
+Gemfiles that still list `gemstack-http` keep working. To finish upgrading, remove `gem "gemstack-http"`
+from your Gemfile (it's loaded by `require "gemstack"`).
 
-Part of [GemStack](https://github.com/gemstack-rb/gemstack), a modular Ruby API framework for Next.js
-applications by [Adware Technologies](https://www.adwaretech.com). All GemStack gems are developed together in that repository and released with the same
-version.
-
-## Installation
-
-Installed with the `gemstack` gem; you rarely need to add it yourself.
-
-## Documentation
-
-- [Guide](https://github.com/gemstack-rb/gemstack/blob/main/docs/controllers.md)
-- [All guides](https://github.com/gemstack-rb/gemstack/tree/main/docs) ·
-  [Architecture](https://github.com/gemstack-rb/gemstack/blob/main/ARCHITECTURE.md)
-
-Source, issues and pull requests: [gemstack-rb/gemstack](https://github.com/gemstack-rb/gemstack)
-(this gem lives in `gems/gemstack-http`).
+GemStack is a modular Ruby API framework for Next.js applications by
+[Adware Technologies](https://www.adwaretech.com) — [gemstack-rb/gemstack](https://github.com/gemstack-rb/gemstack).
 
 ## License
 

data/lib/gemstack-http.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# gemstack-http is part of the gemstack gem since 0.3.0. This shim keeps Gemfiles
+# that still list gemstack-http working; remove the line from your Gemfile.
+require "gemstack/http"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gemstack-http
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
 platform: ruby
 authors:
 - Adware Technologies
@@ -11,62 +11,28 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: gemstack-core
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.2.4
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.2.4
-- !ruby/object:Gem::Dependency
-  name: gemstack-schema
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.2.4
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.2.4
-- !ruby/object:Gem::Dependency
-  name: json
+  name: gemstack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.10'
+        version: 0.3.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.10'
-- !ruby/object:Gem::Dependency
-  name: rack
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.1'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
+        version: 0.3.0
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '3.1'
-description: The API layer of GemStack, built on Rack 3.
+        version: '1.0'
+description: Since GemStack 0.3.0, gemstack-http is part of the gemstack gem. This
+  version only depends on gemstack and loads gemstack/http, so Gemfiles that still
+  list it keep working.
 email:
 - gemstack26@gmail.com
 executables: []
@@ -76,36 +42,18 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
-- lib/gemstack/http.rb
-- lib/gemstack/http/app.rb
-- lib/gemstack/http/config.rb
-- lib/gemstack/http/controller.rb
-- lib/gemstack/http/error_page.rb
-- lib/gemstack/http/error_renderer.rb
-- lib/gemstack/http/json_codec.rb
-- lib/gemstack/http/middleware/body_limit.rb
-- lib/gemstack/http/middleware/compression.rb
-- lib/gemstack/http/middleware/cors.rb
-- lib/gemstack/http/middleware/error_handler.rb
-- lib/gemstack/http/middleware/etags.rb
-- lib/gemstack/http/middleware/health_check.rb
-- lib/gemstack/http/middleware/request_id.rb
-- lib/gemstack/http/middleware/request_logger.rb
-- lib/gemstack/http/middleware/security_headers.rb
-- lib/gemstack/http/middleware_stack.rb
-- lib/gemstack/http/page.rb
-- lib/gemstack/http/params.rb
-- lib/gemstack/http/request.rb
-- lib/gemstack/http/router.rb
+- lib/gemstack-http.rb
 homepage: https://github.com/gemstack-rb/gemstack
 licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-  source_code_uri: https://github.com/gemstack-rb/gemstack/tree/main/gems/gemstack-http
-  changelog_uri: https://github.com/gemstack-rb/gemstack/blob/main/gems/gemstack-http/CHANGELOG.md
+  source_code_uri: https://github.com/gemstack-rb/gemstack
+  changelog_uri: https://github.com/gemstack-rb/gemstack/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/gemstack-rb/gemstack/issues
   documentation_uri: https://github.com/gemstack-rb/gemstack/tree/main/docs
+post_install_message: gemstack-http is now part of the gemstack gem. Remove `gem "gemstack-http"`
+  from your Gemfile (it's loaded by `require "gemstack"`).
 rdoc_options: []
 require_paths:
 - lib
@@ -122,5 +70,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.20
 specification_version: 4
-summary: 'GemStack HTTP: router, middleware, controllers, params and JSON for Rack'
+summary: Merged into the gemstack gem — remove gemstack-http from your Gemfile
 test_files: []

data/lib/gemstack/http/app.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module GemStack
-  module HTTP
-    # The Rack application: the compiled middleware stack in front of the
-    # router. Built once; the router can be replaced (for reloading) without
-    # rebuilding the stack.
-    class App
-      attr_reader :config, :codec
-      attr_accessor :router
-
-      def initialize(config:, router:)
-        @config = config
-        @router = router
-        @codec = JSONCodec.resolve(config.json, max_nesting: config.json_max_nesting)
-        @stack = config.middleware.build(method(:endpoint))
-      end
-
-      def call(env) = @stack.call(env)
-
-      private
-
-      def endpoint(env)
-        env[JSON_CODEC] = @codec
-        env[CONFIG] = @config
-        @router.call(env)
-      end
-    end
-  end
-end

data/lib/gemstack/http/config.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module GemStack
-  module HTTP
-    # `config.http` — every setting has a production-ready default.
-    class Config < Settings
-      # Where the API lives. Routes are declared relative to it, and the dev
-      # gateway uses it to send traffic to Ruby. "" mounts the API at the root.
-      setting :api_path, default: "/api"
-
-      # Liveness endpoint answered by HealthCheck. nil disables it.
-      setting :health_path, default: -> { "#{api_path}/health" }
-
-      # Maximum request body size in bytes (413 beyond it).
-      setting :max_body_size, default: 10 * 1024 * 1024
-
-      # JSON codec: :json (stdlib, default), :oj, or any object responding to
-      # dump(object) -> String and load(String) -> object.
-      setting :json, default: :json
-
-      # Maximum nesting depth accepted when parsing JSON request bodies.
-      setting :json_max_nesting, default: 64
-
-      # Include exception class, message and backtrace in 500 responses.
-      # Never enable in production.
-      setting :show_exceptions, default: -> { GemStack.env.local? }
-
-      # Accept X-Request-Id from clients/proxies (validated) instead of
-      # always generating one.
-      setting :trust_request_id, default: true
-
-      # Headers added to every response unless the response already sets them.
-      setting :security_headers, default: {
-        "x-content-type-options" => "nosniff",
-        "x-frame-options" => "DENY",
-        "referrer-policy" => "strict-origin-when-cross-origin",
-        "cross-origin-opener-policy" => "same-origin",
-        "content-security-policy" => "default-src 'none'; frame-ancestors 'none'"
-      }
-
-      # Strict-Transport-Security for HTTPS requests. nil disables.
-      setting :hsts, default: -> { GemStack.env.production? ? "max-age=63072000; includeSubDomains" : nil }
-
-      # Cross-origin access. Off by default: same-origin apps need none.
-      namespace :cors do
-        # Allowed origins: exact strings, Regexps, or "*".
-        setting :origins, default: []
-        setting :methods, default: %w[GET POST PUT PATCH DELETE OPTIONS]
-        setting :headers, default: %w[content-type authorization x-request-id]
-        setting :expose_headers, default: %w[x-request-id]
-        setting :credentials, default: false
-        setting :max_age, default: 600
-      end
-
-      # Response compression (Middleware::Compression).
-      namespace :compression do
-        setting :enabled, default: true
-        # Bodies smaller than this are sent as they are (compression overhead
-        # outweighs the savings on tiny responses).
-        setting :min_size, default: 1024
-        # Server preference; "br" is used only when the brotli gem is installed.
-        setting :encodings, default: %w[br gzip]
-        # Measured on varied JSON (docs/performance.md): gzip 4 costs half the
-        # CPU of gzip 6 for ~2% larger output; Brotli 4 is smaller than gzip 4 and cheaper.
-        setting :brotli_quality, default: 4
-        setting :gzip_level, default: 4
-      end
-
-      # ETags for GET/HEAD responses and 304 Not Modified (Rack::ETag + Rack::ConditionalGet).
-      setting :etags, default: true
-
-      # Defaults for `paginate` in controllers.
-      namespace :pagination do
-        setting :per_page, default: 25
-        setting :max_per_page, default: 100
-      end
-
-      # The middleware stack. Edit it with use / insert_before / insert_after /
-      # swap / delete. Middleware receive this config and read it when the
-      # application is built, so settings may be changed in any order.
-      setting :middleware, default: -> { MiddlewareStack.default(self) }
-    end
-  end
-end

data/lib/gemstack/http/controller.rb

@@ -1,343 +0,0 @@
-# frozen_string_literal: true
-
-require "digest"
-require "time"
-
-module GemStack
-  module HTTP
-    # Base class for API controllers.
-    #
-    #   class ProductsController < ApplicationController
-    #     before :load_product, only: %i[show update]
-    #     rescue_from Payments::Declined, status: 402
-    #
-    #     def index = render(Product.all)
-    #     def show = render(@product)
-    #
-    #     def create
-    #       product = Product.create!(params.require(:product).permit(:name, :price))
-    #       render product, status: :created
-    #     end
-    #
-    #     private
-    #
-    #     def load_product = @product = Product.find(params[:id])
-    #   end
-    #
-    # Actions are the public methods defined in subclasses. An action that
-    # doesn't render responds 204 No Content. A `before` callback that
-    # renders halts the chain and the action is skipped.
-    class Controller
-      class DoubleRenderError < Error; end
-      class ActionNotFound < Error; end
-
-      Callback = Struct.new(:callback_method, :block, :only, :except) do
-        def applies?(action)
-          (only.nil? || only.include?(action)) && (except.nil? || !except.include?(action))
-        end
-      end
-
-      RescueHandler = Struct.new(:classes, :handler, :status, :code)
-
-      class << self
-        def before_callbacks = @before_callbacks ||= inherited_copy(:before_callbacks)
-        def after_callbacks = @after_callbacks ||= inherited_copy(:after_callbacks)
-        def rescue_handlers = @rescue_handlers ||= inherited_copy(:rescue_handlers)
-
-        # before :authenticate, only: %i[create update]
-        # before { render({ error: "..." }, status: 401) unless ok? }
-        def before(*methods, only: nil, except: nil, &block)
-          add_callbacks(before_callbacks, methods, block, only, except)
-        end
-
-        def after(*methods, only: nil, except: nil, &block)
-          add_callbacks(after_callbacks, methods, block, only, except)
-        end
-
-        def skip_before(*methods)
-          names = methods.map(&:to_sym)
-          @before_callbacks = before_callbacks.reject { |cb| names.include?(cb.callback_method) }
-        end
-
-        # rescue_from Stripe::CardError, with: :card_declined
-        # rescue_from Timeout::Error, status: 504, code: "upstream_timeout"
-        # rescue_from(MyError) { |error| render({ message: error.message }, status: 400) }
-        # Later declarations take precedence (they are checked first).
-        def rescue_from(*classes, with: nil, status: nil, code: nil, &block)
-          handler = with || block
-          raise ArgumentError, "rescue_from needs with:, a block, or status:" unless handler || status
-
-          rescue_handlers.unshift(RescueHandler.new(classes, handler, status, code))
-        end
-
-        # Declares the request schema for actions; `input` returns the
-        # validated, coerced data inside those actions (DECISIONS D-021).
-        #
-        #   accepts :create, with: Product.input_schema
-        #   accepts :update, with: Product.input_schema, partial: true
-        #   accepts(:search) { required :q, :string }
-        def accepts(*actions, with: nil, partial: false, &)
-          schema = with || Schema.define(&)
-          raise ArgumentError, "accepts needs with: SchemaClass or a block" unless schema
-
-          schema = schema.partial if partial
-          actions.each { |action| input_schemas[action.to_s] = schema }
-        end
-
-        def input_schemas = @input_schemas ||= inherited_copy(:input_schemas, {})
-
-        # Declares an action's response type for the API contract when the
-        # convention (<Resource>Serializer, see docs/typescript.md) doesn't apply:
-        #   returns :search, [ProductSerializer]
-        #   returns :stats, StatsSerializer
-        #   returns :ping, nil          # no body
-        def returns(*actions, type)
-          actions.each { |action| response_types[action.to_s] = type }
-        end
-
-        def response_types = @response_types ||= inherited_copy(:response_types, {})
-
-        # Public instance methods added by subclasses of Controller.
-        def action_methods
-          @action_methods ||= (public_instance_methods(true) - Controller.public_instance_methods(true))
-                              .to_set(&:to_s).freeze
-        end
-
-        def method_added(name)
-          super
-          @action_methods = nil
-        end
-
-        def dispatch(action, env)
-          raise ActionNotFound, "#{name}##{action} is not a public action" unless action_methods.include?(action)
-
-          new(env).process(action)
-        end
-
-        private
-
-        def inherited_copy(name, empty = [])
-          superclass.respond_to?(name) ? superclass.public_send(name).dup : empty
-        end
-
-        def add_callbacks(list, methods, block, only, except)
-          only &&= Array(only).map(&:to_s)
-          except &&= Array(except).map(&:to_s)
-          methods.each { |m| list << Callback.new(m.to_sym, nil, only, except) }
-          list << Callback.new(nil, block, only, except) if block
-        end
-      end
-
-      attr_reader :env, :request, :action_name
-
-      def initialize(env)
-        @env = env
-        @request = Request.new(env)
-        @response = nil
-        @response_headers = {}
-      end
-
-      def params
-        @params ||= Params.new(request.all_params)
-      end
-
-      # The validated input for the current action, as declared with `accepts`.
-      def input
-        @input ||= begin
-          schema = self.class.input_schemas[action_name] or
-            raise Error, "#{self.class.name}##{action_name} has no `accepts` declaration; use params.validate instead"
-          schema.call(params)
-        end
-      end
-
-      # Headers to add to the response. Set them before or after rendering.
-      def headers = @response_headers
-
-      def logger = GemStack.logger
-
-      def rendered? = !@response.nil?
-
-      # Renders value as JSON.
-      #   render product
-      #   render products, status: :ok
-      #   render({ ok: true }, status: 202, headers: { "cache-control" => "no-store" })
-      #   render product, serializer: Admin::ProductSerializer
-      def render(value = nil, status: 200, headers: {}, serializer: nil)
-        raise DoubleRenderError, "render/head called twice in #{self.class.name}##{action_name}" if rendered?
-
-        @response_headers.merge!(headers)
-        @response_headers["content-type"] ||= "application/json; charset=utf-8"
-        body = serializer ? apply_serializer(serializer, value) : serialize(value)
-        @response = [status_code(status), [codec.dump(body)]]
-      end
-
-      # Responds without a body: head :no_content, head 404
-      def head(status, headers = {})
-        raise DoubleRenderError, "render/head called twice in #{self.class.name}##{action_name}" if rendered?
-
-        @response_headers.merge!(headers)
-        @response = [status_code(status), []]
-      end
-
-      # Turns domain objects into JSON-ready structures. By convention an
-      # object of class Product is rendered with ProductSerializer (also for
-      # arrays and datasets of them). Values without a serializer go to the
-      # JSON codec as they are. Override for custom behaviour.
-      def serialize(value)
-        return { data: serialize(value.items), meta: value.meta } if value.is_a?(HTTP::Page)
-
-        Serializer.render(value, serializer_context)
-      end
-
-      # Paginates a dataset (or array) using the `page` and `per_page` query
-      # parameters, bounded by config.http.pagination:
-      #
-      #   render paginate(Product.order(:id))
-      #   render paginate(Product.where(active: true).order(:name), per_page: 50)
-      #
-      # Invalid values are a 422 with field errors. The dataset should be
-      # ordered, or pages may overlap.
-      def paginate(scope, per_page: nil)
-        settings = pagination_settings
-        max = settings.max_per_page
-        page, size = PAGE_SCHEMA.call(params).values_at(:page, :per_page)
-        size = (size || per_page || settings.per_page).clamp(1, max)
-        page ||= 1
-        total = scope.count
-        offset = (page - 1) * size
-        items = scope.is_a?(Array) ? scope[offset, size] || [] : scope.limit(size).offset(offset).all
-        HTTP::Page.new(items, page: page, per_page: size, total: total)
-      end
-
-      PAGE_SCHEMA = Schema.define do
-        optional :page, :integer, gte: 1
-        optional :per_page, :integer, gte: 1
-      end
-
-      # HTTP caching. Sets ETag / Last-Modified and answers 304 Not Modified
-      # (without rendering) when the client already has this version:
-      #
-      #   def show
-      #     product = Product.find(params[:id])
-      #     render product if stale?(etag: product, last_modified: product.updated_at)
-      #   end
-      #
-      # etag: any value; records use #cache_key when they have one.
-      def stale?(etag: nil, last_modified: nil)
-        headers["etag"] = %(W/"#{Digest::SHA256.hexdigest(etag_source(etag))[0, 32]}") unless etag.nil?
-        headers["last-modified"] = last_modified.httpdate if last_modified
-        return true unless fresh?
-
-        head :not_modified
-        false
-      end
-
-      def fresh_when(**) = stale?(**)
-
-      #   cache_control max_age: 60                        # private, max-age=60
-      #   cache_control max_age: 300, public: true, stale_while_revalidate: 30
-      #   cache_control :no_store
-      def cache_control(directive = nil, max_age: nil, public: false, stale_while_revalidate: nil)
-        headers["cache-control"] =
-          if directive == :no_store then "no-store"
-          else
-            [public ? "public" : "private", ("max-age=#{Integer(max_age)}" if max_age),
-             ("stale-while-revalidate=#{Integer(stale_while_revalidate)}" if stale_while_revalidate)].compact.join(", ")
-          end
-      end
-
-      # Passed to serializers as `context` (e.g. { current_user: current_user }).
-      def serializer_context = {}
-
-      def process(action)
-        @action_name = action
-        run_callbacks(self.class.before_callbacks)
-        public_send(action) unless rendered?
-        run_callbacks(self.class.after_callbacks)
-        finish
-      rescue StandardError => e
-        handle_exception(e)
-        finish
-      end
-
-      private
-
-      def finish
-        head(:no_content) unless rendered?
-        status, body = @response
-        [status, @response_headers, body]
-      end
-
-      def run_callbacks(callbacks)
-        callbacks.each do |callback|
-          next unless callback.applies?(@action_name)
-
-          callback.callback_method ? send(callback.callback_method) : instance_exec(&callback.block)
-          break if rendered? && callbacks.equal?(self.class.before_callbacks)
-        end
-      end
-
-      def handle_exception(error)
-        rescuer = self.class.rescue_handlers.find { |h| h.classes.any? { |klass| error.is_a?(klass) } }
-        raise error unless rescuer
-
-        @response = nil
-        @response_headers = @response_headers.slice("x-request-id")
-        if rescuer.handler
-          rescuer.handler.is_a?(Proc) ? instance_exec(error, &rescuer.handler) : call_handler(rescuer.handler, error)
-        else
-          status = status_code(rescuer.status)
-          wrapped = GemStack::Error.new(error.message, status: status,
-                                                       code: rescuer.code || ErrorRenderer.code_for(status))
-          status, headers, body = ErrorRenderer.render(wrapped, request_id: request.request_id)
-          @response_headers.merge!(headers)
-          @response = [status, body]
-        end
-      end
-
-      def pagination_settings = (env[CONFIG] || Config.new).pagination
-
-      def etag_source(value)
-        case value
-        when Array then value.map { |v| etag_source(v) }.join("/")
-        else value.respond_to?(:cache_key) ? value.cache_key.to_s : value.to_s
-        end
-      end
-
-      def fresh?
-        none_match = request.get_header("HTTP_IF_NONE_MATCH")
-        etag = headers["etag"]
-        if none_match && etag
-          tags = none_match.split(",").map { |t| t.strip.delete_prefix("W/") }
-          return tags.include?("*") || tags.include?(etag.delete_prefix("W/"))
-        end
-        modified_since = request.get_header("HTTP_IF_MODIFIED_SINCE")
-        last_modified = headers["last-modified"]
-        return false unless modified_since && last_modified
-
-        Time.httpdate(last_modified) <= Time.httpdate(modified_since)
-      rescue ArgumentError
-        false
-      end
-
-      def apply_serializer(serializer, value)
-        return { data: serializer.many(value.items, serializer_context), meta: value.meta } if value.is_a?(HTTP::Page)
-
-        list = value.is_a?(Array) || (value.respond_to?(:all) && value.respond_to?(:model))
-        list ? serializer.many(value, serializer_context) : serializer.serialize(value, serializer_context)
-      end
-
-      def call_handler(name, error)
-        method(name).arity.zero? ? send(name) : send(name, error)
-      end
-
-      def status_code(status)
-        return status if status.is_a?(Integer)
-
-        Rack::Utils::SYMBOL_TO_STATUS_CODE.fetch(status.to_sym) { raise ArgumentError, "unknown status #{status}" }
-      end
-
-      def codec = env[JSON_CODEC] || JSONCodec.default
-    end
-  end
-end