rfc-web-link 0.0.0

data/lib/rfc/web/link/decoder.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module RFC
+  module Web
+    module Link
+      # A HTTP header field decoder which adheres to RFC 8187.
+      class Decoder
+        def initialize delimiter: "'", default_encoding: Encoding::UTF_8, client: URI
+          @delimiter = delimiter
+          @default_encoding = default_encoding
+          @client = client
+        end
+
+        def call text
+          value, encoding, language = parse text
+
+          value = client.decode_uri_component(value)
+                        .force_encoding(encoding || default_encoding)
+                        .encode(default_encoding)
+
+          {value:, encoding:, language:}
+        rescue ArgumentError, NoMethodError
+          {value: nil, encoding:, language:}
+        end
+
+        private
+
+        attr_reader :delimiter, :default_encoding, :client
+
+        def parse text
+          case String(text).split delimiter
+            in [value] then [value, nil, nil]
+            in [encoding, language, value] then [value, encoding, language]
+            else [nil, nil, nil]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rfc/web/link/encoder.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RFC
+  module Web
+    module Link
+      # A HTTP header field encoder which adheres to RFC 8187.
+      class Encoder
+        def initialize pattern: /[^0-9a-zA-Z!\#$&+\-.^_`|~]/
+          @pattern = pattern
+        end
+
+        def call(text) = text.match?(pattern) ? convert_characters(text).join : text
+
+        private
+
+        attr_reader :pattern
+
+        def convert_characters text
+          text.each_char.map do |character|
+            next character unless character.match? pattern
+
+            character.bytes
+                     .map { format "%%%02X", it }
+                     .join
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rfc/web/link/models/link.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module RFC
+  module Web
+    module Link
+      module Models
+        # Models a link.
+        Link = Data.define :uri, :pairs do
+          extend Forwardable
+
+          delegate %i[empty? include?] => :pairs
+
+          def initialize uri:, pairs: Set.new
+            super
+          end
+
+          def add pair
+            pairs.add pair
+            self
+          end
+
+          def append key, value, **attributes
+            pairs.add Pair[key:, value:, **attributes]
+            self
+          end
+
+          def has?(key) = pairs.any? { it.key == key.to_s }
+
+          def to_s(delimiter: "; ") = "<#{uri}>; #{pairs.join delimiter}"
+
+          alias_method :to_str, :to_s
+        end
+      end
+    end
+  end
+end

data/lib/rfc/web/link/models/list.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module RFC
+  module Web
+    module Link
+      module Models
+        # Models a list of links.
+        List = Data.define :links do
+          extend Forwardable
+
+          delegate %i[all? any? empty? find include? map none? one? size] => :links
+
+          def initialize links: Set.new
+            super
+          end
+
+          def add line
+            links.add line
+            self
+          end
+
+          def clear
+            links.clear
+            self
+          end
+
+          def each(&block) = block ? links.each(&block) : self
+
+          def reject(&) = with links: Set[*links.reject(&)]
+
+          def select(&) = with links: Set[*links.select(&)]
+
+          def to_s(delimiter: ", ") = links.join delimiter
+
+          alias_method :to_str, :to_s
+
+          private :links
+        end
+      end
+    end
+  end
+end

data/lib/rfc/web/link/models/pair.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RFC
+  module Web
+    module Link
+      module Models
+        # Models the key, delimiter, and decoded value associated with a link.
+        Pair = Data.define :key, :delimiter, :value, :encoding, :language do
+          def initialize key:, value:, delimiter: "=", encoding: nil, language: nil
+            super key: key.to_s, value:, delimiter:, encoding:, language:
+          end
+
+          def encoded? = delimiter == "*="
+
+          def to_s key_map: {"relation" => "rel", "language" => "hreflang"}.freeze,
+                   encoder: Encoder.new
+            transformed_key = key_map.fetch(key) { it }
+
+            if encoding
+              "#{transformed_key}#{delimiter}#{encoding}'#{language}'" \
+              "#{encoder.call value.encode(encoding)}"
+            else
+              "#{transformed_key}#{delimiter}#{value}"
+            end
+          end
+
+          alias_method :to_str, :to_s
+        end
+      end
+    end
+  end
+end

data/lib/rfc/web/link/parsers/header.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RFC
+  module Web
+    module Link
+      module Parsers
+        # Parses a header link into a list of records.
+        class Header
+          def initialize pattern: /link/i, list: List.new
+            @pattern = pattern
+            @list = list
+          end
+
+          def call headers, root_uri:
+            text = headers.find { |key, value| break value if key.match? pattern }
+            list.call text, root_uri:
+          end
+
+          private
+
+          attr_reader :pattern, :list
+        end
+      end
+    end
+  end
+end

data/lib/rfc/web/link/parsers/line.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RFC
+  module Web
+    module Link
+      module Parsers
+        # Parses a header line into a link record.
+        class Line
+          def initialize delimiter: /;\s*?/, pair: Pair.new, model: Models::Link
+            @delimiter = delimiter
+            @pair = pair
+            @model = model
+          end
+
+          def call text, root_uri:
+            link, *parts = text.split delimiter
+            pairs = process parts, root_uri
+
+            build_model link, pairs, root_uri
+          end
+
+          private
+
+          attr_reader :delimiter, :pair, :model
+
+          def process parts,
+                      root_uri,
+                      default: Hash.new { |nascence, lacuna| nascence[lacuna] = [] }
+            parts.each.with_object default do |part, all|
+              part = pair.call(part, root_uri:)
+              key = part.key
+
+              case part
+                in key: "hreflang" then all[key].append part
+                in delimiter: "*=" then all[key].clear.append part
+                else all[key].append part unless all.key? key
+              end
+            end
+          end
+
+          def build_model link, pairs, root_uri
+            model[uri: build_uri(link, root_uri:), pairs: Set[*pairs.values.flatten!]]
+          end
+
+          def build_uri value, root_uri:
+            value.delete_prefix("<")
+                 .delete_suffix(">")
+                 .then { it.start_with?("/") ? "#{root_uri}#{it}" : it }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rfc/web/link/parsers/list.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module RFC
+  module Web
+    module Link
+      module Parsers
+        # Parses header links into a list of records.
+        class List
+          RELATION_PATTERN = /
+            (?<prefix>rel=")  # Prefix.
+            .+                # One or more characters.
+            \s+?              # One or more spaces, lazy.
+            .+                # One or more characters.
+            (?<suffix>")      # Suffix.
+          /x
+
+          def initialize relation_pattern: RELATION_PATTERN, line: Line.new, list: Models::List.new
+            @scanner = StringScanner.new ""
+            @relation_pattern = relation_pattern
+            @line = line
+            @list = list
+            @comma = ","
+            @quote = %(")
+          end
+
+          def call text, root_uri:
+            text = String text
+            list.clear
+
+            return list unless text.start_with? "<"
+
+            scanner.string = text
+
+            build_list root_uri
+          end
+
+          private
+
+          attr_reader :scanner, :relation_pattern, :line, :list, :comma, :quote
+
+          def build_list root_uri, buffer: +"", lines: []
+            check scanner.getch, buffer, lines until scanner.eos?
+
+            lines.append(buffer.dup)
+                 .each { maybe_split_by_relation it.strip, root_uri: }
+
+            list
+          end
+
+          def check character, buffer, lines
+            case character
+              when quote then enquote buffer
+              when comma
+                lines.append buffer.dup
+                buffer.clear
+              else buffer << character
+            end
+          end
+
+          def enquote buffer
+            start = scanner.pos
+            scanner.scan_until quote
+            buffer << %("#{scanner.pre_match[start..]}")
+          end
+
+          # rubocop:todo Metrics/AbcSize
+          def maybe_split_by_relation text, root_uri:
+            match = text.match relation_pattern
+
+            return list.add line.call(text, root_uri:) unless match
+
+            match.to_s
+                 .delete_prefix(match[:prefix])
+                 .delete_suffix(match[:suffix])
+                 .split
+                 .each { list.add line.call(text.sub(relation_pattern, "rel=#{it}"), root_uri:) }
+          end
+          # rubocop:enable Metrics/AbcSize
+        end
+      end
+    end
+  end
+end

data/lib/rfc/web/link/parsers/pair.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RFC
+  module Web
+    module Link
+      module Parsers
+        # Parses a header key/value pair into a record.
+        class Pair
+          def initialize split_pattern: /(?<target>=)|(?<extended>\*=)/,
+                         decoder: Decoder.new,
+                         model: Models::Pair
+            @split_pattern = split_pattern
+            @decoder = decoder
+            @model = model
+          end
+
+          def call text, root_uri:
+            key, delimiter, value = text.split split_pattern
+            key.strip!
+
+            attributes = decoder.call value
+            value = attributes.delete :value
+            value = "#{root_uri}#{value}" if key == "anchor" && value.start_with?("/")
+            attributes[:value] = value
+
+            model[key:, delimiter:, **attributes]
+          end
+
+          private
+
+          attr_reader :split_pattern, :decoder, :model
+        end
+      end
+    end
+  end
+end

data/lib/rfc/web/link.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "rfc/web/link/decoder"
+require "rfc/web/link/encoder"
+require "rfc/web/link/models/link"
+require "rfc/web/link/models/list"
+require "rfc/web/link/models/pair"
+require "rfc/web/link/parsers/header"
+require "rfc/web/link/parsers/line"
+require "rfc/web/link/parsers/list"
+require "rfc/web/link/parsers/pair"
+
+module RFC
+  module Web
+    # Main namespace.
+    module Link
+      def self.new(**) = Parsers::Header.new(**)
+    end
+  end
+end

data/rfc-web-link.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |spec|
+  spec.name = "rfc-web-link"
+  spec.version = "0.0.0"
+  spec.authors = ["Brooke Kuhlmann"]
+  spec.email = ["brooke@alchemists.io"]
+  spec.homepage = "https://alchemists.io/projects/rfc-web-link"
+  spec.summary = "A RFC 8288 Web Linking implementation."
+  spec.license = "Hippocratic-2.1"
+
+  spec.metadata = {
+    "bug_tracker_uri" => "https://github.com/bkuhlmann/rfc-web-link/issues",
+    "changelog_uri" => "https://alchemists.io/projects/rfc-web-link/versions",
+    "homepage_uri" => "https://alchemists.io/projects/rfc-web-link",
+    "funding_uri" => "https://github.com/sponsors/bkuhlmann",
+    "label" => "RFC Web Link",
+    "rubygems_mfa_required" => "true",
+    "source_code_uri" => "https://github.com/bkuhlmann/rfc-web-link"
+  }
+
+  spec.signing_key = Gem.default_key_path
+  spec.cert_chain = [Gem.default_cert_path]
+
+  spec.required_ruby_version = ">= 4.0"
+
+  spec.extra_rdoc_files = Dir["README*", "LICENSE*"]
+  spec.files = Dir["*.gemspec", "lib/**/*"]
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: rfc-web-link
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Brooke Kuhlmann
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIENjCCAp6gAwIBAgIBAzANBgkqhkiG9w0BAQsFADBBMQ8wDQYDVQQDDAZicm9v
+  a2UxGjAYBgoJkiaJk/IsZAEZFgphbGNoZW1pc3RzMRIwEAYKCZImiZPyLGQBGRYC
+  aW8wHhcNMjYwMzI1MTI0OTEyWhcNMjcwMzI1MTI0OTEyWjBBMQ8wDQYDVQQDDAZi
+  cm9va2UxGjAYBgoJkiaJk/IsZAEZFgphbGNoZW1pc3RzMRIwEAYKCZImiZPyLGQB
+  GRYCaW8wggGiMA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQCro8tj5/E1Hg88
+  f4qfiwPVd2zJQHvdYt4GHVvuHRRgx4HGhJuNp+4BId08RBn7V6V1MW6MY3kezRBs
+  M+7QOQ4b1xNLTvY7FYQB1wGK5a4x7TTokDrPYQxDB2jmsdDYCzVbIMrAvUfcecRi
+  khyGZCdByiiCl4fKv77P12tTT+NfsvXkLt/AYCGwjOUyGKTQ01Z6eC09T27GayPH
+  QQvIkakyFgcJtzSyGzs8bzK5q9u7wQ12MNTjJoXzW69lqp0oNvDylu81EiSUb5S6
+  QzzPxZBiRB1sgtbt1gUbVI262ZDq1gR+HxPFmp+Cgt7ZLIJZAtesQvtcMzseXpfn
+  hpmm0Sw22KGhRAy/mqHBRhDl5HqS1SJp2Ko3lcnpXeFResp0HNlt8NSu13vhC08j
+  GUHU9MyIXbFOsnp3K3ADrAVjPWop8EZkmUR3MV/CUm00w2cZHCSGiXl1KMpiVKvk
+  Ywr1gd2ZME4QLSo+EXUtLxDUa/W3xnBS8dBOuMMz02FPWYr3PN8CAwEAAaM5MDcw
+  CQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0OBBYEFAFgmv0tYMZnItuPycSM
+  F5wykJEVMA0GCSqGSIb3DQEBCwUAA4IBgQAG+ykjp+DIXSybGEtX+/ve974mYfN6
+  8U7qcVfRM+qDSOZ+97iu30qUTbVAKIHlHCDKRn3SgOffDUB5VU2MsJBh/3TPKWBZ
+  anB/uzMcwOfru+qyA3b7ZFqZzRLWmR5FtPObFxc0gYMT3YvLNHk2Nb9Vjq/PoiGG
+  e75PXweDOokwDA5m1gMOz1rdp/dlGMXkSFQg94PPVyUKXgO4VzWTgePSDxOIL+v6
+  +OWV6AaEH9BaqxnmdA5ubi0L7bhl0gbN92FxpNO3kpTjww8kme856a+wCK3qyM5w
+  7ZLbUexynDN0Au8eSpT2Bf6ztGmB1S9ffzDJsGX1/lkpMIB51e48Xe2+gzzOgemk
+  CdZaGupj6WkarnT8kh/cPtyA5ax4rGX6GOS8meGxzkv8Uy0JSEOYAp6wLfIisYZp
+  IJBIXIOkwKKJ0eB5YHrUSJxzpP4LlcIg/eTftaXmJdYjy+2VRrCZYDjfguyLmMjR
+  KR9w4/Fjvqy87kCHmxMWa6IL2Vzt1Clm2cA=
+  -----END CERTIFICATE-----
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+email:
+- brooke@alchemists.io
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.adoc
+- README.adoc
+files:
+- LICENSE.adoc
+- README.adoc
+- lib/rfc/web/link.rb
+- lib/rfc/web/link/decoder.rb
+- lib/rfc/web/link/encoder.rb
+- lib/rfc/web/link/models/link.rb
+- lib/rfc/web/link/models/list.rb
+- lib/rfc/web/link/models/pair.rb
+- lib/rfc/web/link/parsers/header.rb
+- lib/rfc/web/link/parsers/line.rb
+- lib/rfc/web/link/parsers/list.rb
+- lib/rfc/web/link/parsers/pair.rb
+- rfc-web-link.gemspec
+homepage: https://alchemists.io/projects/rfc-web-link
+licenses:
+- Hippocratic-2.1
+metadata:
+  bug_tracker_uri: https://github.com/bkuhlmann/rfc-web-link/issues
+  changelog_uri: https://alchemists.io/projects/rfc-web-link/versions
+  homepage_uri: https://alchemists.io/projects/rfc-web-link
+  funding_uri: https://github.com/sponsors/bkuhlmann
+  label: RFC Web Link
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/bkuhlmann/rfc-web-link
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '4.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.19
+specification_version: 4
+summary: A RFC 8288 Web Linking implementation.
+test_files: []