Rewrite and simplify parsing code

Author: jgarber623

lib/indieweb/endpoints.rb

@@ -6,8 +6,6 @@
 
 require_relative "endpoints/client"
 require_relative "endpoints/parser"
-require_relative "endpoints/response_body_parser"
-require_relative "endpoints/response_headers_parser"
 
 module IndieWeb
   module Endpoints
@@ -21,13 +19,14 @@ class SSLError < Error; end
 
     # Discover a URL's IndieAuth, Micropub, Microsub, and Webmention endpoints.
     #
-    # Convenience method for {IndieWeb::Endpoints::Client#endpoints}.
+    # Convenience method for {Client#endpoints}.
     #
     # @example
     #   IndieWeb::Endpoints.get("https://aaronparecki.com")
     #
-    # @param (see IndieWeb::Endpoints::Client#endpoints)
-    # @return (see IndieWeb::Endpoints::Client#endpoints)
+    # @param (see Client#initialize)
+    #
+    # @return (see Client#endpoints)
     def self.get(url)
       Client.new(url).endpoints
     end

lib/indieweb/endpoints/client.rb

@@ -16,7 +16,8 @@ class Client
       #   client = IndieWeb::Endpoints::Client.new("https://aaronparecki.com")
       #
       # @param url [String, HTTP::URI, #to_s] an absolute URL
-      # @raise [IndieWeb::Endpoints::InvalidURIError]
+      #
+      # @raise [InvalidURIError]
       def initialize(url)
         @uri = HTTP::URI.parse(url.to_s)
       rescue Addressable::URI::InvalidURIError => e
@@ -32,13 +33,14 @@ def inspect
       #
       # @return [Hash{Symbol => String, Array, nil}]
       def endpoints
-        @endpoints ||= Parser.new(response).results
+        @endpoints ||= Parser.new(response).to_h
       end
 
-      # The +HTTP::Response+ object returned by the provided URL.
+      # The {HTTP::Response} object returned by the provided URL.
       #
       # @return [HTTP::Response]
-      # @raise [IndieWeb::Endpoints::HttpError, IndieWeb::Endpoints::SSLError]
+      #
+      # @raise [HttpError, SSLError]
       def response
         @response ||= HTTP
                         .follow(max_hops: 20)

lib/indieweb/endpoints/parser.rb

@@ -9,16 +9,43 @@ def initialize(response)
         @response = response
       end
 
-      # @return [Hash{Symbol => String, Array<String>, nil}]
-      def results
+      # @param identifier [String]
+      # @param node_names [Array<String>]
+      #
+      # @return [Array<String>]
+      #
+      # @raise [InvalidURIError]
+      def matches(identifier, node_names: ["link"])
+        results =
+          (matches_from_headers(identifier) + matches_from_body(identifier, node_names))
+            .compact
+            .map! { |endpoint| response.uri.join(endpoint).to_s }
+
+        results.uniq!
+        results.sort!
+
+        results
+      rescue Addressable::URI::InvalidURIError => e
+        raise InvalidURIError, e
+      end
+
+      # @param (see #matches)
+      #
+      # @return [String]
+      def match(identifier, **kwargs)
+        matches(identifier, **kwargs).first
+      end
+
+      # @return [Hash{Symbol => String, Array, nil}]
+      def to_h
         {
-          authorization_endpoint: result_for(:authorization_endpoint),
-          "indieauth-metadata": result_for(:"indieauth-metadata"),
-          micropub: result_for(:micropub),
-          microsub: result_for(:microsub),
-          redirect_uri: results_for(:redirect_uri),
-          token_endpoint: result_for(:token_endpoint),
-          webmention: result_for(:webmention, ["link", "a"]),
+          authorization_endpoint: match("authorization_endpoint"),
+          "indieauth-metadata": match("indieauth-metadata"),
+          micropub: match("micropub"),
+          microsub: match("microsub"),
+          redirect_uri: (redirect_uri = matches("redirect_uri")).any? ? redirect_uri : nil,
+          token_endpoint: match("token_endpoint"),
+          webmention: match("webmention", node_names: ["link", "a"]),
         }
       end
 
@@ -27,38 +54,32 @@ def results
       # @return [HTTP::Response]
       attr_reader :response
 
-      # @return [IndieWeb::Endpoints::ResponseBodyParser]
-      def response_body_parser
-        @response_body_parser ||= ResponseBodyParser.new(response)
+      # @return [Nokogiri::HTML5::Document]
+      def body
+        @body ||= Nokogiri::HTML5(response.body)
       end
 
-      # @return [IndieWeb::Endpoints::ResponseHeadersParser]
-      def response_headers_parser
-        @response_headers_parser ||= ResponseHeadersParser.new(response)
+      # @return [Hash{Symbol => Array<LinkHeaderParser::LinkHeader>}]
+      def headers
+        @headers ||= LinkHeaderParser.parse(response.headers.get("link"), base: response.uri).group_by_relation_type
       end
 
-      # @param identifier [Symbol]
-      # @param nodes [Array<String>]
-      # @return [String, nil]
-      def result_for(identifier, nodes = ["link"])
-        results_for(identifier, nodes)&.first
-      end
+      # @return [Array<String>]
+      def matches_from_body(identifier, node_names)
+        return [] unless response.mime_type == "text/html"
 
-      # @param identifier [Symbol]
-      # @param nodes [Array<String>]
-      # @return [Array<String>, nil]
-      # @raise [IndieWeb::Endpoints::InvalidURIError]
-      def results_for(identifier, nodes = ["link"])
-        results_from_request = [
-          response_headers_parser.results_for(identifier),
-          response_body_parser.results_for(identifier, nodes),
-        ].flatten.compact
+        # Reject endpoints that contain a fragment identifier.
+        selectors = node_names.map { |node| %(#{node}[rel~="#{identifier}"][href]:not([href*="#"])) }.join(",")
 
-        return if results_from_request.none?
+        body.css(selectors).map { |element| element["href"] }
+      end
 
-        results_from_request.map { |endpoint| response.uri.join(endpoint).to_s }.uniq.sort
-      rescue Addressable::URI::InvalidURIError => e
-        raise InvalidURIError, e
+      # @return [Array<String>]
+      def matches_from_headers(identifier)
+        # Reject endpoints that contain a fragment identifier.
+        Array(headers[identifier.to_sym])
+          .filter { |header| !HTTP::URI.parse(header.target_uri).fragment }
+          .map(&:target_uri)
       end
     end
   end