dommy-rack 0.8.0

data/lib/dommy/rack/request_builder.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "uri"
+require "stringio"
+require "rack/utils"
+
+module Dommy
+  module Rack
+    # Builds a Rack-compatible env hash from a high-level request description.
+    # Stateless aside from the session config it reads defaults from.
+    class RequestBuilder
+      FORM_URLENCODED = "application/x-www-form-urlencoded"
+      BODY_METHODS = %w[POST PUT PATCH DELETE].freeze
+
+      def initialize(config)
+        @config = config
+      end
+
+      def build(method:, url:, headers: {}, body: nil, params: nil, cookie_string: "")
+        raise ArgumentError, "pass either :params or :body, not both" if params && body
+
+        verb = method.to_s.upcase
+        uri = URI.parse(url)
+        env_headers = normalize_headers(headers)
+
+        body_string, query_extra, content_type = encode_payload(verb, params, body, env_headers)
+        query = merge_query(uri.query, query_extra)
+
+        env = base_env(verb, uri, query, body_string)
+        apply_default_headers(env, env_headers, cookie_string)
+        env["CONTENT_TYPE"] = content_type if content_type
+        env.merge!(env_headers)
+        env
+      end
+
+      private
+
+      def base_env(verb, uri, query, body_string)
+        {
+          "REQUEST_METHOD" => verb,
+          "SCRIPT_NAME" => "",
+          "PATH_INFO" => uri.path.to_s.empty? ? "/" : uri.path,
+          "QUERY_STRING" => query,
+          "SERVER_NAME" => uri.host.to_s,
+          "SERVER_PORT" => uri.port.to_s,
+          "SERVER_PROTOCOL" => "HTTP/1.1",
+          "HTTP_HOST" => host_header(uri),
+          "CONTENT_LENGTH" => body_string.bytesize.to_s,
+          "rack.url_scheme" => uri.scheme || "http",
+          "rack.input" => StringIO.new(body_string),
+          "rack.errors" => $stderr
+        }
+      end
+
+      def apply_default_headers(env, env_headers, cookie_string)
+        env["HTTP_ACCEPT"] = @config.accept unless env_headers.key?("HTTP_ACCEPT")
+        env["HTTP_USER_AGENT"] = @config.user_agent unless env_headers.key?("HTTP_USER_AGENT")
+        env["HTTP_COOKIE"] = cookie_string unless cookie_string.to_s.empty?
+      end
+
+      # Returns [body_string, query_extra, content_type]. For GET-style verbs,
+      # params go into the query string and the body stays empty.
+      def encode_payload(verb, params, body, env_headers)
+        if params
+          pairs = to_pairs(params)
+          if BODY_METHODS.include?(verb)
+            if FileUpload.multipart?(pairs)
+              multipart_body, content_type = FileUpload.encode(pairs)
+              [multipart_body, nil, content_type]
+            else
+              [encode_query(pairs), nil, env_headers["CONTENT_TYPE"] || FORM_URLENCODED]
+            end
+          else
+            ["", encode_query(pairs), nil]
+          end
+        elsif body.is_a?(String)
+          [body, nil, nil]
+        elsif body.respond_to?(:read)
+          [body.read.to_s, nil, nil]
+        else
+          ["", nil, nil]
+        end
+      end
+
+      def merge_query(existing, extra)
+        [existing, extra].compact.reject(&:empty?).join("&")
+      end
+
+      # Normalize params to ordered [name, value] pairs. A Hash expands array
+      # values into repeated pairs; an Array is already ordered pairs. Keeping
+      # order lets Rack reconstruct nested params (e.g. address[][street]).
+      def to_pairs(params)
+        if params.is_a?(::Hash)
+          params.flat_map { |key, value| Array(value).map { |v| [key.to_s, v] } }
+        else
+          params.map { |key, value| [key.to_s, value] }
+        end
+      end
+
+      # urlencode ordered pairs preserving order.
+      def encode_query(pairs)
+        pairs.map { |key, value| "#{::Rack::Utils.escape(key)}=#{::Rack::Utils.escape(scalar(value))}" }.join("&")
+      end
+
+      # File/Blob values can appear in a GET form; reduce them to their
+      # filename so build_query never serializes raw bytes into a query.
+      def scalar(value)
+        return value.to_s unless value.respond_to?(:__dommy_bytes__)
+
+        value.respond_to?(:name) ? value.name.to_s : ""
+      end
+
+      def normalize_headers(headers)
+        headers.each_with_object({}) do |(name, value), acc|
+          acc[normalize_header_name(name)] = value.to_s
+        end
+      end
+
+      def normalize_header_name(name)
+        key = name.to_s
+        case key.downcase
+        when "content-type" then "CONTENT_TYPE"
+        when "content-length" then "CONTENT_LENGTH"
+        else "HTTP_#{key.upcase.tr("-", "_")}"
+        end
+      end
+
+      def host_header(uri)
+        default = uri.scheme == "https" ? 443 : 80
+        uri.port && uri.port != default ? "#{uri.host}:#{uri.port}" : uri.host.to_s
+      end
+    end
+  end
+end

data/lib/dommy/rack/response.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Dommy
+  module Rack
+    # Wraps a single completed Rack response triple plus the absolute URL it
+    # was fetched at. The body is drained eagerly (Rack bodies are one-shot)
+    # and the Dommy document is parsed lazily on first access.
+    class Response
+      HTML_CONTENT_TYPES = ["text/html", "application/xhtml+xml"].freeze
+      REDIRECT_STATUSES = [301, 302, 303, 307, 308].freeze
+
+      attr_reader :status, :headers, :url
+
+      # The redirects followed to reach this response, oldest first. Each entry
+      # is {status:, url:, location:}. Empty unless this was the final response
+      # of a followed redirect chain. Set by Navigation.
+      attr_accessor :redirects
+
+      def initialize(status, headers, body, url:)
+        @status = status.to_i
+        @headers = headers || {}
+        @url = url
+        @body = drain_body(body)
+        @document_parsed = false
+        @window = nil
+        @redirects = []
+      end
+
+      def body
+        @body
+      end
+
+      # Content-Type with any parameters (charset, boundary) stripped.
+      def content_type
+        raw = header("content-type")
+        return nil unless raw
+
+        raw.split(";", 2).first.to_s.strip.downcase
+      end
+
+      def html?
+        HTML_CONTENT_TYPES.include?(content_type)
+      end
+
+      # True when the response advertises a JSON content type, including
+      # structured-suffix types such as application/vnd.api+json.
+      def json?
+        ct = content_type
+        return false unless ct
+
+        ct == "application/json" || ct == "text/json" || ct.end_with?("+json")
+      end
+
+      # The parsed JSON body. Parses regardless of Content-Type so that
+      # servers mislabeling JSON still work; raises JSON::ParserError on
+      # invalid JSON. Pass symbolize_names: true for symbol keys.
+      def json(symbolize_names: false)
+        JSON.parse(@body, symbolize_names: symbolize_names)
+      end
+
+      def redirect?
+        REDIRECT_STATUSES.include?(@status)
+      end
+
+      # --- Status-class predicates ---
+
+      def success? = (200..299).cover?(@status)
+      def client_error? = (400..499).cover?(@status)
+      def server_error? = (500..599).cover?(@status)
+      def error? = @status >= 400
+      def not_found? = @status == 404
+
+      def location_header
+        header("location")
+      end
+
+      # The redirect target of an immediate (delay 0) <meta http-equiv=
+      # "refresh">, or nil. The HTML analog of location_header. A self-refresh
+      # with no URL is ignored to avoid reload loops; non-HTML responses and
+      # non-zero delays return nil.
+      def meta_refresh_url
+        return nil unless html?
+
+        meta = document&.query_selector_all("meta")
+          &.find { |m| m.get_attribute("http-equiv")&.downcase == "refresh" }
+        return nil unless meta
+
+        delay, _, rest = meta.get_attribute("content").to_s.partition(";")
+        return nil unless delay.strip.match?(/\A0+\z/)
+
+        url = rest.strip.sub(/\Aurl\s*=\s*/i, "").delete("\"'").strip
+        url.empty? ? nil : url
+      end
+
+      # All Set-Cookie values, handling both single-string (newline-joined)
+      # and array header shapes across Rack 2 and Rack 3.
+      def set_cookie_strings
+        values = lookup_header("set-cookie")
+        Array(values).flat_map { |v| v.to_s.split("\n") }.reject(&:empty?)
+      end
+
+      # The parsed Dommy window, or nil for non-HTML responses.
+      def window
+        parse_document! unless @document_parsed
+        @window
+      end
+
+      def document
+        window&.document
+      end
+
+      private
+
+      def drain_body(body)
+        return +"" if body.nil?
+        return body.dup if body.is_a?(String)
+
+        parts = []
+        body.each { |part| parts << part }
+        parts.join
+      ensure
+        body.close if body.respond_to?(:close)
+      end
+
+      def parse_document!
+        @document_parsed = true
+        return unless html?
+
+        @window = Dommy.parse(@body)
+        # Location#href= updates origin too (Dommy resolves absolute URLs),
+        # so a single assignment configures the full document URL.
+        @window.location.__js_set__("href", @url) if @url
+        @window.document.content_type = content_type if content_type
+      end
+
+      # Case-insensitive single-value header lookup.
+      def header(name)
+        value = lookup_header(name)
+        value.is_a?(Array) ? value.first : value
+      end
+
+      def lookup_header(name)
+        target = name.downcase
+        @headers.each do |key, value|
+          return value if key.to_s.downcase == target
+        end
+        nil
+      end
+    end
+  end
+end