rails_den 2.0.0

data/lib/rails_den/onebox/oembed/discovery.rb

@@ -0,0 +1,296 @@
+require "nokogiri"
+require "uri"
+
+module RailsDen
+  module Onebox
+    module OEmbed
+      class Discovery
+        MEDIA_TYPES = {
+          "application/json+oembed" => :json,
+          "text/xml+oembed" => :xml
+        }.freeze
+
+        Endpoint = Struct.new(
+          :url,
+          :format,
+          :source,
+          keyword_init: true
+        )
+
+        def self.call(
+          html:,
+          headers:,
+          page_url:
+        )
+          new(
+            html: html,
+            headers: headers,
+            page_url: page_url
+          ).call
+        end
+
+        def initialize(
+          html:,
+          headers:,
+          page_url:
+        )
+          @html = html.to_s
+          @headers = headers || {}
+          @page_url = page_url.to_s
+        end
+
+        def call
+          candidates =
+            html_candidates +
+            header_candidates
+
+          candidates.find do |endpoint|
+            endpoint.format == :json
+          end || candidates.first
+        end
+
+        private
+
+        def html_candidates
+          document =
+            Nokogiri::HTML5.parse(
+              @html
+            )
+
+          document.css(
+            "link[href][rel][type]"
+          ).filter_map do |node|
+            relations =
+              node["rel"]
+                .to_s
+                .split(/\s+/)
+                .map(&:downcase)
+
+            next unless relations.include?(
+              "alternate"
+            )
+
+            build_endpoint(
+              node["href"],
+              node["type"],
+              :html
+            )
+          end
+        end
+
+        def header_candidates
+          value =
+            header_value(
+              "link"
+            )
+
+          return [] if value.empty?
+
+          split_link_values(
+            value
+          ).filter_map do |link_value|
+            parse_link_value(
+              link_value
+            )
+          end
+        end
+
+        def parse_link_value(value)
+          match =
+            value.match(
+              /\A\s*<([^>]*)>\s*(.*)\z/
+            )
+
+          return unless match
+
+          href = match[1]
+          parameters =
+            parse_parameters(
+              match[2]
+            )
+
+          return if parameters.key?(
+            "anchor"
+          )
+
+          relations =
+            parameters
+              .fetch("rel", "")
+              .split(/\s+/)
+              .map(&:downcase)
+
+          return unless relations.include?(
+            "alternate"
+          )
+
+          build_endpoint(
+            href,
+            parameters["type"],
+            :header
+          )
+        end
+
+        def parse_parameters(value)
+          parameters = {}
+
+          scanner =
+            value.to_s
+
+          scanner.scan(
+            /;\s*([!#$%&'*+\-.^_`|~0-9A-Za-z]+)\s*=\s*(?:"((?:\\.|[^"])*)"|([^;\s,]+))/
+          ) do |name, quoted, token|
+            key = name.downcase
+
+            next if parameters.key?(key)
+
+            raw =
+              quoted.nil? ?
+                token :
+                quoted.gsub(
+                  /\\(.)/,
+                  '\1'
+                )
+
+            parameters[key] = raw
+          end
+
+          parameters
+        end
+
+        def build_endpoint(
+          href,
+          media_type,
+          source
+        )
+          format =
+            MEDIA_TYPES[
+              normalize_media_type(
+                media_type
+              )
+            ]
+
+          return unless format
+
+          url =
+            resolve_url(href)
+
+          return unless url
+
+          Endpoint.new(
+            url: url,
+            format: format,
+            source: source
+          )
+        end
+
+        def resolve_url(value)
+          candidate =
+            value.to_s.strip
+
+          return if candidate.empty?
+
+          resolved =
+            URI.join(
+              @page_url,
+              candidate
+            )
+
+          return unless Url.web?(
+            resolved.to_s
+          )
+
+          resolved.to_s
+        rescue URI::InvalidURIError
+          nil
+        end
+
+        def normalize_media_type(value)
+          value
+            .to_s
+            .split(";", 2)
+            .first
+            .to_s
+            .strip
+            .downcase
+        end
+
+        def header_value(name)
+          key = name.downcase
+
+          pair =
+            @headers.find do |header_name, _value|
+              header_name.to_s.downcase == key
+            end
+
+          pair ?
+            pair.last.to_s :
+            ""
+        end
+
+        def split_link_values(value)
+          results = []
+          current = +""
+          quoted = false
+          angle = false
+          escaped = false
+
+          value.each_char do |character|
+            if escaped
+              current << character
+              escaped = false
+              next
+            end
+
+            if quoted && character == "\\"
+              current << character
+              escaped = true
+              next
+            end
+
+            case character
+            when '"'
+              quoted = !quoted unless angle
+              current << character
+            when "<"
+              angle = true unless quoted
+              current << character
+            when ">"
+              angle = false unless quoted
+              current << character
+            when ","
+              if quoted || angle
+                current << character
+              else
+                append_link_value(
+                  results,
+                  current
+                )
+
+                current = +""
+              end
+            else
+              current << character
+            end
+          end
+
+          append_link_value(
+            results,
+            current
+          )
+
+          results
+        end
+
+        def append_link_value(
+          results,
+          value
+        )
+          stripped =
+            value.to_s.strip
+
+          results << stripped unless stripped.empty?
+        end
+      end
+    end
+  end
+end

data/lib/rails_den/onebox/oembed/response.rb

@@ -0,0 +1,375 @@
+require "json"
+require "nokogiri"
+
+module RailsDen
+  module Onebox
+    module OEmbed
+      class Response
+        TYPES = %w[
+          photo
+          video
+          link
+          rich
+        ].freeze
+
+        ATTRIBUTES = %i[
+          type
+          version
+          title
+          author_name
+          author_url
+          provider_name
+          provider_url
+          cache_age
+          thumbnail_url
+          thumbnail_width
+          thumbnail_height
+          url
+          html
+          width
+          height
+          raw
+        ].freeze
+
+        attr_reader(*ATTRIBUTES)
+
+        def self.parse(
+          body,
+          format:
+        )
+          data =
+            case format
+            when :json
+              parse_json(body)
+            when :xml
+              parse_xml(body)
+            else
+              raise UnsupportedFormatError,
+                    "Unsupported oEmbed format: #{format.inspect}"
+            end
+
+          new(data)
+        end
+
+        def self.parse_json(body)
+          data =
+            JSON.parse(
+              body.to_s
+            )
+
+          unless data.is_a?(Hash)
+            raise InvalidResponseError,
+                  "oEmbed JSON response must be an object"
+          end
+
+          data
+        rescue JSON::ParserError => error
+          raise InvalidResponseError,
+                "Invalid oEmbed JSON: #{error.message}"
+        end
+
+        def self.parse_xml(body)
+          source = body.to_s
+
+          if source.match?(
+            /<!DOCTYPE|<!ENTITY/i
+          )
+            raise InvalidResponseError,
+                  "oEmbed XML cannot contain a DTD or entity declaration"
+          end
+
+          document =
+            Nokogiri::XML(
+              source
+            ) do |config|
+              config.strict.nonet
+            end
+
+          unless document.root&.name == "oembed"
+            raise InvalidResponseError,
+                  "oEmbed XML must have an oembed root element"
+          end
+
+          document
+            .root
+            .element_children
+            .each_with_object({}) do |node, data|
+              data[node.name] = node.text
+            end
+        rescue Nokogiri::XML::SyntaxError => error
+          raise InvalidResponseError,
+                "Invalid oEmbed XML: #{error.message}"
+        end
+
+        def initialize(data)
+          @raw =
+            stringify_keys(
+              data
+            ).freeze
+
+          @version =
+            normalize_text(
+              @raw["version"]
+            )
+
+          validate_version!
+
+          @type =
+            normalize_type(
+              @raw["type"]
+            )
+
+          validate_type!
+
+          @title =
+            normalize_text(
+              @raw["title"]
+            )
+
+          @author_name =
+            normalize_text(
+              @raw["author_name"]
+            )
+
+          @author_url =
+            safe_web_url(
+              @raw["author_url"]
+            )
+
+          @provider_name =
+            normalize_text(
+              @raw["provider_name"]
+            )
+
+          @provider_url =
+            safe_web_url(
+              @raw["provider_url"]
+            )
+
+          @cache_age =
+            nonnegative_integer(
+              @raw["cache_age"]
+            )
+
+          @url =
+            safe_web_url(
+              @raw["url"]
+            )
+
+          @html =
+            normalize_html(
+              @raw["html"]
+            )
+
+          @width =
+            positive_integer(
+              @raw["width"]
+            )
+
+          @height =
+            positive_integer(
+              @raw["height"]
+            )
+
+          normalize_thumbnail!
+          validate_type_requirements!
+
+          freeze
+        end
+
+        def to_h
+          ATTRIBUTES.to_h do |attribute|
+            [
+              attribute,
+              public_send(attribute)
+            ]
+          end
+        end
+
+        private
+
+        def validate_version!
+          return if @version == "1.0"
+
+          raise InvalidResponseError,
+                "oEmbed version must be 1.0"
+        end
+
+        def normalize_type(value)
+          normalize_text(
+            value
+          )&.downcase
+        end
+
+        def validate_type!
+          return if TYPES.include?(@type)
+
+          raise InvalidResponseError,
+                "oEmbed response has an invalid type"
+        end
+
+        def validate_type_requirements!
+          case @type
+          when "photo"
+            require_value!(
+              @url,
+              "photo url"
+            )
+
+            require_dimension!(
+              @width,
+              "photo width"
+            )
+
+            require_dimension!(
+              @height,
+              "photo height"
+            )
+          when "video", "rich"
+            require_value!(
+              @html,
+              "#{@type} html"
+            )
+
+            require_dimension!(
+              @width,
+              "#{@type} width"
+            )
+
+            require_dimension!(
+              @height,
+              "#{@type} height"
+            )
+          end
+        end
+
+        def normalize_thumbnail!
+          thumbnail_url =
+            safe_web_url(
+              @raw["thumbnail_url"]
+            )
+
+          thumbnail_width =
+            positive_integer(
+              @raw["thumbnail_width"]
+            )
+
+          thumbnail_height =
+            positive_integer(
+              @raw["thumbnail_height"]
+            )
+
+          if thumbnail_url &&
+             thumbnail_width &&
+             thumbnail_height
+            @thumbnail_url =
+              thumbnail_url
+
+            @thumbnail_width =
+              thumbnail_width
+
+            @thumbnail_height =
+              thumbnail_height
+          else
+            @thumbnail_url = nil
+            @thumbnail_width = nil
+            @thumbnail_height = nil
+          end
+        end
+
+        def safe_web_url(value)
+          candidate =
+            normalize_text(value)
+
+          return unless candidate
+          return unless Url.web?(candidate)
+
+          candidate
+        end
+
+        def normalize_text(value)
+          string =
+            value.to_s
+                 .encode(
+                   Encoding::UTF_8,
+                   invalid: :replace,
+                   undef: :replace,
+                   replace: ""
+                 )
+                 .gsub(/\s+/, " ")
+                 .strip
+
+          return if string.empty?
+
+          string
+        end
+
+        def normalize_html(value)
+          string =
+            value.to_s.encode(
+              Encoding::UTF_8,
+              invalid: :replace,
+              undef: :replace,
+              replace: ""
+            )
+
+          return if string.strip.empty?
+
+          string
+        end
+
+        def positive_integer(value)
+          integer =
+            Integer(
+              value,
+              exception: false
+            )
+
+          return unless integer
+          return unless integer.positive?
+
+          integer
+        end
+
+        def nonnegative_integer(value)
+          integer =
+            Integer(
+              value,
+              exception: false
+            )
+
+          return unless integer
+          return if integer.negative?
+
+          integer
+        end
+
+        def require_value!(
+          value,
+          name
+        )
+          return unless value.nil?
+
+          raise InvalidResponseError,
+                "oEmbed #{name} is required"
+        end
+
+        def require_dimension!(
+          value,
+          name
+        )
+          return if value
+
+          raise InvalidResponseError,
+                "oEmbed #{name} is required"
+        end
+
+        def stringify_keys(data)
+          data.each_with_object({}) do |(key, value), result|
+            result[key.to_s] = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_den/onebox/oembed.rb

@@ -0,0 +1,18 @@
+module RailsDen
+  module Onebox
+    module OEmbed
+      class Error < RailsDen::Onebox::Error
+      end
+
+      class InvalidResponseError < Error
+      end
+
+      class UnsupportedFormatError < Error
+      end
+    end
+  end
+end
+
+require "rails_den/onebox/oembed/discovery"
+require "rails_den/onebox/oembed/response"
+require "rails_den/onebox/oembed/client"

data/lib/rails_den/onebox/providers/base.rb

@@ -0,0 +1,23 @@
+module RailsDen
+  module Onebox
+    module Providers
+      class Base
+        class << self
+          def key
+            raise NotImplementedError,
+                  "#{name} must implement .key"
+          end
+
+          def handles?(_url)
+            false
+          end
+
+          def call(_url)
+            raise NotImplementedError,
+                  "#{name} must implement .call"
+          end
+        end
+      end
+    end
+  end
+end