rails_den 2.0.0

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

@@ -0,0 +1,402 @@
+require "json"
+require "uri"
+
+module RailsDen
+  module Onebox
+    module Providers
+      class Bluesky < Base
+        BLUESKY_HOSTS = %w[
+          bsky.app
+          www.bsky.app
+        ].freeze
+
+        PROVIDER_URL =
+          "https://bsky.app/".freeze
+
+        PUBLIC_API_ORIGIN =
+          "https://public.api.bsky.app".freeze
+
+        EMBED_ORIGIN =
+          "https://embed.bsky.app".freeze
+
+        DID_PATTERN =
+          /\Adid:[a-z0-9]+:[A-Za-z0-9._:%-]+\z/i
+
+        RECORD_KEY_PATTERN =
+          /\A[A-Za-z0-9._~-]+\z/
+
+        DOMAIN_LABEL_PATTERN =
+          /\A[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\z/i
+
+        class << self
+          def key
+            :bluesky
+          end
+
+          def handles?(url)
+            !resource_details_for_url(
+              url
+            ).nil?
+          end
+
+          def call(
+            url,
+            generic_provider: Generic,
+            fetcher: Fetcher
+          )
+            details =
+              resource_details_for_url(
+                url
+              )
+
+            return unless details
+
+            generic =
+              generic_provider.call(url)
+
+            return unless generic
+
+            resolved_details =
+              resolve_details(
+                details,
+                generic,
+                fetcher
+              )
+
+            Result.new(
+              url: generic.url,
+              canonical_url:
+                generic.canonical_url,
+              kind:
+                result_kind(
+                  generic,
+                  resolved_details
+                ),
+              provider_name: "Bluesky",
+              provider_url: PROVIDER_URL,
+              title: generic.title,
+              description:
+                generic.description,
+              author_name:
+                generic.author_name,
+              author_url:
+                generic.author_url,
+              site_name:
+                generic.site_name,
+              image_url:
+                generic.image_url,
+              thumbnail_url:
+                generic.thumbnail_url,
+              embed_url:
+                embed_url(
+                  resolved_details
+                ),
+              html: nil,
+              width: generic.width,
+              height: generic.height,
+              published_at:
+                generic.published_at,
+              metadata:
+                bluesky_metadata(
+                  generic.metadata,
+                  resolved_details
+                )
+            )
+          end
+
+          private
+
+          def resource_details_for_url(value)
+            uri =
+              parse_url(value)
+
+            return unless uri
+
+            host =
+              uri.hostname
+                 .to_s
+                 .downcase
+
+            return unless BLUESKY_HOSTS.include?(
+              host
+            )
+
+            resource_details(uri)
+          end
+
+          def resource_details(uri)
+            segments =
+              path_segments(uri)
+
+            case segments
+            in ["profile", actor]
+              return unless valid_actor?(
+                actor
+              )
+
+              {
+                resource_type: "profile",
+                actor: actor
+              }
+            in ["profile", actor, "post", record_key]
+              return unless valid_actor?(
+                actor
+              )
+
+              return unless valid_record_key?(
+                record_key
+              )
+
+              {
+                resource_type: "post",
+                actor: actor,
+                record_key: record_key
+              }
+            else
+              nil
+            end
+          end
+
+          def parse_url(value)
+            candidate =
+              value.to_s.strip
+
+            return unless Url.web?(
+              candidate
+            )
+
+            uri =
+              URI.parse(candidate)
+
+            return unless uri.hostname
+
+            uri
+          rescue URI::InvalidURIError
+            nil
+          end
+
+          def path_segments(uri)
+            uri.path
+               .to_s
+               .split("/")
+               .reject(&:empty?)
+          end
+
+          def valid_actor?(value)
+            candidate =
+              value.to_s
+
+            valid_did?(candidate) ||
+              valid_handle?(candidate)
+          end
+
+          def valid_did?(value)
+            value.to_s.match?(
+              DID_PATTERN
+            )
+          end
+
+          def valid_handle?(value)
+            candidate =
+              value.to_s.downcase
+
+            return false if candidate.empty?
+            return false unless candidate.include?(".")
+            return false if candidate.end_with?(".")
+            return false if candidate.length > 253
+
+            labels =
+              candidate.split(".")
+
+            labels.all? do |label|
+              label.length <= 63 &&
+                label.match?(
+                  DOMAIN_LABEL_PATTERN
+                )
+            end
+          end
+
+          def valid_record_key?(value)
+            candidate =
+              value.to_s
+
+            return false if candidate.empty?
+            return false if candidate.length > 512
+
+            candidate.match?(
+              RECORD_KEY_PATTERN
+            )
+          end
+
+          def resolve_details(
+            details,
+            generic,
+            fetcher
+          )
+            return details unless details[
+              :resource_type
+            ] == "post"
+
+            did =
+              did_from_details(
+                details
+              ) ||
+              did_from_canonical(
+                generic,
+                details
+              ) ||
+              resolve_handle(
+                details[:actor],
+                fetcher
+              )
+
+            return details unless did
+
+            details.merge(
+              did: did
+            )
+          end
+
+          def did_from_details(details)
+            actor =
+              details[:actor].to_s
+
+            actor if valid_did?(actor)
+          end
+
+          def did_from_canonical(
+            generic,
+            original_details
+          )
+            canonical_details =
+              resource_details_for_url(
+                generic.canonical_url
+              )
+
+            return unless canonical_details
+
+            return unless canonical_details[
+              :resource_type
+            ] == "post"
+
+            return unless canonical_details[
+              :record_key
+            ] == original_details[
+              :record_key
+            ]
+
+            actor =
+              canonical_details[:actor]
+
+            return unless valid_did?(
+              actor
+            )
+
+            actor
+          end
+
+          def resolve_handle(
+            actor,
+            fetcher
+          )
+            return actor if valid_did?(
+              actor
+            )
+
+            return unless valid_handle?(
+              actor
+            )
+
+            query =
+              URI.encode_www_form(
+                handle: actor
+              )
+
+            response =
+              fetcher.call(
+                "#{PUBLIC_API_ORIGIN}/xrpc/" \
+                  "com.atproto.identity.resolveHandle" \
+                  "?#{query}"
+              )
+
+            return unless response.status.between?(
+              200,
+              299
+            )
+
+            data =
+              JSON.parse(
+                response.body.to_s
+              )
+
+            did =
+              data["did"].to_s.strip
+
+            return unless valid_did?(
+              did
+            )
+
+            did
+          rescue RailsDen::Onebox::Error,
+                 JSON::ParserError
+            nil
+          end
+
+          def result_kind(
+            generic,
+            details
+          )
+            if details[
+              :resource_type
+            ] == "post"
+              :rich
+            else
+              generic.kind
+            end
+          end
+
+          def embed_url(details)
+            return unless details[
+              :resource_type
+            ] == "post"
+
+            did =
+              details[:did]
+
+            record_key =
+              details[:record_key]
+
+            return unless valid_did?(
+              did
+            )
+
+            return unless valid_record_key?(
+              record_key
+            )
+
+            "#{EMBED_ORIGIN}/embed/" \
+              "#{did}/" \
+              "app.bsky.feed.post/" \
+              "#{record_key}"
+          end
+
+          def bluesky_metadata(
+            metadata,
+            details
+          )
+            source =
+              if metadata.respond_to?(:to_h)
+                metadata.to_h
+              else
+                {}
+              end
+
+            source.merge(
+              bluesky: details
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,310 @@
+require "uri"
+
+module RailsDen
+  module Onebox
+    module Providers
+      class Generic < Base
+        HTML_CONTENT_TYPES = %w[
+          text/html
+          application/xhtml+xml
+        ].freeze
+
+        class << self
+          def key
+            :generic
+          end
+
+          def handles?(url)
+            Url.web?(url)
+          end
+
+          def call(
+            url,
+            fetcher: Fetcher,
+            oembed_client: OEmbed::Client
+          )
+            response =
+              fetcher.call(url)
+
+            if html_response?(response)
+              build_html_result(
+                response,
+                fetcher: fetcher,
+                oembed_client: oembed_client
+              )
+            else
+              build_fallback_result(
+                response
+              )
+            end
+          end
+
+          private
+
+          def build_html_result(
+            response,
+            fetcher:,
+            oembed_client:
+          )
+            metadata =
+              Metadata.call(
+                response.body,
+                page_url: response.url
+              )
+
+            oembed =
+              resolve_oembed(
+                response,
+                fetcher: fetcher,
+                oembed_client: oembed_client
+              )
+
+            Result.new(
+              url: response.original_url,
+              canonical_url:
+                metadata[
+                  :canonical_url
+                ],
+              kind:
+                result_kind(
+                  metadata,
+                  oembed
+                ),
+              provider_name:
+                first_present(
+                  oembed&.provider_name,
+                  metadata[:site_name],
+                  hostname_for(
+                    response.url
+                  )
+                ),
+              provider_url:
+                first_present(
+                  oembed&.provider_url,
+                  origin_for(
+                    response.url
+                  )
+                ),
+              title:
+                first_present(
+                  oembed&.title,
+                  metadata[:title]
+                ),
+              description:
+                metadata[:description],
+              author_name:
+                first_present(
+                  oembed&.author_name,
+                  metadata[:author_name]
+                ),
+              author_url:
+                oembed&.author_url,
+              site_name:
+                metadata[:site_name],
+              image_url:
+                result_image_url(
+                  metadata,
+                  oembed
+                ),
+              thumbnail_url:
+                oembed&.thumbnail_url,
+              html:
+                oembed&.html,
+              width:
+                first_present(
+                  oembed&.width,
+                  metadata[:image_width]
+                ),
+              height:
+                first_present(
+                  oembed&.height,
+                  metadata[:image_height]
+                ),
+              published_at:
+                metadata[:published_at],
+              metadata: {
+                content_type:
+                  content_type(
+                    response
+                  ),
+                image_alt:
+                  metadata[:image_alt],
+                object_type:
+                  metadata[:type],
+                twitter_card:
+                  metadata[:twitter_card],
+                source:
+                  metadata[:raw],
+                oembed:
+                  oembed&.to_h
+              }
+            )
+          end
+
+          def resolve_oembed(
+            response,
+            fetcher:,
+            oembed_client:
+          )
+            endpoint =
+              OEmbed::Discovery.call(
+                html: response.body,
+                headers: response.headers,
+                page_url: response.url
+              )
+
+            return unless endpoint
+
+            oembed_client.call(
+              endpoint,
+              fetcher: fetcher
+            )
+          rescue RailsDen::Onebox::Error
+            nil
+          end
+
+          def build_fallback_result(response)
+            Result.new(
+              url: response.original_url,
+              canonical_url:
+                response.url,
+              kind: :link,
+              provider_name:
+                hostname_for(
+                  response.url
+                ),
+              provider_url:
+                origin_for(
+                  response.url
+                ),
+              metadata: {
+                content_type:
+                  content_type(
+                    response
+                  )
+              }
+            )
+          end
+
+          def html_response?(response)
+            HTML_CONTENT_TYPES.include?(
+              content_type(response)
+            )
+          end
+
+          def content_type(response)
+            response
+              .headers
+              .fetch(
+                "content-type",
+                ""
+              )
+              .split(
+                ";",
+                2
+              )
+              .first
+              .to_s
+              .strip
+              .downcase
+          end
+
+          def result_kind(
+            metadata,
+            oembed
+          )
+            if oembed
+              kind_for_oembed(
+                oembed.type
+              )
+            else
+              kind_for_metadata(
+                metadata[:type]
+              )
+            end
+          end
+
+          def kind_for_oembed(type)
+            case type
+            when "photo"
+              :image
+            when "video"
+              :video
+            when "rich"
+              :rich
+            else
+              :link
+            end
+          end
+
+          def result_image_url(
+            metadata,
+            oembed
+          )
+            if oembed&.type == "photo"
+              oembed.url
+            else
+              metadata[:image_url]
+            end
+          end
+
+          def first_present(*values)
+            values.find do |value|
+              if value.respond_to?(:empty?)
+                !value.empty?
+              else
+                !value.nil?
+              end
+            end
+          end
+
+          def hostname_for(url)
+            URI.parse(
+              url
+            ).hostname.to_s
+          rescue URI::InvalidURIError
+            ""
+          end
+
+          def origin_for(url)
+            uri = URI.parse(url)
+
+            default_port =
+              uri.scheme == "https" ?
+                443 :
+                80
+
+            port =
+              if uri.port == default_port
+                ""
+              else
+                ":#{uri.port}"
+              end
+
+            "#{uri.scheme}://#{uri.hostname}#{port}"
+          rescue URI::InvalidURIError
+            nil
+          end
+
+          def kind_for_metadata(type)
+            value =
+              type.to_s.downcase
+
+            case value
+            when "article"
+              :article
+            when /\Avideo(?:\.|\z)/
+              :video
+            when /\Amusic(?:\.|\z)/
+              :audio
+            when "profile"
+              :profile
+            else
+              :link
+            end
+          end
+        end
+      end
+    end
+  end
+end