philiprehberger-header_kit 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0483e3f7557d6bc4a5d455fa7fcfbee3808118f120f17427f73c1b763cdfa4dd'
-  data.tar.gz: f2834acace689c8b78da5e7af771348efa97918bf7eb71434e6317708ef9da62
+  metadata.gz: 3d4bcbb3c1002def0f437335a19871b535ce7764369d43fed1c4a1548367988f
+  data.tar.gz: 03dea17ed3566ea8cce9ea8511f741c92487113b6ba0a4cdb899ab1835f07009
 SHA512:
-  metadata.gz: cbc23f4ecb68a3c80815a21f09de5156ccef17e9d9cc15a2d420409209f06119491d059ccfc9d3de26f268029cb78b910db12d88c56cf0918a14dea45d11f75e
-  data.tar.gz: 6c792d9fbff457ce2377ab95e641bce5626bb3a8ce5a01df1f0062cee51b9be05c0e9ecdc91e978938842213c5c76e9847cb521f1c91031d06f766b75be5df88
+  metadata.gz: 35c43a782a9e1ba431f972d18ec2c248a6141e96f79c082d09a2a48f973aee449d684011e4b70e3f95b4c488ff71fb1537c8da716e0186669e9ca974ff267792
+  data.tar.gz: 1b82e5bdea29824445c2097f21009f57a0f71cebbd80799386aed785e2247de8a4c87bd65136e198fea1150485c6909264f21cfed3970a2365c47c61ca7b7ce7

data/CHANGELOG.md

@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-03-28
+
+### Added
+
+- Parse Accept-Language headers with quality values
+- Negotiate best language match from Accept-Language against available languages
+- Parse Accept-Encoding headers with quality values
+- Parse Authorization headers (Bearer, Basic, Digest schemes)
+- Parse Cookie headers into name-value hashes
+- Build Set-Cookie header strings with all standard attributes
+- Build Accept header strings from structured type arrays
+
+## [0.1.1] - 2026-03-26
+
+### Changed
+
+- Fix README compliance (sponsor badge format, license link)
+
 ## [0.1.0] - 2026-03-26
 
 ### Added

data/README.md

@@ -2,8 +2,12 @@
 
 [![Tests](https://github.com/philiprehberger/rb-header-kit/actions/workflows/ci.yml/badge.svg)](https://github.com/philiprehberger/rb-header-kit/actions/workflows/ci.yml)
 [![Gem Version](https://badge.fury.io/rb/philiprehberger-header_kit.svg)](https://rubygems.org/gems/philiprehberger-header_kit)
+[![GitHub release](https://img.shields.io/github/v/release/philiprehberger/rb-header-kit)](https://github.com/philiprehberger/rb-header-kit/releases)
+[![Last updated](https://img.shields.io/github/last-commit/philiprehberger/rb-header-kit)](https://github.com/philiprehberger/rb-header-kit/commits/main)
 [![License](https://img.shields.io/github/license/philiprehberger/rb-header-kit)](LICENSE)
-[![Sponsor](https://img.shields.io/badge/sponsor-philiprehberger-pink?logo=githubsponsors)](https://github.com/sponsors/philiprehberger)
+[![Bug Reports](https://img.shields.io/github/issues/philiprehberger/rb-header-kit/bug)](https://github.com/philiprehberger/rb-header-kit/issues?q=is%3Aissue+is%3Aopen+label%3Abug)
+[![Feature Requests](https://img.shields.io/github/issues/philiprehberger/rb-header-kit/enhancement)](https://github.com/philiprehberger/rb-header-kit/issues?q=is%3Aissue+is%3Aopen+label%3Aenhancement)
+[![Sponsor](https://img.shields.io/badge/sponsor-GitHub%20Sponsors-ec6cb9)](https://github.com/sponsors/philiprehberger)
 
 HTTP header parsing, construction, and content negotiation
 
@@ -39,6 +43,44 @@ Philiprehberger::HeaderKit.parse_accept("text/html;q=0.9, application/json")
 #     {type: "text/html", quality: 0.9, params: {}}]
 ```
 
+### Build Accept
+
+```ruby
+Philiprehberger::HeaderKit.build_accept([{type: "text/html"}, {type: "application/json", quality: 0.9}])
+# => "text/html, application/json;q=0.9"
+```
+
+### Parse Accept-Language
+
+```ruby
+Philiprehberger::HeaderKit.parse_accept_language("en-US,en;q=0.9,fr;q=0.8")
+# => [{language: "en-US", quality: 1.0}, {language: "en", quality: 0.9}, {language: "fr", quality: 0.8}]
+```
+
+### Negotiate Language
+
+```ruby
+Philiprehberger::HeaderKit.negotiate_language("en-US,fr;q=0.9", ["fr", "en"])
+# => "en"
+```
+
+### Parse Accept-Encoding
+
+```ruby
+Philiprehberger::HeaderKit.parse_accept_encoding("gzip, deflate;q=0.5, br;q=0.8")
+# => [{encoding: "gzip", quality: 1.0}, {encoding: "br", quality: 0.8}, {encoding: "deflate", quality: 0.5}]
+```
+
+### Parse Authorization
+
+```ruby
+Philiprehberger::HeaderKit.parse_authorization("Bearer eyJhbGciOiJIUzI1NiJ9")
+# => {scheme: "Bearer", credentials: "eyJhbGciOiJIUzI1NiJ9"}
+
+Philiprehberger::HeaderKit.parse_authorization('Digest username="admin", realm="example"')
+# => {scheme: "Digest", params: {"username" => "admin", "realm" => "example"}}
+```
+
 ### Parse Cache-Control
 
 ```ruby
@@ -60,6 +102,20 @@ Philiprehberger::HeaderKit.parse_content_type("text/html; charset=utf-8")
 # => {media_type: "text/html", charset: "utf-8", boundary: nil}
 ```
 
+### Parse Cookie
+
+```ruby
+Philiprehberger::HeaderKit.parse_cookie("session=abc123; user=john")
+# => {"session" => "abc123", "user" => "john"}
+```
+
+### Build Set-Cookie
+
+```ruby
+Philiprehberger::HeaderKit.build_set_cookie("session", "abc123", secure: true, httponly: true, path: "/")
+# => "session=abc123; Path=/; Secure; HttpOnly"
+```
+
 ### Parse Link
 
 ```ruby
@@ -86,9 +142,16 @@ Philiprehberger::HeaderKit.negotiate("text/html;q=0.9, application/json", ["text
 | Method | Description |
 |--------|-------------|
 | `HeaderKit.parse_accept(header)` | Parse Accept header into sorted entries |
+| `HeaderKit.build_accept(types)` | Build Accept header string from type array |
+| `HeaderKit.parse_accept_language(header)` | Parse Accept-Language into sorted entries |
+| `HeaderKit.negotiate_language(header, available)` | Language negotiation, returns best match or nil |
+| `HeaderKit.parse_accept_encoding(header)` | Parse Accept-Encoding into sorted entries |
+| `HeaderKit.parse_authorization(header)` | Parse Authorization header (Bearer, Basic, Digest) |
 | `HeaderKit.parse_cache_control(header)` | Parse Cache-Control into directive hash |
 | `HeaderKit.build_cache_control(directives)` | Build Cache-Control string from hash |
 | `HeaderKit.parse_content_type(header)` | Parse Content-Type into components |
+| `HeaderKit.parse_cookie(header)` | Parse Cookie header into name-value hash |
+| `HeaderKit.build_set_cookie(name, value, **opts)` | Build Set-Cookie header string |
 | `HeaderKit.parse_link(header)` | Parse Link header into entry array |
 | `HeaderKit.build_link(links)` | Build Link header from array of hashes |
 | `HeaderKit.negotiate(accept_header, available)` | Content negotiation, returns best match or nil |
@@ -97,10 +160,17 @@ Philiprehberger::HeaderKit.negotiate("text/html;q=0.9, application/json", ["text
 
 ```bash
 bundle install
-bundle exec rspec      # Run tests
-bundle exec rubocop    # Check code style
+bundle exec rspec
+bundle exec rubocop
 ```
 
+## Support
+
+If you find this package useful, consider giving it a star on GitHub — it helps motivate continued maintenance and development.
+
+[![LinkedIn](https://img.shields.io/badge/Philip%20Rehberger-LinkedIn-0A66C2?logo=linkedin)](https://www.linkedin.com/in/philiprehberger)
+[![More packages](https://img.shields.io/badge/more-open%20source%20packages-blue)](https://philiprehberger.com/open-source-packages)
+
 ## License
 
-MIT
+[MIT](LICENSE)

data/lib/philiprehberger/header_kit/accept_builder.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Philiprehberger
+  module HeaderKit
+    # Builds Accept header strings from structured type entries.
+    module AcceptBuilder
+      # Build an Accept header string from an array of type hashes.
+      #
+      # @param types [Array<Hash>] each with :type and optional :quality
+      # @return [String] formatted Accept header value
+      def self.build(types)
+        return '' if types.nil? || types.empty?
+
+        parts = types.map do |entry|
+          type = entry[:type]
+          quality = entry[:quality]
+
+          if quality && quality < 1.0
+            "#{type};q=#{format_quality(quality)}"
+          else
+            type
+          end
+        end
+
+        parts.join(', ')
+      end
+
+      # Format a quality value, removing trailing zeros.
+      #
+      # @param quality [Float] the quality value
+      # @return [String] formatted quality string
+      def self.format_quality(quality)
+        formatted = format('%.3f', quality)
+        formatted.sub(/0+\z/, '').sub(/\.\z/, '.0')
+      end
+
+      private_class_method :format_quality
+    end
+  end
+end

data/lib/philiprehberger/header_kit/accept_encoding.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Philiprehberger
+  module HeaderKit
+    # Parses Accept-Encoding headers into structured encoding entries with quality values.
+    module AcceptEncoding
+      QUALITY_PATTERN = /\Aq\z/i
+
+      # Parse an Accept-Encoding header string.
+      #
+      # @param header [String] the Accept-Encoding header value
+      # @return [Array<Hash>] sorted by quality descending, each with :encoding, :quality
+      def self.parse(header)
+        return [] if header.nil? || header.strip.empty?
+
+        entries = header.split(',').map { |entry| parse_entry(entry.strip) }
+        entries.compact.sort_by { |e| [-e[:quality], entries.index(e)] }
+      end
+
+      # Parse a single encoding entry.
+      #
+      # @param entry [String] a single encoding with optional quality
+      # @return [Hash, nil] parsed entry or nil if invalid
+      def self.parse_entry(entry)
+        return nil if entry.empty?
+
+        parts = entry.split(';').map(&:strip)
+        encoding = parts.shift
+        return nil if encoding.nil? || encoding.empty?
+
+        quality = 1.0
+
+        parts.each do |param|
+          key, value = param.split('=', 2).map(&:strip)
+          next if key.nil? || key.empty?
+
+          quality = parse_quality(value) if QUALITY_PATTERN.match?(key)
+        end
+
+        { encoding: encoding.downcase, quality: quality }
+      end
+
+      # Parse a quality value, clamping to [0.0, 1.0].
+      #
+      # @param value [String, nil] the quality string
+      # @return [Float] parsed quality value
+      def self.parse_quality(value)
+        return 1.0 if value.nil? || value.empty?
+
+        value.to_f.clamp(0.0, 1.0)
+      end
+
+      private_class_method :parse_entry, :parse_quality
+    end
+  end
+end

data/lib/philiprehberger/header_kit/accept_language.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Philiprehberger
+  module HeaderKit
+    # Parses Accept-Language headers into structured language entries with quality values.
+    module AcceptLanguage
+      QUALITY_PATTERN = /\Aq\z/i
+
+      # Parse an Accept-Language header string.
+      #
+      # @param header [String] the Accept-Language header value
+      # @return [Array<Hash>] sorted by quality descending, each with :language, :quality
+      def self.parse(header)
+        return [] if header.nil? || header.strip.empty?
+
+        entries = header.split(',').map { |entry| parse_entry(entry.strip) }
+        entries.compact.sort_by { |e| [-e[:quality], entries.index(e)] }
+      end
+
+      # Negotiate the best language match from available languages.
+      #
+      # @param header [String] the Accept-Language header value
+      # @param available [Array<String>] list of available language tags
+      # @return [String, nil] the best matching language, or nil if no match
+      def self.negotiate(header, available)
+        return nil if available.nil? || available.empty?
+        return available.first if header.nil? || header.strip.empty?
+
+        parsed = parse(header)
+        return nil if parsed.empty?
+
+        parsed.each do |entry|
+          next if entry[:quality] <= 0.0
+
+          match = find_match(entry[:language], available)
+          return match if match
+        end
+
+        nil
+      end
+
+      # Parse a single language entry.
+      #
+      # @param entry [String] a single language tag with optional quality
+      # @return [Hash, nil] parsed entry or nil if invalid
+      def self.parse_entry(entry)
+        return nil if entry.empty?
+
+        parts = entry.split(';').map(&:strip)
+        language = parts.shift
+        return nil if language.nil? || language.empty?
+
+        quality = 1.0
+
+        parts.each do |param|
+          key, value = param.split('=', 2).map(&:strip)
+          next if key.nil? || key.empty?
+
+          quality = parse_quality(value) if QUALITY_PATTERN.match?(key)
+        end
+
+        { language: language, quality: quality }
+      end
+
+      # Parse a quality value, clamping to [0.0, 1.0].
+      #
+      # @param value [String, nil] the quality string
+      # @return [Float] parsed quality value
+      def self.parse_quality(value)
+        return 1.0 if value.nil? || value.empty?
+
+        value.to_f.clamp(0.0, 1.0)
+      end
+
+      # Find the best match for a language tag among available languages.
+      #
+      # @param tag [String] the requested language tag
+      # @param available [Array<String>] available language tags
+      # @return [String, nil] matching language or nil
+      def self.find_match(tag, available)
+        return available.first if tag == '*'
+
+        downcased = tag.downcase
+        exact = available.find { |a| a.downcase == downcased }
+        return exact if exact
+
+        prefix = available.find { |a| a.downcase.start_with?("#{downcased}-") }
+        return prefix if prefix
+
+        base = downcased.split('-').first
+        available.find { |a| a.downcase.split('-').first == base }
+      end
+
+      private_class_method :parse_entry, :parse_quality, :find_match
+    end
+  end
+end

data/lib/philiprehberger/header_kit/authorization.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Philiprehberger
+  module HeaderKit
+    # Parses Authorization headers for Bearer, Basic, and Digest schemes.
+    module Authorization
+      DIGEST_PARAM_PATTERN = %r{(\w+)=(?:"([^"]*)"|([\w+/=]+))}
+
+      # Parse an Authorization header string.
+      #
+      # @param header [String] the Authorization header value
+      # @return [Hash] with :scheme and :credentials (Bearer/Basic) or :params (Digest)
+      def self.parse(header)
+        return { scheme: nil, credentials: nil } if header.nil? || header.strip.empty?
+
+        stripped = header.strip
+        space_index = stripped.index(' ')
+
+        unless space_index
+          return { scheme: stripped, credentials: nil }
+        end
+
+        scheme = stripped[0...space_index]
+        rest = stripped[(space_index + 1)..].strip
+
+        case scheme.downcase
+        when 'bearer', 'basic'
+          { scheme: scheme, credentials: rest }
+        when 'digest'
+          { scheme: scheme, params: parse_digest_params(rest) }
+        else
+          { scheme: scheme, credentials: rest }
+        end
+      end
+
+      # Parse Digest authorization parameters.
+      #
+      # @param params_str [String] the parameter string after "Digest "
+      # @return [Hash{String => String}] parsed key-value parameters
+      def self.parse_digest_params(params_str)
+        params = {}
+
+        params_str.scan(DIGEST_PARAM_PATTERN).each do |key, quoted_value, unquoted_value|
+          params[key] = quoted_value || unquoted_value
+        end
+
+        params
+      end
+
+      private_class_method :parse_digest_params
+    end
+  end
+end

data/lib/philiprehberger/header_kit/cookie.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Philiprehberger
+  module HeaderKit
+    # Parses Cookie headers and builds Set-Cookie header strings.
+    module Cookie
+      # Parse a Cookie header string into a name-value hash.
+      #
+      # @param header [String] the Cookie header value
+      # @return [Hash{String => String}] cookie name-value pairs
+      def self.parse(header)
+        return {} if header.nil? || header.strip.empty?
+
+        cookies = {}
+
+        header.split(';').each do |pair|
+          pair = pair.strip
+          next if pair.empty?
+
+          name, value = pair.split('=', 2)
+          next if name.nil? || name.strip.empty?
+
+          cookies[name.strip] = (value || '').strip
+        end
+
+        cookies
+      end
+
+      # Build a Set-Cookie header string.
+      #
+      # @param name [String] cookie name
+      # @param value [String] cookie value
+      # @param expires [String, nil] Expires attribute value
+      # @param max_age [Integer, nil] Max-Age attribute value
+      # @param secure [Boolean] include Secure flag
+      # @param httponly [Boolean] include HttpOnly flag
+      # @param samesite [String, nil] SameSite attribute (Strict, Lax, None)
+      # @param path [String, nil] Path attribute
+      # @param domain [String, nil] Domain attribute
+      # @return [String] formatted Set-Cookie header value
+      def self.build_set_cookie(name, value, expires: nil, max_age: nil, secure: false, # rubocop:disable Metrics/ParameterLists
+                                httponly: false, samesite: nil, path: nil, domain: nil)
+        parts = ["#{name}=#{value}"]
+        parts << "Expires=#{expires}" if expires
+        parts << "Max-Age=#{max_age}" if max_age
+        parts << "Domain=#{domain}" if domain
+        parts << "Path=#{path}" if path
+        parts << 'Secure' if secure
+        parts << 'HttpOnly' if httponly
+        parts << "SameSite=#{samesite}" if samesite
+
+        parts.join('; ')
+      end
+    end
+  end
+end

data/lib/philiprehberger/header_kit/version.rb

@@ -2,6 +2,6 @@
 
 module Philiprehberger
   module HeaderKit
-    VERSION = '0.1.0'
+    VERSION = '0.2.0'
   end
 end

data/lib/philiprehberger/header_kit.rb

@@ -2,8 +2,13 @@
 
 require_relative 'header_kit/version'
 require_relative 'header_kit/accept'
+require_relative 'header_kit/accept_builder'
+require_relative 'header_kit/accept_encoding'
+require_relative 'header_kit/accept_language'
+require_relative 'header_kit/authorization'
 require_relative 'header_kit/cache_control'
 require_relative 'header_kit/content_type'
+require_relative 'header_kit/cookie'
 require_relative 'header_kit/link'
 require_relative 'header_kit/negotiation'
 
@@ -19,6 +24,47 @@ module Philiprehberger
       Accept.parse(header)
     end
 
+    # Build an Accept header string from an array of type hashes.
+    #
+    # @param types [Array<Hash>] each with :type and optional :quality
+    # @return [String] formatted Accept header value
+    def self.build_accept(types)
+      AcceptBuilder.build(types)
+    end
+
+    # Parse an Accept-Encoding header into structured entries sorted by quality.
+    #
+    # @param header [String] the Accept-Encoding header value
+    # @return [Array<Hash>] entries with :encoding, :quality keys
+    def self.parse_accept_encoding(header)
+      AcceptEncoding.parse(header)
+    end
+
+    # Parse an Accept-Language header into structured entries sorted by quality.
+    #
+    # @param header [String] the Accept-Language header value
+    # @return [Array<Hash>] entries with :language, :quality keys
+    def self.parse_accept_language(header)
+      AcceptLanguage.parse(header)
+    end
+
+    # Negotiate the best language from an Accept-Language header.
+    #
+    # @param header [String] the Accept-Language header value
+    # @param available [Array<String>] list of available language tags
+    # @return [String, nil] the best matching language, or nil if no match
+    def self.negotiate_language(header, available)
+      AcceptLanguage.negotiate(header, available)
+    end
+
+    # Parse an Authorization header into its components.
+    #
+    # @param header [String] the Authorization header value
+    # @return [Hash] with :scheme and :credentials or :params
+    def self.parse_authorization(header)
+      Authorization.parse(header)
+    end
+
     # Parse a Cache-Control header into a directive hash.
     #
     # @param header [String] the Cache-Control header value
@@ -43,6 +89,24 @@ module Philiprehberger
       ContentType.parse(header)
     end
 
+    # Parse a Cookie header into a name-value hash.
+    #
+    # @param header [String] the Cookie header value
+    # @return [Hash{String => String}] cookie name-value pairs
+    def self.parse_cookie(header)
+      Cookie.parse(header)
+    end
+
+    # Build a Set-Cookie header string.
+    #
+    # @param name [String] cookie name
+    # @param value [String] cookie value
+    # @param options [Hash] optional attributes (expires:, max_age:, secure:, httponly:, samesite:, path:, domain:)
+    # @return [String] formatted Set-Cookie header value
+    def self.build_set_cookie(name, value, **options)
+      Cookie.build_set_cookie(name, value, **options)
+    end
+
     # Parse a Link header into an array of link entries.
     #
     # @param header [String] the Link header value

metadata

@@ -1,17 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: philiprehberger-header_kit
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Philip Rehberger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-27 00:00:00.000000000 Z
+date: 2026-03-29 00:00:00.000000000 Z
 dependencies: []
-description: Parse and build Accept, Cache-Control, Content-Type, and Link HTTP headers.
-  Includes content negotiation for selecting the best response type.
+description: Parse and build Accept, Accept-Language, Accept-Encoding, Authorization,
+  Cache-Control, Content-Type, Cookie, and Link HTTP headers. Includes content negotiation
+  for selecting the best response type or language.
 email:
 - me@philiprehberger.com
 executables: []
@@ -23,8 +24,13 @@ files:
 - README.md
 - lib/philiprehberger/header_kit.rb
 - lib/philiprehberger/header_kit/accept.rb
+- lib/philiprehberger/header_kit/accept_builder.rb
+- lib/philiprehberger/header_kit/accept_encoding.rb
+- lib/philiprehberger/header_kit/accept_language.rb
+- lib/philiprehberger/header_kit/authorization.rb
 - lib/philiprehberger/header_kit/cache_control.rb
 - lib/philiprehberger/header_kit/content_type.rb
+- lib/philiprehberger/header_kit/cookie.rb
 - lib/philiprehberger/header_kit/link.rb
 - lib/philiprehberger/header_kit/negotiation.rb
 - lib/philiprehberger/header_kit/version.rb