net-http-structured_field_values 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 50d5376e269e9e8cf277cb12a3dcf3fbf22d7f047b0a72654bce858e5e60994a
+  data.tar.gz: 3bdc2d923d5d9aeb32238fe9ce07ea12d9a570f5e47b85077ce0d950d20715b5
+SHA512:
+  metadata.gz: 6862b163faa570c59554c2174a3d5b10b0477de62909f57e7c5887d58c80a65dbc8fabdf19eaa45c007327dfdb53b6dbfc5b6dfd16e6e3b4a4c815b5a3706c74
+  data.tar.gz: 173d2bb39bce5245778b3916dc3e8d9c975d8400ad4f096b4c3ed81a1970d7fe78e50699499f6f81d1f6938e57055fbcfa7a02a97a633bf60a9ffd24f81b2756

data/.github/workflows/check-actions.yml

@@ -0,0 +1,27 @@
+name: Check Actions
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - '.github/workflows/**.yml'
+  pull_request:
+    paths:
+      - '.github/workflows/**.yml'
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Install and Run Actionlint
+        run: |
+          bash <(curl https://raw.githubusercontent.com/rhysd/actionlint/main/scripts/download-actionlint.bash)
+          ./actionlint -color

data/.github/workflows/check-project.yml

@@ -0,0 +1,61 @@
+name: Check Project
+
+on:
+  push:
+    branches:
+      - main
+    paths-ignore:
+      - '**.md'
+
+  pull_request:
+    paths-ignore:
+      - '**.md'
+
+jobs:
+  rspec:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: .ruby-version
+          bundler-cache: true
+
+      - name: Run RSpec
+        run: bundle exec rspec
+
+      - name: Upload coverage report
+        uses: codecov/codecov-action@v3
+
+  rubocop:
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: read
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: .ruby-version
+          bundler-cache: true
+
+      - name: Run RuboCop
+        uses: reviewdog/action-rubocop@v2
+        with:
+          rubocop_version: gemfile
+          rubocop_extensions: rubocop-performance:gemfile rubocop-rake:gemfile rubocop-rspec:gemfile
+          github_token: ${{ secrets.github_token }}
+          reporter: github-pr-review
+          fail_on_error: true
+          filter_mode: nofilter

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,25 @@
+require:
+  - rubocop-performance
+  - rubocop-rake
+  - rubocop-rspec
+
+AllCops:
+  NewCops: enable
+
+Metrics:
+  Enabled: false
+
+RSpec/MultipleExpectations:
+  Enabled: false
+
+Style/NumericLiterals:
+  Enabled: false
+
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: consistent_comma

data/.ruby-version

@@ -0,0 +1 @@
+3.2.2

data/Gemfile

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in net-http-structured_field_values.gemspec
+gemspec
+
+group :development, :test do
+  gem 'bundler', '~> 2.4'
+  gem 'rake', '~> 13.0'
+
+  gem 'rubocop', '~> 1.56'
+  gem 'rubocop-performance', '~> 1.19'
+  gem 'rubocop-rake', '~> 0.4'
+  gem 'rubocop-rspec', '~> 2.1'
+end
+
+group :test do
+  gem 'rspec', '~> 3.12'
+
+  gem 'simplecov', '~> 0.22'
+  gem 'simplecov-cobertura', '~> 2.1'
+end

data/Gemfile.lock

@@ -0,0 +1,92 @@
+PATH
+  remote: .
+  specs:
+    net-http-structured_field_values (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    base64 (0.1.1)
+    diff-lcs (1.5.0)
+    docile (1.4.0)
+    json (2.6.3)
+    language_server-protocol (3.17.0.3)
+    parallel (1.23.0)
+    parser (3.2.2.3)
+      ast (~> 2.4.1)
+      racc
+    racc (1.7.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.8.1)
+    rexml (3.2.6)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.2)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.6)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.1)
+    rubocop (1.56.3)
+      base64 (~> 0.1.1)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.2.2.3)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.28.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.29.0)
+      parser (>= 3.2.1.0)
+    rubocop-capybara (2.18.0)
+      rubocop (~> 1.41)
+    rubocop-factory_bot (2.23.1)
+      rubocop (~> 1.33)
+    rubocop-performance (1.19.1)
+      rubocop (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    rubocop-rake (0.6.0)
+      rubocop (~> 1.0)
+    rubocop-rspec (2.24.0)
+      rubocop (~> 1.33)
+      rubocop-capybara (~> 2.17)
+      rubocop-factory_bot (~> 2.22)
+    ruby-progressbar (1.13.0)
+    simplecov (0.22.0)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-cobertura (2.1.0)
+      rexml
+      simplecov (~> 0.19)
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.4)
+    unicode-display_width (2.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.4)
+  net-http-structured_field_values!
+  rake (~> 13.0)
+  rspec (~> 3.12)
+  rubocop (~> 1.56)
+  rubocop-performance (~> 1.19)
+  rubocop-rake (~> 0.4)
+  rubocop-rspec (~> 2.1)
+  simplecov (~> 0.22)
+  simplecov-cobertura (~> 2.1)
+
+BUNDLED WITH
+   2.4.10

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 kyori19
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,37 @@
+# Net::Http::StructuredFieldValues
+
+A Ruby implementation of [RFC 8941 - Structured Field Values for HTTP](https://datatracker.ietf.org/doc/html/rfc8941).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'net-http-structured_field_values'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install net-http-structured_field_values
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/kyori19/net-http-structured_field_values.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'net/http/structured_field_values'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/net/http/structured_field_values/parameterized_value.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Net
+  module HTTP
+    module StructuredFieldValues
+      # ParameterizedValue represents a value with parameters.
+      class ParameterizedValue
+        attr_reader :value, :parameters
+
+        def initialize(value, parameters)
+          @value = value
+          @parameters = parameters
+        end
+
+        def ==(other)
+          value == other.value && parameters == other.parameters
+        end
+      end
+    end
+  end
+end

data/lib/net/http/structured_field_values/parser.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'strscan'
+
+require 'net/http/structured_field_values/parameterized_value'
+
+# Disable some cops which is not compatible with StringScanner.
+# rubocop:disable Lint/MissingCopEnableDirective
+# rubocop:disable Performance/StringInclude
+# rubocop:disable Style/CaseLikeIf
+# rubocop:enable Lint/MissingCopEnableDirective
+
+module Net
+  module HTTP
+    module StructuredFieldValues
+      # RFC8941 compliant parser which parses HTTP fields into Ruby objects.
+      #
+      # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.2}
+      class Parser
+        TOP_LEVEL_TYPES = %w[list dictionary item].freeze
+        private_constant :TOP_LEVEL_TYPES
+
+        # @param [String] input input bytes to be parsed
+        def initialize(input)
+          @scanner = StringScanner.new(input.encode(Encoding::ASCII))
+          remove_leading_spaces
+        rescue Encoding::UndefinedConversionError
+          raise ParseError, 'Unexpected input'
+        end
+
+        # @param [String] type type of the field to be parsed,
+        #                      must be one of 'list', 'dictionary' or 'item'
+        def parse_as(type)
+          raise ArgumentError, "Invalid type: #{type}" unless TOP_LEVEL_TYPES.include?(type)
+
+          send("parse_as_#{type}").tap do
+            remove_leading_spaces
+            raise ParseError, 'Unexpected input' unless scanner.eos?
+          end
+        end
+
+        TOP_LEVEL_TYPES.each do |type|
+          define_singleton_method("parse_as_#{type}") do |input|
+            new(input).parse_as(type)
+          end
+        end
+
+        private
+
+        attr_reader :scanner
+
+        def remove_leading_spaces
+          scanner.skip(/ +/)
+        end
+
+        def remove_leading_whitespaces
+          scanner.skip(/[ \t]+/)
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.2.1}
+        # @return [Array<ParameterizedValue>]
+        def parse_as_list
+          return [] if scanner.eos?
+
+          [].tap do |result|
+            loop do
+              result << parse_as_item_or_inner_list
+              remove_leading_whitespaces
+              break if scanner.eos?
+
+              raise ParseError, 'Expected ","' unless scanner.skip(/,/)
+
+              remove_leading_whitespaces
+              raise ParseError, 'Expected next item' if scanner.eos?
+            end
+          end
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.2.1.1}
+        # @return [ParameterizedValue]
+        def parse_as_item_or_inner_list
+          if scanner.match?(/\(/)
+            parse_as_inner_list
+          else
+            parse_as_item
+          end
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.2.1.2}
+        # @return [ParameterizedValue<Array>]
+        def parse_as_inner_list
+          raise ParseError, 'Expected "("' unless scanner.skip(/\(/)
+
+          ParameterizedValue.new(
+            [].tap do |result|
+              loop do
+                remove_leading_spaces
+                break if scanner.skip(/\)/)
+
+                result << parse_as_item
+                raise ParseError, 'Expected space or ")"' unless scanner.match?(/[ )]/)
+              end
+            end,
+            parse_as_parameters,
+          )
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.2.2}
+        # @return [Hash]
+        def parse_as_dictionary
+          return {} if scanner.eos?
+
+          {}.tap do |result|
+            loop do
+              result[parse_as_key] = if scanner.skip(/=/)
+                                       parse_as_item_or_inner_list
+                                     else
+                                       ParameterizedValue.new(true, parse_as_parameters)
+                                     end
+              remove_leading_whitespaces
+              break if scanner.eos?
+
+              raise ParseError, 'Expected ","' unless scanner.skip(/,/)
+
+              remove_leading_whitespaces
+              raise ParseError, 'Expected next hash key' if scanner.eos?
+            end
+          end
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.2.3}
+        # @return [ParameterizedValue<Integer,Float,String,Boolean>]
+        def parse_as_item
+          ParameterizedValue.new(parse_as_bare_item, parse_as_parameters)
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.2.3.1}
+        # @return [Integer,Float,String,Symbol,Boolean]
+        def parse_as_bare_item
+          raise ParseError, 'Unexpected input' if scanner.eos?
+
+          if scanner.match?(/[-\d]/)
+            parse_as_integer_or_decimal
+          elsif scanner.match?(/"/)
+            parse_as_string
+          elsif scanner.match?(/[a-zA-Z*]/)
+            parse_as_token
+          elsif scanner.match?(/:/)
+            parse_as_byte_sequence
+          elsif scanner.match?(/\?/)
+            parse_as_boolean
+          else
+            raise ParseError, 'Unexpected input'
+          end
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.2.3.2}
+        # @return [Hash]
+        def parse_as_parameters
+          {}.tap do |result|
+            while scanner.skip(/;/)
+              remove_leading_spaces
+              result[parse_as_key] = if scanner.skip(/=/)
+                                       parse_as_bare_item
+                                     else
+                                       true
+                                     end
+            end
+          end
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.2.3.3}
+        # @return [String]
+        def parse_as_key
+          raise ParseError, 'Unexpected input' unless scanner.match?(/[a-z*]/)
+
+          scanner.scan(/[a-z\d_\-.*]+/)
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.2.4}
+        # @return [Integer,Float]
+        def parse_as_integer_or_decimal
+          sign = scanner.skip(/-/) ? -1 : 1
+          raise ParseError, 'Unexpected input' unless scanner.match?(/\d/)
+
+          str = scanner.scan(/\d+/)
+          num = if scanner.skip(/\./)
+                  raise ParseError, 'Integer part of decimal number is too long' if str.length > 12
+                  raise ParseError, 'Unexpected input' unless scanner.match?(/\d/)
+
+                  frac = scanner.scan(/\d+/)
+                  raise ParseError, 'Fractional part of decimal number is too long' if frac.length > 3
+
+                  "#{str}.#{frac}".to_f
+                else
+                  raise ParseError, 'Integer number is too long' if str.length > 15
+
+                  str.to_i
+                end
+
+          num * sign
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.2.5}
+        # @return [String]
+        def parse_as_string
+          raise ParseError, 'Unexpected input' unless scanner.skip(/"/)
+
+          (+'').tap do |result|
+            loop do
+              if scanner.eos?
+                raise ParseError, 'Unexpected input'
+              elsif scanner.skip(/"/)
+                break
+              elsif scanner.skip(/\\/)
+                byte = scanner.scan(/["\\]/)
+                raise ParseError, 'Unexpected input' unless byte
+
+                result << byte
+              elsif scanner.match?(/[ -~]/)
+                result << scanner.scan(/[ !#-\[\]-~]+/)
+              else
+                raise ParseError, 'Expected space or visible ASCII character'
+              end
+            end
+          end
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.2.6}
+        # @return [Symbol]
+        def parse_as_token
+          raise ParseError, 'Unexpected input' unless scanner.match?(/[a-zA-Z*]/)
+
+          scanner.scan(/[!#-'*+\--:A-Z^-z|~]+/).to_sym
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.2.7}
+        # @return [String]
+        def parse_as_byte_sequence
+          raise ParseError, 'Unexpected input' unless scanner.skip(/:/)
+
+          str = scanner.scan(%r{[a-zA-Z\d+/=]+})
+          raise ParseError, 'Unexpected input' unless scanner.skip(/:/)
+
+          Base64.decode64(str || '')
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.2.8}
+        # @return [Boolean]
+        def parse_as_boolean
+          raise ParseError, 'Unexpected input' unless scanner.skip(/\?/)
+
+          case scanner.get_byte
+          when '0'
+            false
+          when '1'
+            true
+          else
+            raise ParseError, 'Unexpected input'
+          end
+        end
+
+        class ParseError < StandardError; end
+      end
+    end
+  end
+end

data/lib/net/http/structured_field_values/serializer.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+module Net
+  module HTTP
+    module StructuredFieldValues
+      # RFC8941 compliant serializer which serializes Ruby objects into HTTP fields.
+      #
+      # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.1}
+      class Serializer
+        def initialize
+          @result = +''
+        end
+
+        # @return [String]
+        def serialize(obj)
+          case obj
+          when Array
+            serialize_list(obj)
+          when Hash
+            serialize_dictionary(obj)
+          else
+            value, params = unpack_parameterized_value(obj)
+            serialize_item(value, params)
+          end
+
+          result.encode(Encoding::ASCII)
+        end
+
+        # @return [String]
+        def self.serialize(obj)
+          new.serialize(obj)
+        end
+
+        private
+
+        attr_reader :result
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.1.1}
+        #
+        # @param [Array] arr
+        def serialize_list(arr)
+          return if arr.empty?
+
+          loop do
+            value, params = unpack_parameterized_value(arr.shift)
+            case value
+            when Array
+              serialize_inner_list(value, params)
+            else
+              serialize_item(value, params)
+            end
+
+            break if arr.empty?
+
+            result << ', '
+          end
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.1.1.1}
+        #
+        # @param [Array] arr
+        # @param [Hash] params
+        def serialize_inner_list(arr, params)
+          result << '('
+
+          unless arr.empty?
+            loop do
+              serialize_item(*unpack_parameterized_value(arr.shift))
+
+              break if arr.empty?
+
+              result << ' '
+            end
+          end
+
+          result << ')'
+
+          serialize_parameters(params)
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.1.1.2}
+        #
+        # @param [Hash] params
+        def serialize_parameters(params)
+          params.each do |key, value|
+            result << ';'
+
+            serialize_key(key)
+            next if value == true
+
+            result << '='
+            serialize_bare_item(value)
+          end
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.1.1.3}
+        #
+        # @param [String] key
+        def serialize_key(key)
+          key = key.encode(Encoding::ASCII)
+          raise SerializationError, 'Invalid key' unless key.match?(/\A[a-z*][a-z\d_\-*]*\z/)
+
+          result << key
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.1.2}
+        #
+        # @param [Hash] dict
+        def serialize_dictionary(dict)
+          return if dict.empty?
+
+          loop do
+            key, obj = dict.shift
+            serialize_key(key)
+
+            value, params = unpack_parameterized_value(obj)
+            if value == true
+              serialize_parameters(params)
+            else
+              result << '='
+              case value
+              when Array
+                serialize_inner_list(value, params)
+              else
+                serialize_item(value, params)
+              end
+            end
+
+            break if dict.empty?
+
+            result << ', '
+          end
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.1.3}
+        #
+        # @param [Object] item
+        # @param [Hash] params
+        def serialize_item(item, params)
+          serialize_bare_item(item)
+          serialize_parameters(params)
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.1.3.1}
+        def serialize_bare_item(item)
+          case item
+          when Integer
+            serialize_integer(item)
+          when Float
+            serialize_decimal(item)
+          when String
+            case item.encoding
+            when Encoding::BINARY
+              serialize_byte_sequence(item)
+            else
+              serialize_string(item)
+            end
+          when Symbol
+            serialize_token(item)
+          when TrueClass, FalseClass
+            serialize_boolean(item)
+          else
+            raise SerializationError, "Unexpected item: #{item.inspect}"
+          end
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.1.4}
+        #
+        # @param [Integer] int
+        def serialize_integer(int)
+          unless (-999_999_999_999_999..999_999_999_999_999).cover?(int)
+            raise SerializationError, 'integers must be in the range of -999,999,999,999,999 to 999,999,999,999,999'
+          end
+
+          result << int.to_s
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.1.5}
+        #
+        # @param [Float] decimal
+        def serialize_decimal(decimal)
+          decimal = decimal.round(3, half: :even)
+          str = decimal.to_s
+          i = str.index('.')
+
+          raise SerializationError, 'integer part of decimals must be less than 13 chars' if i.nil? || i > 12
+
+          result << str
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.1.6}
+        #
+        # @param [String] str
+        def serialize_string(str)
+          result << '"'
+
+          s = StringScanner.new(str.encode(Encoding::ASCII))
+          loop do
+            if (part = s.scan(/[ !#-\[\]-~]+/))
+              result << part
+            end
+
+            break if s.eos?
+
+            raise SerializationError, 'Invalid string' unless (byte = s.scan(/["\\]/))
+
+            result << '\\'
+            result << byte
+          end
+
+          result << '"'
+        rescue EncodingError
+          raise SerializationError, 'Invalid string'
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.1.7}
+        #
+        # @param [Symbol] token
+        def serialize_token(token)
+          str = token.to_s
+
+          raise SerializationError, 'Invalid token' unless str.match?(/\A[a-zA-Z*][!#-'*+\--:A-Z^-z|~]*\z/)
+
+          result << str
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.1.8}
+        #
+        # @param [String] bytes
+        def serialize_byte_sequence(bytes)
+          result << ':'
+          result << Base64.strict_encode64(bytes)
+          result << ':'
+        end
+
+        # @see {https://www.rfc-editor.org/rfc/rfc8941#section-4.1.9}
+        #
+        # @param [Boolean] bool
+        def serialize_boolean(bool)
+          result << '?'
+          result << (bool ? '1' : '0')
+        end
+
+        def unpack_parameterized_value(obj)
+          case obj
+          when ParameterizedValue
+            [obj.value, obj.parameters]
+          else
+            [obj, {}]
+          end
+        end
+
+        class SerializationError < StandardError; end
+      end
+    end
+  end
+end

data/lib/net/http/structured_field_values/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Net
+  module Http
+    module StructuredFieldValues
+      VERSION = '0.1.0'
+    end
+  end
+end

data/lib/net/http/structured_field_values.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'net/http/structured_field_values/parameterized_value'
+require 'net/http/structured_field_values/parser'
+require 'net/http/structured_field_values/version'
+
+module Net
+  module Http
+    # A Ruby implementation of RFC 8941 - Structured Field Values for HTTP.
+    #
+    # @see https://datatracker.ietf.org/doc/html/rfc8941
+    module StructuredFieldValues
+    end
+  end
+end

data/net-http-structured_field_values.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'net/http/structured_field_values/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'net-http-structured_field_values'
+  spec.version       = Net::Http::StructuredFieldValues::VERSION
+  spec.authors       = ['kyori19']
+  spec.email         = ['kyori@accelf.net']
+
+  spec.summary       = 'A Ruby implementation of RFC 8941 - Structured Field Values for HTTP'
+  spec.homepage      = 'https://github.com/kyori19/net-http-structured_field_values'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+    spec.metadata['rubygems_mfa_required'] = 'true'
+
+    spec.metadata['homepage_uri'] = spec.homepage
+    spec.metadata['source_code_uri'] = 'https://github.com/kyori19/net-http-structured_field_values'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+          'public gem pushes.'
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 3.2'
+end

data/renovate.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:base"
+  ]
+}

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: net-http-structured_field_values
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- kyori19
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-09-23 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
+- kyori@accelf.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/check-actions.yml"
+- ".github/workflows/check-project.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/net/http/structured_field_values.rb
+- lib/net/http/structured_field_values/parameterized_value.rb
+- lib/net/http/structured_field_values/parser.rb
+- lib/net/http/structured_field_values/serializer.rb
+- lib/net/http/structured_field_values/version.rb
+- net-http-structured_field_values.gemspec
+- renovate.json
+homepage: https://github.com/kyori19/net-http-structured_field_values
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/kyori19/net-http-structured_field_values
+  source_code_uri: https://github.com/kyori19/net-http-structured_field_values
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: A Ruby implementation of RFC 8941 - Structured Field Values for HTTP
+test_files: []