132 行
4.0 KiB
Ruby
132 行
4.0 KiB
Ruby
require 'time'
|
|
|
|
class PostMetadataFetcher
|
|
TIMESTAMP_PATTERN =
|
|
Regexp.new(
|
|
'\A(\d{4})-(\d{2})-(\d{2})T(\d{2})' \
|
|
'(?::(\d{2})(?::(\d{2})(?:\.(\d+))?)?)?' \
|
|
'(Z|[+-]\d{2}:?\d{2})?\z')
|
|
|
|
def self.fetch raw_url
|
|
uri, = Preview::UrlSafety.validate(raw_url)
|
|
response = Preview::HttpFetcher.fetch(
|
|
uri.to_s,
|
|
max_bytes: Preview::ThumbnailFetcher::HTML_MAX_BYTES)
|
|
metadata = Preview::HtmlMetadataExtractor.extract(response)
|
|
document = Nokogiri::HTML.parse(response.body)
|
|
content = lambda { |name|
|
|
document
|
|
.at_css("meta[property='#{ name }'], meta[name='#{ name }']")
|
|
&.[]('content')
|
|
&.strip
|
|
&.presence
|
|
}
|
|
duration = content.call('og:video:duration') || content.call('video:duration')
|
|
published = content.call('article:published_time') || content.call('date')
|
|
created_range = original_created_range(published)
|
|
platform_tags = platform_tags(uri)
|
|
{ title: metadata[:title],
|
|
thumbnail_base:
|
|
Preview::KnownSiteExtractor.thumbnail_url(uri) || metadata[:image_url],
|
|
original_created_from: serialise_time(created_range&.first),
|
|
original_created_before: serialise_time(created_range&.last),
|
|
duration: duration&.to_f&.then { _1.positive? ? (_1 * 1_000).round : nil },
|
|
tags: platform_tags.join(' ') }
|
|
end
|
|
|
|
def self.platform_tags uri
|
|
return ['動画', 'YouTube'] if Preview::KnownSiteExtractor.youtube_video_id(uri)
|
|
return ['動画', 'ニコニコ'] if Preview::KnownSiteExtractor.niconico_video_id(uri)
|
|
|
|
[]
|
|
end
|
|
|
|
def self.original_created_range value
|
|
return nil if value.blank?
|
|
|
|
raw = value.to_s.strip
|
|
from, before =
|
|
case raw
|
|
when /\A(\d{4})\z/
|
|
year = Regexp.last_match(1).to_i
|
|
from = Time.zone.local(year, 1, 1)
|
|
[from, from + 1.year]
|
|
when /\A(\d{4})-(\d{2})\z/
|
|
year = Regexp.last_match(1).to_i
|
|
month = Regexp.last_match(2).to_i
|
|
from = Time.zone.local(year, month, 1)
|
|
[from, from + 1.month]
|
|
when /\A(\d{4})-(\d{2})-(\d{2})\z/
|
|
year = Regexp.last_match(1).to_i
|
|
month = Regexp.last_match(2).to_i
|
|
day = Regexp.last_match(3).to_i
|
|
from = Time.zone.local(year, month, day)
|
|
[from, from + 1.day]
|
|
else
|
|
parse_timestamp_range(raw)
|
|
end
|
|
return nil if from.nil? || before.nil?
|
|
|
|
[from, before]
|
|
rescue ArgumentError, TypeError
|
|
nil
|
|
end
|
|
|
|
def self.parse_timestamp_range raw
|
|
match = raw.match(TIMESTAMP_PATTERN)
|
|
return nil unless match
|
|
|
|
year = match[1].to_i
|
|
month = match[2].to_i
|
|
day = match[3].to_i
|
|
hour = match[4].to_i
|
|
minute = match[5]&.to_i || 0
|
|
second = match[6]&.to_i || 0
|
|
fraction = match[7]
|
|
offset = match[8]
|
|
whole_second = second + fractional_seconds(fraction)
|
|
from =
|
|
if offset.present?
|
|
Time.new(year, month, day, hour, minute, whole_second, parse_offset(offset)).in_time_zone
|
|
else
|
|
Time.zone.local(year, month, day, hour, minute, whole_second)
|
|
end
|
|
before =
|
|
if fraction.present?
|
|
from + (10**(-fraction.length))
|
|
elsif match[6].present?
|
|
from + 1.second
|
|
elsif match[5].present?
|
|
from + 1.minute
|
|
else
|
|
from + 1.hour
|
|
end
|
|
[from, before]
|
|
end
|
|
|
|
def self.parse_offset value
|
|
return '+00:00' if value == 'Z'
|
|
|
|
value.match?(/\A[+-]\d{2}:\d{2}\z/) ? value : "#{ value[0, 3] }:#{ value[3, 2] }"
|
|
end
|
|
|
|
def self.fractional_seconds value
|
|
return 0 if value.blank?
|
|
|
|
Rational(value.to_i, 10**value.length)
|
|
end
|
|
|
|
def self.serialise_time value
|
|
return nil if value.nil?
|
|
|
|
value.nsec.zero? ? value.iso8601 : value.iso8601(9)
|
|
end
|
|
|
|
private_class_method :platform_tags,
|
|
:original_created_range,
|
|
:parse_timestamp_range,
|
|
:parse_offset,
|
|
:fractional_seconds,
|
|
:serialise_time
|
|
end
|