link-header-parser 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 740f4f2172b36ed9b95799c1050809fdb0e2069c5c3dddcab82c3c295ca09c40
-  data.tar.gz: 45942dc43d28bd7048da8ded2c4f6290c4d959940d8d15ab03efd293d84ee957
+  metadata.gz: f27e7cee875b551a9a48c7d37b498eeec2a5dae6a3cd3695dddd5bdb59c3ae5b
+  data.tar.gz: 59113fb0ff7c0ce6d82150b3143599a995841b114778f1cc63cd7625cb973c59
 SHA512:
-  metadata.gz: c4d4b3b394a946ccdc13a0047b281ee37e13ce527acb344044068807d2742dc242a884875b30039c163384511f19bad8d65afd583fdcfefb7d6196a45f4cdd4a
-  data.tar.gz: c990a1bcd6d4b0aa88d57c820876521b5111208b7b835859bd818acb81fe2f331eb379c59484631583be4a71528e8fdb894a7cc1add5aa4cc78545752c5a3531
+  metadata.gz: 5db8f753ed8a5562d212368f647cf1eb32e4b23dad387ed06f5d9d6083ec4cd706cfec35fe2116b1d41813599b560b60c7152b5a786eecee3bcbdc319aea5660
+  data.tar.gz: 77aa58a97d9f87789f03b5206a9878368446675c1b46c4184bd697cd55965811f4d797d2f11b572cf9dbf286a2680af9967feb9ac8a4a81a3090b3f22dcfbc03

data/.reek.yml

@@ -1,6 +1,9 @@
 detectors:
   IrresponsibleModule:
     enabled: false
+  NestedIterators:
+    exclude:
+      - LinkHeaderParser::LinkHeadersCollection#group_by_relation_type
 
 exclude_paths:
   - vendor/

data/.ruby-version

@@ -1 +1 @@
-2.4.10
+2.5.8

data/.travis.yml

@@ -1,7 +1,6 @@
 dist: bionic
 language: ruby
 rvm:
-  - 2.4
   - 2.5
   - 2.6
   - 2.7

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 2.0.0 / 2020-05-21
+
+- **Breaking changes:** Rewrite gem code (5351010)
+	- `LinkHeaderParser.parse` returns `LinkHeadersCollection`
+	- New classes: `LinkHeadersCollection`, `LinkHeader`, and `LinkHeaderParameter`
+	- Renamed collection's `by_relation_type` method to `group_by_relation_type`
+- **Breaking change:** Update project Ruby version to 2.5.8 and minimum Ruby version to 2.5 (05b2e82)
+- Update inline documentation and refactor `ParsedHeader` and `ParsedHeaderCollection` classes (31ec43e)
+
 ## 1.0.0 / 2020-05-14
 
 - Update Absolutely dependency to 4.0 (4b78347)
@@ -8,11 +17,11 @@
 
 ## 0.3.0 / 2020-01-20
 
-- Expand supported Ruby versions to include 2.7 ([c55624a](https://github.com/jgarber623/link-header-parser-ruby/commit/c55624a)).
+- Expand supported Ruby versions to include 2.7 (c55624a)
 
 ## 0.2.0 / 2019-07-02
 
-- Add support for the `anchor` parameter to `ParsedHeader` exposed via `context` and `context_uri` methods ([d2dff52](https://github.com/jgarber623/link-header-parser-ruby/commit/d2dff52)).
+- Add support for the `anchor` parameter to `ParsedHeader` exposed via `context` and `context_uri` methods (d2dff52)
 
 ## 0.1.0 / 2019-06-06
 

data/CONTRIBUTING.md

@@ -8,9 +8,9 @@ There are a couple ways you can help improve link-header-parser-ruby:
 
 ## Getting Started
 
-link-header-parser-ruby is developed using Ruby 2.4.10 and is additionally tested against Ruby 2.5, 2.6, and 2.7 using [Travis CI](https://travis-ci.com/jgarber623/link-header-parser-ruby).
+link-header-parser-ruby is developed using Ruby 2.5.8 and is additionally tested against Ruby 2.6 and 2.7 using [Travis CI](https://travis-ci.com/jgarber623/link-header-parser-ruby).
 
-Before making changes to link-header-parser-ruby, you'll want to install Ruby 2.4.10. It's recommended that you use a Ruby version managment tool like [rbenv](https://github.com/rbenv/rbenv), [chruby](https://github.com/postmodern/chruby), or [rvm](https://github.com/rvm/rvm). Once you've installed Ruby 2.4.10 using your method of choice, install the project's gems by running:
+Before making changes to link-header-parser-ruby, you'll want to install Ruby 2.5.8. It's recommended that you use a Ruby version managment tool like [rbenv](https://github.com/rbenv/rbenv), [chruby](https://github.com/postmodern/chruby), or [rvm](https://github.com/rvm/rvm). Once you've installed Ruby 2.5.8 using your method of choice, install the project's gems by running:
 
 ```sh
 bundle install

data/README.md

@@ -11,9 +11,9 @@
 
 ## Getting Started
 
-Before installing and using link-header-parser-ruby, you'll want to have [Ruby](https://www.ruby-lang.org) 2.4 (or newer) installed. It's recommended that you use a Ruby version managment tool like [rbenv](https://github.com/rbenv/rbenv), [chruby](https://github.com/postmodern/chruby), or [rvm](https://github.com/rvm/rvm).
+Before installing and using link-header-parser-ruby, you'll want to have [Ruby](https://www.ruby-lang.org) 2.5 (or newer) installed. It's recommended that you use a Ruby version managment tool like [rbenv](https://github.com/rbenv/rbenv), [chruby](https://github.com/postmodern/chruby), or [rvm](https://github.com/rvm/rvm).
 
-link-header-parser-ruby is developed using Ruby 2.4.10 and is additionally tested against Ruby 2.5, 2.6, and 2.7 using [Travis CI](https://travis-ci.com/jgarber623/link-header-parser-ruby).
+link-header-parser-ruby is developed using Ruby 2.5.8 and is additionally tested against Ruby 2.6 and 2.7 using [Travis CI](https://travis-ci.com/jgarber623/link-header-parser-ruby).
 
 ## Installation
 
@@ -51,79 +51,98 @@ The `parse` method accepts two arguments:
 1. an `Array` of strings representing HTTP Link headers (e.g. `['</>; rel="home"', '</chapters/1>; anchor="#copyright"; rel="license"']`)
 1. a `String` representing the absolute URL of the resource providing the HTTP Link headers
 
-In the example above, `collection` is an instance of `ParsedHeaderCollection` which includes Ruby's [`Enumerable`](https://ruby-doc.org/core/Enumerable.html) mixin. This mixin allows for use of common methods like `each`, `first`/`last`, and `map`.
+In the example above, `collection` is an instance of `LinkHeadersCollection` which includes Ruby's [`Enumerable`](https://ruby-doc.org/core/Enumerable.html) mixin. This mixin allows for use of common methods like `each`, `first`/`last`, and `map`.
 
 For example, you could retrieve an array of `target_uri`s:
 
 ```ruby
-puts collection.map(&:target_uri) # => ["https://assets.sixtwothree.org/", "https://fonts.googleapis.com/", "https://fonts.gstatic.com/", "https://sixtwothree.org/webmentions"]
+puts collection.map(&:target_uri)
+#=> ["https://assets.sixtwothree.org/", "https://fonts.googleapis.com/", "https://fonts.gstatic.com/", "https://sixtwothree.org/webmentions"]
 ```
 
-### Working with a `ParsedHeaderCollection`
+### Working with a `LinkHeadersCollection`
 
-In addition to the included `Enumerable` methods, the following methods may be used to interact with a `ParsedHeaderCollection`:
+In addition to the included `Enumerable` methods, the following methods may be used to interact with a `LinkHeadersCollection`:
 
 #### The `relation_types` Method
 
 ```ruby
-puts collection.relation_types # => ["preconnect", "webmention"]
+puts collection.relation_types
+#=> ["preconnect", "webmention"]
 ```
 
-#### The `by_relation_type` Method
+#### The `group_by_relation_type` Method
 
-Using the `collection` from above, the `by_relation_type` method returns an `OpenStruct` with the following attributes:
+Using the `collection` from above, the `group_by_relation_type` method returns a `Hash`:
 
 ```ruby
 {
   preconnect: [
-    #<LinkHeaderParser::ParsedHeader @header="<https://assets.sixtwothree.org/>; rel=\"preconnect\"">,
-    #<LinkHeaderParser::ParsedHeader @header="<https://fonts.googleapis.com/>; rel=\"preconnect\"">,
-    #<LinkHeaderParser::ParsedHeader @header="<https://fonts.gstatic.com/>; rel=\"preconnect\"">
+    #<LinkHeaderParser::LinkHeader target_uri: "https://assets.sixtwothree.org/", relation_types: ["preconnect"]>,
+    #<LinkHeaderParser::LinkHeader target_uri: "https://fonts.googleapis.com/", relation_types: ["preconnect"]>,
+    #<LinkHeaderParser::LinkHeader target_uri: "https://fonts.gstatic.com/", relation_types: ["preconnect"]>
   ],
   webmention: [
-    #<LinkHeaderParser::ParsedHeader @header="<https://sixtwothree.org/webmentions>; rel=\"webmention\"">
+    #<LinkHeaderParser::LinkHeader target_uri: "https://sixtwothree.org/webmentions", relation_types: ["webmention"]>
   ]
 }
 ```
 
-### Working with a `ParsedHeader`
+### Working with a `LinkHeader`
 
-You may interact with one or more `ParsedHeader`s in a `ParsedHeaderCollection` using the methods outlined below. The naming conventions for these methods draws heavily on the terminology established in [RFC-5988](https://tools.ietf.org/html/rfc5988) and [RFC-8288](https://tools.ietf.org/html/rfc8288).
+You may interact with one or more `LinkHeader`s in a `LinkHeadersCollection` using the methods outlined below. The naming conventions for these methods draws heavily on the terminology established in [RFC-5988](https://tools.ietf.org/html/rfc5988) and [RFC-8288](https://tools.ietf.org/html/rfc8288).
 
 #### Link Target ([§ 3.1](https://tools.ietf.org/html/rfc8288#section-3.1))
 
 ```ruby
-link_headers = ['</index.html>; rel="home"']
-parsed_header = LinkHeaderParser.parse(link_headers, base: 'https://example.com/').first
+link_header = LinkHeaderParser.parse('</index.html>; rel="home"', base: 'https://example.com/').first
 
-parsed_header.target     # => '/index.html'
-parsed_header.target_uri # => 'https://example.com/index.html'
+link_header.target_string
+#=> "/index.html"
+
+link_header.target_uri
+#=> "https://example.com/index.html"
 ```
 
-The `target` method returns a string of the value between the opening and closing angle brackets at the beginning of the Link header. The `target_uri` method returns a string representing the resolved URL.
+The `target_string` method returns a string of the value between the opening and closing angle brackets at the beginning of the Link header. The `target_uri` method returns a string representing the resolved URL.
 
 #### Link Context ([§ 3.2](https://tools.ietf.org/html/rfc8288#section-3.2))
 
 ```ruby
-link_headers = ['<https://example.com/chapters/1>; anchor="#copyright"; rel="license"']
-parsed_header = LinkHeaderParser.parse(link_headers, base: 'https://example.com/').first
+link_header = LinkHeaderParser.parse('</chapters/1>; anchor="#copyright"; rel="license"', base: 'https://example.com/').first
+
+link_header.context_string
+#=> "#copyright"
 
-parsed_header.context     # => '#copyright'
-parsed_header.context_uri # => 'https://example.com/chapters/1#copyright'
+link_header.context_uri
+#=> "https://example.com/chapters/1#copyright"
 ```
 
-The `anchor` parameter's value may be a fragment identifier (e.g. `#foo`), a relative URL (e.g. `/foo`), or an absolute URL (e.g. `https://context.example.com`). The `context` method returns the `anchor` parameter's value (when present) and defaults to the `target` value.
+The `anchor` parameter's value may be a fragment identifier (e.g. `#foo`), a relative URL (e.g. `/foo`), or an absolute URL (e.g. `https://context.example.com`). The `context_string` method returns the `anchor` parameter's value (when present) and defaults to the `target_string` value. The `context_uri` method returns a string representing the resolved URL.
 
 #### Relation Type ([§ 3.3](https://tools.ietf.org/html/rfc8288#section-3.3))
 
 ```ruby
-link_headers = ['<https://example.com/chapters/1>; rel="prev start"']
-parsed_header = LinkHeaderParser.parse(link_headers, base: 'https://example.com/').first
+link_header = LinkHeaderParser.parse('</chapters/1>; rel="prev start"', base: 'https://example.com/').first
+
+link_header.relations_string
+#=> "prev start"
 
-parsed_header.relations      # => 'prev start'
-parsed_header.relation_types # => ['prev', 'start']
+link_header.relation_types
+#=> ["prev", "start"]
 ```
 
+#### Link Parameters ([Appendix B.3](https://tools.ietf.org/html/rfc8288#appendix-B.3))
+
+```ruby
+link_header = LinkHeaderParser.parse('</posts.rss>; rel="alternate"; hreflang="en-US"; title="sixtwothree.org: Posts"; type="application/rss+xml"', base: 'https://sixtwothree.org').first
+
+link_header.link_parameters
+#=> [#<LinkHeaderParser::LinkHeaderParameter:0x3fdea54716ac name: "rel", value: "alternate">, #<LinkHeaderParser::LinkHeaderParameter:0x3fdea5471684 name: "hreflang", value: "en-US">, #<LinkHeaderParser::LinkHeaderParameter:0x3fdea5471670 name: "title", value: "sixtwothree.org: Posts">, #<LinkHeaderParser::LinkHeaderParameter:0x3fdea547165c name: "type", value: "application/rss+xml">]
+```
+
+Note that the `Array` returned by the `link_parameters` method may include multiple `LinkHeaderParameter`s with the same name depending on the provided Link header. Certain methods on `LinkHeader` will return values from the first occurrence of a parameter name (e.g. `link_header.relations_string`) in accordance with [RFC-8288](https://tools.ietf.org/html/rfc8288).
+
 ## Contributing
 
 Interested in helping improve link-header-parser-ruby? Awesome! Your help is greatly appreciated. See [CONTRIBUTING.md](https://github.com/jgarber623/link-header-parser-ruby/blob/master/CONTRIBUTING.md) for details.

data/lib/link-header-parser.rb

@@ -1,17 +1,21 @@
-require 'ostruct'
+require 'forwardable'
 
 require 'absolutely'
 
 require 'link_header_parser/version'
 require 'link_header_parser/exceptions'
 
-require 'link_header_parser/parsed_header'
-require 'link_header_parser/parsed_header_collection'
+require 'link_header_parser/link_header'
+require 'link_header_parser/link_header_parameter'
+require 'link_header_parser/link_headers_collection'
 
 module LinkHeaderParser
-  class << self
-    def parse(*headers, base:)
-      ParsedHeaderCollection.new(headers, base: base)
-    end
+  # Parse an array of HTTP Link headers
+  #
+  # @param headers [Array<String>]
+  # @param base [String]
+  # @return [LinkHeaderParser::LinkHeadersCollection]
+  def self.parse(*headers, base:)
+    LinkHeadersCollection.new(*headers, base: base)
   end
 end

data/lib/link_header_parser/link_header.rb

@@ -0,0 +1,106 @@
+module LinkHeaderParser
+  class LinkHeader
+    FIELD_VALUE_REGEXP_PATTERN = /^\s*<\s*(?<target_string>[^>]+)\s*>\s*(?<parameters>;\s*.*)$/.freeze
+    PARAMETERS_REGEXP_PATTERN = /(?<!;)\s*([^;]+)/.freeze
+
+    attr_reader :field_value
+
+    # Create a new parsed Link header
+    # @see https://tools.ietf.org/html/rfc8288#appendix-B.2
+    #
+    # @param field_value [String]
+    # @param base [String]
+    def initialize(field_value, base:)
+      raise ArgumentError, "field_value must be a String (given #{field_value.class})" unless field_value.is_a?(String)
+      raise ArgumentError, "base must be a String (given #{base.class})" unless base.is_a?(String)
+
+      @field_value = field_value
+      @base = base
+    end
+
+    # The context URL for this Link header extracted from field_value (or target URL if no context URL is present)
+    # @see https://tools.ietf.org/html/rfc8288#appendix-B.2 (Appendix B.2.2.11)
+    #
+    # @return [String]
+    def context_string
+      @context_string ||= grouped_link_parameters[:anchor]&.first || target_string
+    end
+
+    # The resolved context URL for this Link header
+    # @see https://tools.ietf.org/html/rfc8288#appendix-B.2 (Appendix B.2.2.12)
+    #
+    # @return [String]
+    def context_uri
+      @context_uri ||= Absolutely.to_abs(base: target_uri, relative: context_string)
+    end
+
+    def inspect
+      format(%(#<#{self.class.name}:%#0x target_uri: #{target_uri.inspect}, relation_types: #{relation_types.inspect}>), object_id)
+    end
+
+    # The parsed parameters for this Link header extracted from field_value
+    # @see https://tools.ietf.org/html/rfc8288#appendix-B.3
+    #
+    # @return [Array<LinkHeaderParser::LinkHeaderParameter>]
+    def link_parameters
+      @link_parameters ||= field_value_match_data[:parameters].scan(PARAMETERS_REGEXP_PATTERN).flatten.map { |parameter| LinkHeaderParameter.new(parameter) }
+    end
+
+    # The relations_string value returned as an Array
+    # @see https://tools.ietf.org/html/rfc8288#appendix-B.2 (Appendix B.2.2.10 and Appendix B.2.2.17.1)
+    #
+    # @return [Array<String>]
+    def relation_types
+      @relation_types ||= relations_string.split.map(&:downcase)
+    end
+
+    # The relation types for this Link header extracted from field_value
+    # @see https://tools.ietf.org/html/rfc8288#appendix-B.2 (Appendix B.2.2.9)
+    #
+    # @return [String]
+    def relations_string
+      @relations_string ||= grouped_link_parameters[:rel]&.first || ''
+    end
+
+    # The target URL for this Link header extracted from field_value
+    # @see https://tools.ietf.org/html/rfc8288#appendix-B.2 (Appendix B.2.2.4)
+    #
+    # @return [String]
+    def target_string
+      @target_string ||= field_value_match_data[:target_string]
+    end
+
+    # The resolved target URL for this Link header
+    # @see https://tools.ietf.org/html/rfc8288#appendix-B.2 (Appendix B.2.2.8)
+    #
+    # @return [String]
+    def target_uri
+      @target_uri ||= Absolutely.to_abs(base: base, relative: target_string)
+    end
+
+    # @return [Hash{Symbol => String, Array, Hash{Symbol => Array}}]
+    def to_h
+      {
+        target_string: target_string,
+        target_uri: target_uri,
+        context_string: context_string,
+        context_uri: context_uri,
+        relations_string: relations_string,
+        relation_types: relation_types,
+        link_parameters: grouped_link_parameters
+      }
+    end
+
+    private
+
+    attr_reader :base
+
+    def field_value_match_data
+      @field_value_match_data ||= field_value.match(FIELD_VALUE_REGEXP_PATTERN)
+    end
+
+    def grouped_link_parameters
+      @grouped_link_parameters ||= link_parameters.map(&:to_a).group_by(&:shift).transform_keys(&:to_sym).transform_values(&:flatten)
+    end
+  end
+end

data/lib/link_header_parser/link_header_parameter.rb

@@ -0,0 +1,41 @@
+module LinkHeaderParser
+  class LinkHeaderParameter
+    PARAMETER_REGEXP_PATTERN = /^(?<name>.+?)(?:="?(?<value>.*?)"?)?$/.freeze
+
+    attr_reader :parameter
+
+    # @param parameter [String]
+    def initialize(parameter)
+      @parameter = parameter
+    end
+
+    def inspect
+      format(%(#<#{self.class.name}:%#0x name: #{name.inspect}, value: #{value.inspect}>), object_id)
+    end
+
+    # @see https://tools.ietf.org/html/rfc8288#appendix-B.3 (Appendix B.3.2.9)
+    #
+    # @return [String]
+    def name
+      @name ||= parameter_match_data[:name].downcase
+    end
+
+    # @see https://tools.ietf.org/html/rfc8288#appendix-B.3 (Appendix B.3.2.8)
+    #
+    # @return [String, nil]
+    def value
+      @value ||= parameter_match_data[:value] || ''
+    end
+
+    # @return [Array<String>]
+    def to_a
+      [name, value]
+    end
+
+    private
+
+    def parameter_match_data
+      @parameter_match_data ||= parameter.match(PARAMETER_REGEXP_PATTERN)
+    end
+  end
+end

data/lib/link_header_parser/link_headers_collection.rb

@@ -0,0 +1,48 @@
+module LinkHeaderParser
+  class LinkHeadersCollection
+    extend Forwardable
+
+    include Enumerable
+
+    def_delegators :members, :[], :<<, :each, :last, :length, :push
+
+    attr_reader :headers
+
+    # @param headers [Array<String>]
+    # @param base [String]
+    def initialize(*headers, base:)
+      @headers = headers.flatten
+      @base = base
+
+      discrete_headers.each { |header| push(LinkHeader.new(header, base: base)) }
+    end
+
+    # @return [Hash{Symbol => Array<LinkHeaderParser::LinkHeader>}]
+    def group_by_relation_type
+      relation_types.map do |relation_type|
+        [relation_type, find_all { |member| member.relation_types.include?(relation_type) }]
+      end.to_h.transform_keys(&:to_sym)
+    end
+
+    def inspect
+      format(%(#<#{self.class.name}:%#0x headers: #{headers.inspect}, relation_types: #{relation_types.inspect}>), object_id)
+    end
+
+    # @return [Array<String>]
+    def relation_types
+      @relation_types ||= flat_map(&:relation_types).uniq.sort
+    end
+
+    private
+
+    attr_reader :base
+
+    def discrete_headers
+      @discrete_headers ||= headers.flat_map { |header| header.split(/,(?=[\s|<])/) }.map(&:strip)
+    end
+
+    def members
+      @members ||= []
+    end
+  end
+end

data/lib/link_header_parser/version.rb

@@ -1,3 +1,3 @@
 module LinkHeaderParser
-  VERSION = '1.0.0'.freeze
+  VERSION = '2.0.0'.freeze
 end

data/link-header-parser.gemspec

@@ -1,7 +1,7 @@
 require_relative 'lib/link_header_parser/version'
 
 Gem::Specification.new do |spec|
-  spec.required_ruby_version = Gem::Requirement.new('>= 2.4', '< 2.8')
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.5', '< 2.8')
 
   spec.name          = 'link-header-parser'
   spec.version       = LinkHeaderParser::VERSION

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: link-header-parser
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Jason Garber
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-14 00:00:00.000000000 Z
+date: 2020-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: absolutely
@@ -48,8 +48,9 @@ files:
 - Rakefile
 - lib/link-header-parser.rb
 - lib/link_header_parser/exceptions.rb
-- lib/link_header_parser/parsed_header.rb
-- lib/link_header_parser/parsed_header_collection.rb
+- lib/link_header_parser/link_header.rb
+- lib/link_header_parser/link_header_parameter.rb
+- lib/link_header_parser/link_headers_collection.rb
 - lib/link_header_parser/version.rb
 - link-header-parser.gemspec
 homepage: https://github.com/jgarber623/link-header-parser-ruby
@@ -57,7 +58,7 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/jgarber623/link-header-parser-ruby/issues
-  changelog_uri: https://github.com/jgarber623/link-header-parser-ruby/blob/v1.0.0/CHANGELOG.md
+  changelog_uri: https://github.com/jgarber623/link-header-parser-ruby/blob/v2.0.0/CHANGELOG.md
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -66,7 +67,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '2.5'
   - - "<"
     - !ruby/object:Gem::Version
       version: '2.8'
@@ -76,7 +77,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Parse HTTP Link headers.

data/lib/link_header_parser/parsed_header.rb

@@ -1,70 +0,0 @@
-module LinkHeaderParser
-  class ParsedHeader
-    attr_reader :header
-
-    def initialize(header, base:)
-      raise ArgumentError, "header must be a String (given #{header.class})" unless header.is_a?(String)
-      raise ArgumentError, "base must be a String (given #{base.class})" unless base.is_a?(String)
-
-      @header = header
-      @base = base
-    end
-
-    # https://tools.ietf.org/html/rfc8288#section-3.2
-    def context
-      @context ||= parameters.anchor || target
-    end
-
-    def context_uri
-      @context_uri ||= Absolutely.to_abs(base: target_uri, relative: context)
-    end
-
-    def inspect
-      format(%(#<#{self.class.name}:%#0x @header="#{header.gsub('"', '\"')}">), object_id)
-    end
-
-    def parameters
-      @parameters ||= OpenStruct.new(header_attributes)
-    end
-
-    def relation_types
-      @relation_types ||= relations&.split(' ') || nil
-    end
-
-    # https://tools.ietf.org/html/rfc8288#section-3.3
-    def relations
-      @relations ||= parameters.rel || nil
-    end
-
-    # https://tools.ietf.org/html/rfc8288#section-3.1
-    def target
-      @target ||= header_match_data[:target]
-    end
-
-    def target_uri
-      @target_uri ||= Absolutely.to_abs(base: @base, relative: target)
-    end
-
-    def to_h
-      {
-        target: target,
-        target_uri: target_uri,
-        context: context,
-        context_uri: context_uri,
-        relations: relations,
-        relation_types: relation_types,
-        parameters: parameters.to_h
-      }
-    end
-
-    private
-
-    def header_attributes
-      @header_attributes ||= header_match_data[:attributes].tr('"', '').split(';').map { |tuple| tuple.split('=').map(&:strip) }.sort.to_h
-    end
-
-    def header_match_data
-      @header_match_data ||= header.match(/^<\s*(?<target>[^>]+)\s*>\s*;\s*(?<attributes>.*)$/)
-    end
-  end
-end

data/lib/link_header_parser/parsed_header_collection.rb

@@ -1,58 +0,0 @@
-module LinkHeaderParser
-  class ParsedHeaderCollection
-    include Enumerable
-
-    attr_reader :headers
-
-    def initialize(*headers, base:)
-      @headers = headers.flatten
-      @base = base
-    end
-
-    def by_relation_type
-      @by_relation_type ||= OpenStruct.new(mapped_relation_types)
-    end
-
-    def each
-      return to_enum unless block_given?
-
-      parsed_headers.each { |parsed_header| yield parsed_header }
-
-      self
-    end
-
-    def inspect
-      format(%(#<#{self.class.name}:%#0x @headers=#{headers}>), object_id)
-    end
-
-    def last
-      @last ||= parsed_headers[-1]
-    end
-
-    def length
-      @length ||= parsed_headers.length
-    end
-
-    def relation_types
-      @relation_types ||= parsed_headers.map(&:relation_types).flatten.uniq.sort
-    end
-
-    private
-
-    def find_all_by_relation_type(relation_type)
-      find_all { |parsed_header| parsed_header.relation_types.include?(relation_type) }
-    end
-
-    def mapped_relation_types
-      @mapped_relation_types ||= relation_types.map { |relation_type| [relation_type, find_all_by_relation_type(relation_type)] }.to_h
-    end
-
-    def parsed_headers
-      @parsed_headers ||= uniq_headers.map { |header| ParsedHeader.new(header, base: @base) }
-    end
-
-    def uniq_headers
-      @uniq_headers ||= headers.map { |header| header.split(/,(?=[\s|<])/) }.flatten.map(&:strip)
-    end
-  end
-end