rails_den 2.0.0

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

@@ -0,0 +1,292 @@
+require "uri"
+
+module RailsDen
+  module Onebox
+    module Providers
+      class TikTok < Base
+        TIKTOK_HOSTS = %w[
+          tiktok.com
+          www.tiktok.com
+          m.tiktok.com
+        ].freeze
+
+        SHORT_HOSTS = %w[
+          vm.tiktok.com
+          vt.tiktok.com
+        ].freeze
+
+        PROVIDER_URL =
+          "https://www.tiktok.com/".freeze
+
+        PLAYER_ORIGIN =
+          "https://www.tiktok.com/player/v1".freeze
+
+        POST_ID_PATTERN =
+          /\A\d+\z/
+
+        class << self
+          def key
+            :tiktok
+          end
+
+          def handles?(url)
+            uri =
+              parse_url(url)
+
+            return false unless uri
+
+            host =
+              normalized_host(uri)
+
+            if SHORT_HOSTS.include?(host)
+              return !path_segments(uri).empty?
+            end
+
+            return false unless TIKTOK_HOSTS.include?(
+              host
+            )
+
+            !resource_details(uri).nil?
+          end
+
+          def call(
+            url,
+            generic_provider: Generic
+          )
+            return unless handles?(url)
+
+            generic =
+              generic_provider.call(url)
+
+            return unless generic
+
+            details =
+              resolved_resource_details(
+                url,
+                generic
+              )
+
+            Result.new(
+              url: generic.url,
+              canonical_url:
+                generic.canonical_url,
+              kind:
+                result_kind(
+                  generic,
+                  details
+                ),
+              provider_name: "TikTok",
+              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(details),
+              html: nil,
+              width: generic.width,
+              height: generic.height,
+              published_at:
+                generic.published_at,
+              metadata:
+                tiktok_metadata(
+                  generic.metadata,
+                  details
+                )
+            )
+          end
+
+          private
+
+          def resolved_resource_details(
+            original_url,
+            generic
+          )
+            candidates = [
+              generic.canonical_url,
+              generic.url,
+              original_url
+            ].compact
+
+            candidates.each do |candidate|
+              details =
+                resource_details_for_url(
+                  candidate
+                )
+
+              return details if details
+            end
+
+            {
+              resource_type: "short_link"
+            }
+          end
+
+          def resource_details_for_url(value)
+            uri =
+              parse_url(value)
+
+            return unless uri
+
+            return unless TIKTOK_HOSTS.include?(
+              normalized_host(uri)
+            )
+
+            resource_details(uri)
+          end
+
+          def resource_details(uri)
+            segments =
+              path_segments(uri)
+
+            case segments
+            in [username, "video", post_id]
+              return unless valid_username?(
+                username
+              )
+
+              return unless valid_post_id?(
+                post_id
+              )
+
+              {
+                resource_type: "video",
+                username:
+                  username.delete_prefix("@"),
+                post_id: post_id
+              }
+            in [username]
+              return unless valid_username?(
+                username
+              )
+
+              {
+                resource_type: "profile",
+                username:
+                  username.delete_prefix("@")
+              }
+            in ["player", "v1", post_id]
+              return unless valid_post_id?(
+                post_id
+              )
+
+              {
+                resource_type: "video",
+                post_id: post_id
+              }
+            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 normalized_host(uri)
+            uri.hostname
+               .to_s
+               .downcase
+          end
+
+          def path_segments(uri)
+            uri.path
+               .to_s
+               .split("/")
+               .reject(&:empty?)
+          end
+
+          def valid_username?(value)
+            candidate =
+              value.to_s
+
+            return false unless candidate.start_with?(
+              "@"
+            )
+
+            username =
+              candidate.delete_prefix("@")
+
+            return false if username.empty?
+
+            username.match?(
+              /\A[A-Za-z0-9._]+\z/
+            )
+          end
+
+          def valid_post_id?(value)
+            value.to_s.match?(
+              POST_ID_PATTERN
+            )
+          end
+
+          def result_kind(
+            generic,
+            details
+          )
+            if details[:resource_type] == "video"
+              :video
+            else
+              generic.kind
+            end
+          end
+
+          def embed_url(details)
+            return unless details[
+              :resource_type
+            ] == "video"
+
+            post_id =
+              details[:post_id]
+
+            return unless post_id
+
+            "#{PLAYER_ORIGIN}/#{post_id}" \
+              "?autoplay=0" \
+              "&music_info=1" \
+              "&description=1"
+          end
+
+          def tiktok_metadata(
+            metadata,
+            details
+          )
+            source =
+              if metadata.respond_to?(:to_h)
+                metadata.to_h
+              else
+                {}
+              end
+
+            source.merge(
+              tiktok: details
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,414 @@
+require "ipaddr"
+require "uri"
+
+module RailsDen
+  module Onebox
+    module Providers
+      class Twitch < Base
+        TWITCH_HOSTS = %w[
+          twitch.tv
+          www.twitch.tv
+        ].freeze
+
+        CLIP_HOSTS = %w[
+          clips.twitch.tv
+          www.clips.twitch.tv
+        ].freeze
+
+        RESERVED_CHANNELS = %w[
+          directory
+          downloads
+          drops
+          inventory
+          jobs
+          p
+          search
+          settings
+          subscriptions
+          videos
+        ].freeze
+
+        PROVIDER_URL =
+          "https://www.twitch.tv/".freeze
+
+        PLAYER_ORIGIN =
+          "https://player.twitch.tv/".freeze
+
+        CLIP_EMBED_ORIGIN =
+          "https://clips.twitch.tv/embed".freeze
+
+        CHANNEL_PATTERN =
+          /\A[A-Za-z0-9_]{1,25}\z/
+
+        VIDEO_ID_PATTERN =
+          /\A\d+\z/
+
+        CLIP_SLUG_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
+            :twitch
+          end
+
+          def handles?(url)
+            !resource_details(url).nil?
+          end
+
+          def call(
+            url,
+            generic_provider: Generic
+          )
+            details =
+              resource_details(url)
+
+            return unless details
+
+            generic =
+              generic_provider.call(url)
+
+            return unless generic
+
+            Result.new(
+              url: generic.url,
+              canonical_url:
+                generic.canonical_url,
+              kind: :video,
+              provider_name: "Twitch",
+              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(details),
+              html: nil,
+              width: generic.width,
+              height: generic.height,
+              published_at:
+                generic.published_at,
+              metadata:
+                twitch_metadata(
+                  generic.metadata,
+                  details
+                )
+            )
+          end
+
+          private
+
+          def resource_details(url)
+            uri =
+              parse_url(url)
+
+            return unless uri
+
+            host =
+              uri.hostname
+                 .to_s
+                 .downcase
+
+            if CLIP_HOSTS.include?(host)
+              clip_details(uri)
+            elsif TWITCH_HOSTS.include?(host)
+              twitch_details(uri)
+            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 twitch_details(uri)
+            segments =
+              path_segments(uri)
+
+            case segments
+            in ["videos", video_id]
+              return unless valid_video_id?(
+                video_id
+              )
+
+              {
+                resource_type: "video",
+                video_id: video_id
+              }
+            in [channel, "clip", clip_slug]
+              return unless valid_channel?(
+                channel
+              )
+
+              return unless valid_clip_slug?(
+                clip_slug
+              )
+
+              {
+                resource_type: "clip",
+                channel: channel,
+                clip_slug: clip_slug
+              }
+            in [channel]
+              return unless valid_channel?(
+                channel
+              )
+
+              {
+                resource_type: "channel",
+                channel: channel
+              }
+            else
+              nil
+            end
+          end
+
+          def clip_details(uri)
+            segments =
+              path_segments(uri)
+
+            return unless segments.length == 1
+
+            clip_slug =
+              segments.first
+
+            return unless valid_clip_slug?(
+              clip_slug
+            )
+
+            {
+              resource_type: "clip",
+              clip_slug: clip_slug
+            }
+          end
+
+          def path_segments(uri)
+            uri.path
+               .to_s
+               .split("/")
+               .reject(&:empty?)
+          end
+
+          def valid_channel?(value)
+            return false unless value.match?(
+              CHANNEL_PATTERN
+            )
+
+            !RESERVED_CHANNELS.include?(
+              value.downcase
+            )
+          end
+
+          def valid_video_id?(value)
+            value.match?(
+              VIDEO_ID_PATTERN
+            )
+          end
+
+          def valid_clip_slug?(value)
+            value.match?(
+              CLIP_SLUG_PATTERN
+            )
+          end
+
+          def embed_url(details)
+            parents =
+              twitch_parent_hosts
+
+            return if parents.empty?
+
+            case details[:resource_type]
+            when "channel"
+              player_url(
+                "channel",
+                details[:channel],
+                parents
+              )
+            when "video"
+              player_url(
+                "video",
+                "v#{details[:video_id]}",
+                parents
+              )
+            when "clip"
+              clip_embed_url(
+                details[:clip_slug],
+                parents
+              )
+            end
+          end
+
+          def player_url(
+            parameter,
+            value,
+            parents
+          )
+            parameters = [
+              [parameter, value]
+            ]
+
+            append_parents!(
+              parameters,
+              parents
+            )
+
+            parameters << [
+              "autoplay",
+              "false"
+            ]
+
+            "#{PLAYER_ORIGIN}?" \
+              "#{URI.encode_www_form(parameters)}"
+          end
+
+          def clip_embed_url(
+            clip_slug,
+            parents
+          )
+            parameters = [
+              ["clip", clip_slug]
+            ]
+
+            append_parents!(
+              parameters,
+              parents
+            )
+
+            parameters << [
+              "autoplay",
+              "false"
+            ]
+
+            "#{CLIP_EMBED_ORIGIN}?" \
+              "#{URI.encode_www_form(parameters)}"
+          end
+
+          def append_parents!(
+            parameters,
+            parents
+          )
+            parents.each do |parent|
+              parameters << [
+                "parent",
+                parent
+              ]
+            end
+          end
+
+          def twitch_parent_hosts
+            Array(
+              RailsDen.config
+                      .onebox_twitch_parent_hosts
+            )
+              .filter_map do |value|
+                normalize_parent_host(value)
+              end
+              .uniq
+          end
+
+          def normalize_parent_host(value)
+            candidate =
+              value.to_s
+                   .strip
+                   .downcase
+
+            return if candidate.empty?
+
+            return candidate if candidate == "localhost"
+
+            if ip_address?(candidate)
+              return candidate if loopback_ipv4?(
+                candidate
+              )
+
+              return
+            end
+
+            return unless valid_domain?(
+              candidate
+            )
+
+            candidate
+          end
+
+          def ip_address?(value)
+            IPAddr.new(value)
+
+            true
+          rescue IPAddr::InvalidAddressError
+            false
+          end
+
+          def loopback_ipv4?(value)
+            address =
+              IPAddr.new(value)
+
+            return false unless address.ipv4?
+
+            IPAddr.new(
+              "127.0.0.0/8"
+            ).include?(address)
+          rescue IPAddr::InvalidAddressError
+            false
+          end
+
+          def valid_domain?(value)
+            return false unless value.include?(".")
+            return false if value.end_with?(".")
+            return false if value.length > 253
+
+            labels =
+              value.split(".")
+
+            labels.all? do |label|
+              label.length <= 63 &&
+                label.match?(
+                  DOMAIN_LABEL_PATTERN
+                )
+            end
+          end
+
+          def twitch_metadata(
+            metadata,
+            details
+          )
+            source =
+              if metadata.respond_to?(:to_h)
+                metadata.to_h
+              else
+                {}
+              end
+
+            source.merge(
+              twitch: details
+            )
+          end
+        end
+      end
+    end
+  end
+end