automatic 14.12.2 → 26.09

data/plugins/filter/present.rb

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+# Name::        Automatic::Plugin::Filter::Present
+# Description:: Keep items whose configured fields are all present.
+# Author:       id774 (More info: https://id774.net)
+# Source Code:: https://github.com/id774/automaticruby
+# License::     The GPL version 3, or LGPL version 3 (Dual License).
+# Contact::     idnanashi@gmail.com
+# Created::     Aug 24, 2026
+# Updated::     Aug 24, 2026
+# Copyright::   Copyright (c) 2012-2026 Automatic Ruby Developers.
+
+module Automatic::Plugin
+  class FilterPresent
+    # The item fields presence may be checked over. `date` is not one, being
+    # absent from a plain summary as often as not, and `enclosure` is not
+    # either, being a structure rather than a value.
+    FIELDS = %w[title link description author comments source content_encoded].freeze
+
+    def initialize(config, pipeline = [])
+      @config   = config || {}
+      @pipeline = pipeline
+      @fields   = validated_fields
+    end
+
+    # Keeps only the items where every configured field is present. A feed
+    # that kept nothing is dropped from the output rather than passed on empty.
+    def run
+      @pipeline.each_with_object([]) do |feeds, returned|
+        next if feeds.nil?
+
+        survivors = feeds.items.select { |item| present?(item) }
+        returned << Automatic::FeedMaker.create_pipeline(survivors) unless survivors.empty?
+      end
+    end
+
+    private
+
+    def validated_fields
+      given = @config['fields']
+      raise ArgumentError, 'FilterPresent takes fields as a list' unless given.is_a?(Array)
+
+      names = given.map(&:to_s)
+      raise ArgumentError, 'FilterPresent needs a non-empty fields list' if names.empty?
+
+      unknown = names - FIELDS
+      unless unknown.empty?
+        raise ArgumentError,
+              "FilterPresent cannot inspect #{unknown.join(', ')}; " \
+              "the fields are #{FIELDS.join(', ')}"
+      end
+
+      duplicated = names.tally.select { |_name, count| count > 1 }.keys
+      raise ArgumentError, "FilterPresent was given #{duplicated.join(', ')} twice" unless duplicated.empty?
+
+      names
+    end
+
+    def present?(item)
+      @fields.all? { |field| field_present?(item, field) }
+    end
+
+    # A field an item does not carry, or whose value is nil, is absent. A
+    # field whose value answers #content -- a parsed source or enclosure -- is
+    # judged on that content rather than on the element itself.
+    def field_present?(item, field)
+      return false unless item.respond_to?(field)
+
+      value = item.public_send(field)
+      return false if value.nil?
+
+      value = value.content if value.respond_to?(:content)
+      !value.to_s.strip.empty?
+    end
+  end
+end

data/plugins/filter/rand.rb

@@ -1,28 +1,27 @@
 # -*- coding: utf-8 -*-
-# Name::      Automatic::Plugin::Filter::Rand
-# Author::    soramugi <http://soramugi.net>
-#             774 <http://id774.net>
-# Created::   Mar  6, 2013
-# Updated::   Feb 21, 2014
-# Copyright:: Copyright (c) 2012-2014 Automatic Ruby Developers.
-# License::   Licensed under the GNU GENERAL PUBLIC LICENSE, Version 3.0.
+# Name::        Automatic::Plugin::Filter::Rand
+# Author:       soramugi (More info: http://soramugi.net)
+# Source Code:: https://github.com/id774/automaticruby
+# License::     The GPL version 3, or LGPL version 3 (Dual License).
+# Contact::     idnanashi@gmail.com
+# Created::     Mar  6, 2013
+# Updated::     Aug 15, 2026
+# Copyright::   Copyright (c) 2012-2026 Automatic Ruby Developers.
 
 module Automatic::Plugin
   class FilterRand
-
-    def initialize(config, pipeline=[])
-      @config   = config
+    def initialize(config, pipeline = [])
+      @config   = config || {}
       @pipeline = pipeline
     end
 
+    # Shuffles each feed's items. Combined with FilterOne, picks one at random.
     def run
-      @return_feeds = []
-      @pipeline.each {|feed|
-        unless feed.nil?
-          @return_feeds << Automatic::FeedMaker.create_pipeline(feed.items.shuffle)
-        end
-      }
-      @return_feeds
+      @pipeline.each_with_object([]) do |feeds, returned|
+        next if feeds.nil?
+
+        returned << Automatic::FeedMaker.create_pipeline(feeds.items.shuffle)
+      end
     end
   end
 end

data/plugins/filter/sakura_ai.rb

@@ -0,0 +1,205 @@
+# -*- coding: utf-8 -*-
+# Name::        Automatic::Plugin::Filter::SakuraAI
+# Description:: Replace each item's description with what the Sakura AI Engine answers.
+# Author:       id774 (More info: https://id774.net)
+# Source Code:: https://github.com/id774/automaticruby
+# License::     The GPL version 3, or LGPL version 3 (Dual License).
+# Contact::     idnanashi@gmail.com
+# Created::     Aug 17, 2026
+# Updated::     Aug 17, 2026
+# Copyright::   Copyright (c) 2012-2026 Automatic Ruby Developers.
+#
+# One transformation: the item's description goes to the Sakura AI Engine under
+# the Recipe's prompt, and the answer becomes the item's description. What that
+# transformation is -- a summary, a translation, an extraction, a
+# classification -- is the prompt's business, not this plugin's.
+#
+# The Sakura AI Engine offers an OpenAI-compatible chat completions interface,
+# and this plugin is still its own rather than a mode of FilterOpenAI. It is a
+# different service: a different endpoint, a different account, a different set
+# of models, its own limits and its own errors, and any of those may move
+# without OpenAI moving. A Recipe naming FilterSakuraAI says which service the
+# text is sent to, which a `provider:` setting would not.
+#
+# @see https://manual.sakura.ad.jp/cloud/ai-engine/
+
+module Automatic::Plugin
+  class FilterSakuraAI
+    require 'json'
+    require 'net/http'
+    require 'openssl'
+    require 'uri'
+
+    # The one endpoint the service publishes for this. It is not a setting: an
+    # operator has no version of this plugin that talks to a different host,
+    # and a setting for it would be a way to send the token somewhere else.
+    ENDPOINT = URI('https://api.ai.sakura.ad.jp/v1/chat/completions')
+
+    OPEN_TIMEOUT = 10
+
+    # Generous, and bounded. A model given several articles thinks for a while;
+    # an unattended run that waits forever is the failure this exists against.
+    READ_TIMEOUT = 300
+
+    # A failure that another attempt will not get past: a setting that is
+    # wrong, a request the service refuses, an answer this plugin cannot read.
+    class Error < StandardError; end
+
+    # A failure that another attempt may get past: the network, a rate limit, a
+    # server error.
+    class TemporaryError < StandardError; end
+
+    def initialize(config, pipeline = [])
+      @config   = config || {}
+      @pipeline = pipeline
+    end
+
+    # Replaces each item's description with the answer. Nothing else about an
+    # item is touched, and the feeds and their items arrive and leave in the
+    # same order and number.
+    def run
+      validate_settings
+
+      @pipeline.each { |feeds|
+        next if feeds.nil?
+
+        feeds.items.each { |item| transform(item) }
+      }
+      @pipeline
+    end
+
+    private
+
+    # Checked before the first request, because a Recipe this plugin cannot
+    # carry out is the operator's mistake and will be the same mistake on every
+    # item. The token is never named in a message.
+    def validate_settings
+      raise ArgumentError, 'FilterSakuraAI needs a token' if token.empty?
+      raise ArgumentError, 'FilterSakuraAI needs a model' if model.empty?
+      raise ArgumentError, 'FilterSakuraAI needs a prompt' if prompt.empty?
+    end
+
+    def token
+      @config['token'].to_s
+    end
+
+    def model
+      @config['model'].to_s.strip
+    end
+
+    def prompt
+      @config['prompt'].to_s.strip
+    end
+
+    def transform(item)
+      text = item.description.to_s
+      if text.strip.empty?
+        Automatic::Log.puts('warn', "FilterSakuraAI: nothing to send for #{item.link}")
+        return
+      end
+
+      Automatic::Log.puts('info', "FilterSakuraAI: asking #{model} about #{item.link}")
+      item.description = answer(text)
+    end
+
+    # The retry shape of doc/PLUGINS.md section 3.6, applied only to what
+    # retrying can help. A missing setting, a refused request or an answer in a
+    # shape this plugin cannot read is raised at once: trying again would fail
+    # the same way, more slowly.
+    def answer(text)
+      retries   = 0
+      retry_max = @config['retry'].to_i
+      begin
+        completion(text)
+      rescue TemporaryError => e
+        retries += 1
+        Automatic::Log.puts('error', "ErrorCount: #{retries}, FilterSakuraAI: #{e.message}")
+        if retries <= retry_max
+          sleep(@config['interval'].to_i)
+          retry
+        end
+        raise Error, "FilterSakuraAI gave up after #{retries} attempts: #{e.message}"
+      end
+    end
+
+    def completion(text)
+      # The prompt is the system turn and the description is the user turn it
+      # is applied to. They are separate messages, so that what an article says
+      # is never read as an instruction to this plugin or to the model.
+      body = {
+        'model' => model,
+        'messages' => [
+          { 'role' => 'system', 'content' => prompt },
+          { 'role' => 'user', 'content' => text }
+        ]
+      }
+      content(post(JSON.generate(body)))
+    end
+
+    def post(body)
+      request = Net::HTTP::Post.new(ENDPOINT)
+      request['Authorization'] = "Bearer #{token}"
+      request['Content-Type']  = 'application/json'
+      request.body = body
+
+      # TLS with the certificate verified, which is Net::HTTP's own default and
+      # is named here because it is not a thing to be turned off.
+      Net::HTTP.start(ENDPOINT.host, ENDPOINT.port,
+                      use_ssl: true,
+                      verify_mode: OpenSSL::SSL::VERIFY_PEER,
+                      open_timeout: OPEN_TIMEOUT,
+                      read_timeout: READ_TIMEOUT) { |http| http.request(request) }
+    rescue Timeout::Error, SystemCallError, SocketError, IOError,
+           OpenSSL::SSL::SSLError, Net::HTTPBadResponse => e
+      raise TemporaryError, "the request to the Sakura AI Engine failed: #{e.message}"
+    end
+
+    def content(response)
+      case response
+      when Net::HTTPSuccess
+        answer_text(parse(response.body))
+      when Net::HTTPTooManyRequests, Net::HTTPServerError
+        raise TemporaryError, "the Sakura AI Engine answered #{response.code}: #{reason(response)}"
+      else
+        raise Error, "the Sakura AI Engine answered #{response.code}: #{reason(response)}"
+      end
+    end
+
+    def parse(body)
+      JSON.parse(body.to_s)
+    rescue JSON::ParserError => e
+      raise Error, "the Sakura AI Engine answered with something that is not JSON: #{e.message}"
+    end
+
+    # The first choice's message content. An answer this plugin cannot find is
+    # an error and not an empty description: a Recipe that published the empty
+    # string here would have thrown the article away and reported success.
+    def answer_text(body)
+      choices = body['choices']
+      unless choices.is_a?(Array) && choices.first.is_a?(Hash)
+        raise Error, 'the Sakura AI Engine answered without a choice'
+      end
+
+      message = choices.first['message']
+      raise Error, 'the Sakura AI Engine answered without a message' unless message.is_a?(Hash)
+
+      text = message['content'].to_s.strip
+      raise Error, 'the Sakura AI Engine answered with no content' if text.empty?
+
+      text
+    end
+
+    # The service's own explanation where it gave one, the status line
+    # otherwise. Neither carries the token, and the settings are never logged
+    # or raised wholesale.
+    def reason(response)
+      body = JSON.parse(response.body.to_s)
+      error = body['error']
+      return error['message'].to_s if error.is_a?(Hash) && !error['message'].to_s.empty?
+
+      response.message.to_s
+    rescue JSON::ParserError
+      response.message.to_s
+    end
+  end
+end

data/plugins/filter/sanitize.rb

@@ -1,49 +1,44 @@
 # -*- coding: utf-8 -*-
-# Name::      Automatic::Plugin::Filter::Sanitize
-# Author::    774 <http://id774.net>
-# Created::   Jun 20, 2013
-# Updated::   Feb 21, 2014
-# Copyright:: Copyright (c) 2012-2014 Automatic Ruby Developers.
-# License::   Licensed under the GNU GENERAL PUBLIC LICENSE, Version 3.0.
+# Name::        Automatic::Plugin::Filter::Sanitize
+# Author:       id774 (More info: https://id774.net)
+# Source Code:: https://github.com/id774/automaticruby
+# License::     The GPL version 3, or LGPL version 3 (Dual License).
+# Contact::     idnanashi@gmail.com
+# Created::     Jun 20, 2013
+# Updated::     Aug 15, 2026
+# Copyright::   Copyright (c) 2012-2026 Automatic Ruby Developers.
 
 module Automatic::Plugin
   class FilterSanitize
-    require 'sanitize'
+    Automatic.require_optional('sanitize', needed_by: 'FilterSanitize')
 
-    def initialize(config, pipeline=[])
-      @config = config
+    MODES = {
+      'basic'   => Sanitize::Config::BASIC,
+      'relaxed' => Sanitize::Config::RELAXED
+    }.freeze
+
+    def initialize(config, pipeline = [])
+      @config   = config || {}
       @pipeline = pipeline
-      case @config['mode']
-        when "basic"
-          @mode = Sanitize::Config::BASIC
-        when "relaxed"
-          @mode = Sanitize::Config::RELAXED
-        else
-          @mode = Sanitize::Config::RESTRICTED
-      end
+      @mode     = MODES.fetch(@config['mode'].to_s, Sanitize::Config::RESTRICTED)
     end
 
+    # Strips HTML from descriptions.
     def run
-      @return_feeds = []
-      @pipeline.each {|feeds|
-        unless feeds.nil?
-          feeds.items.each {|feed|
-            feed = sanitize(feed)
-          }
-          @return_feeds << feeds
-        end
-      }
-      @return_feeds
+      @pipeline.each_with_object([]) do |feeds, returned|
+        next if feeds.nil?
+
+        feeds.items.each { |item| sanitize(item) }
+        returned << feeds
+      end
     end
 
     private
-    def sanitize(feed)
-      begin
-        feed.description = Sanitize.clean(feed.description, @mode) unless feed.description.nil?
-      rescue
-        Automatic::Log.puts("warn", "Undefined field detected in feed.")
-      end
-      feed
+
+    def sanitize(item)
+      item.description = Sanitize.fragment(item.description, @mode) unless item.description.nil?
+    rescue StandardError => e
+      Automatic::Log.puts('warn', "Undefined field detected in feed: #{e.message}")
     end
   end
 end

data/plugins/filter/sort.rb

@@ -1,37 +1,30 @@
 # -*- coding: utf-8 -*-
-# Name::      Automatic::Plugin::Filter::Sort
-# Author::    774 <http://id774.net>
-# Created::   Mar 23, 2012
-# Updated::   Jan 23, 2013
-# Copyright:: Copyright (c) 2012-2013 Automatic Ruby Developers.
-# License::   Licensed under the GNU GENERAL PUBLIC LICENSE, Version 3.0.
+# Name::        Automatic::Plugin::Filter::Sort
+# Author:       id774 (More info: https://id774.net)
+# Source Code:: https://github.com/id774/automaticruby
+# License::     The GPL version 3, or LGPL version 3 (Dual License).
+# Contact::     idnanashi@gmail.com
+# Created::     Mar 23, 2012
+# Updated::     Aug 15, 2026
+# Copyright::   Copyright (c) 2012-2026 Automatic Ruby Developers.
 
 module Automatic::Plugin
   class FilterSort
-
-    def initialize(config, pipeline=[])
-      @config = config
-      @pipeline = pipeline
+    def initialize(config, pipeline = [])
+      @config    = config || {}
+      @pipeline  = pipeline
+      @ascending = @config['sort'].to_s == 'asc'
     end
 
+    # Sorts each feed's items by date. Items must carry one; a feed built from
+    # a source without dates fails here.
     def run
-      @return_feeds = []
-      @pipeline.each { |feeds|
-        return_feed_items = []
-        unless feeds.nil?
-          if @config['sort'] == "asc"
-            feeds.items.sort!{|a,b|
-              a.date <=> b.date
-            }
-          else
-            feeds.items.sort!{|a,b|
-              - (a.date <=> b.date)
-            }
-          end
-          @return_feeds << feeds
-        end
-      }
-      @return_feeds
+      @pipeline.each_with_object([]) do |feeds, returned|
+        next if feeds.nil?
+
+        feeds.items.sort! { |a, b| @ascending ? a.date <=> b.date : b.date <=> a.date }
+        returned << feeds
+      end
     end
   end
 end

data/plugins/filter/tumblr_resize.rb

@@ -1,40 +1,48 @@
 # -*- coding: utf-8 -*-
-# Name::      Automatic::Plugin::Filter::TumblrResize
-# Author::    774 <http://id774.net>
-# Created::   Feb 28, 2012
-# Updated::   Apr  5, 2013
-# Copyright:: Copyright (c) 2012-2013 Automatic Ruby Developers.
-# License::   Licensed under the GNU GENERAL PUBLIC LICENSE, Version 3.0.
+# Name::        Automatic::Plugin::Filter::TumblrResize
+# Author:       id774 (More info: https://id774.net)
+# Source Code:: https://github.com/id774/automaticruby
+# License::     The GPL version 3, or LGPL version 3 (Dual License).
+# Contact::     idnanashi@gmail.com
+# Created::     Feb 28, 2012
+# Updated::     Aug 15, 2026
+# Copyright::   Copyright (c) 2012-2026 Automatic Ruby Developers.
 
 module Automatic::Plugin
   class FilterTumblrResize
+    # Tumblr has served images under two URL schemes. The older one carries
+    # the size as a suffix on the file name -- tumblr_xxx_500.jpg -- and is
+    # what images uploaded before 2019 still use. The newer one carries it as
+    # a path segment -- /s540x810/ -- and is what everything since uses.
+    # Both are rewritten to the largest variant the scheme offers.
+    LEGACY_SIZE = /_(?:75sq|100|250|400|500)(?=\.[a-zA-Z0-9]+\z)/
+    LEGACY_LARGEST = '_1280'
 
-    def initialize(config, pipeline=[])
-      @config = config
+    PATH_SIZE = %r{/s\d+x\d+/}
+    PATH_LARGEST = '/s1280x1920/'
+
+    def initialize(config, pipeline = [])
+      @config   = config || {}
       @pipeline = pipeline
     end
 
+    # Assumes FilterImage or FilterImageSource has already put an image URL in
+    # the link.
     def run
-      @return_feeds = []
-      @pipeline.each {|feeds|
-        img_url = ""
+      @pipeline.each_with_object([]) do |feeds, returned|
         unless feeds.nil?
-          feeds.items.each {|feed|
-            feed.link = resize(feed.link) unless feed.link.nil?
-          }
+          feeds.items.each do |item|
+            item.link = resize(item.link) unless item.link.nil?
+          end
         end
-        @return_feeds << feeds
-      }
-      @return_feeds
+        returned << feeds
+      end
     end
 
     private
-    def resize(string)
-      string = string.gsub("_75sq\.", "_1280\.")
-      string = string.gsub("_100\.", "_1280\.")
-      string = string.gsub("_250\.", "_1280\.")
-      string = string.gsub("_400\.", "_1280\.")
-      string = string.gsub("_500\.", "_1280\.")
+
+    def resize(link)
+      link.sub(LEGACY_SIZE, LEGACY_LARGEST).sub(PATH_SIZE, PATH_LARGEST)
     end
   end
 end