trmnl_preview 0.15.0 → 0.17.0

data/lib/trmnlp/merged_plugin_locals.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module TRMNLP
+  # A plugin_merge plugin's data as TRMNL builds it: each referenced plugin's locals under "<keyname>_<id>".
+  # Locally each reference names another trmnlp project, listed under merged_plugins in .trmnlp.yml.
+  class MergedPluginLocals
+    SENSITIVE_KEYNAMES = %w[polling_headers headers polling_body oauth_token_headers oauth_token_params].freeze
+
+    def initialize(config:, paths:)
+      @config = config
+      @paths = paths
+    end
+
+    def call
+      # A project met again is a cycle and merges as empty.
+      root_dirs_being_merged = (Thread.current[:trmnlp_merged_plugin_dirs] ||= [])
+      return {} if root_dirs_being_merged.include?(paths.root_dir)
+
+      root_dirs_being_merged.push(paths.root_dir)
+      begin
+        merged_locals
+      ensure
+        root_dirs_being_merged.pop
+      end
+    end
+
+    private
+
+    attr_reader :config, :paths
+
+    def merged_locals
+      locals = config.project.merged_plugins.to_h { |reference, dir| [reference, plugin_locals(paths.expand(dir))] }
+      instance_selections.each { |keyname, selected| locals[keyname] = locals[selected] if locals.key?(selected) }
+      locals
+    end
+
+    def plugin_locals(dir)
+      context = Context.new(dir)
+      context.validate!
+      locals = { 'merge_variables' => context.user_data_assembler.call.except('trmnl') }
+      values = shareable_custom_fields_values(context.config.plugin)
+      values.empty? ? locals : locals.merge('custom_fields_values' => values)
+    end
+
+    def shareable_custom_fields_values(plugin)
+      secret = plugin.custom_field_definitions.select do |field|
+        field['field_type'] == 'password' || SENSITIVE_KEYNAMES.include?(field['keyname'])
+      end
+      plugin.custom_fields_values.except(*secret.map { it['keyname'] })
+    end
+
+    def instance_selections
+      fields = config.plugin.custom_field_definitions.select { it['field_type'] == 'plugin_instance_select' }
+      config.plugin.custom_fields_values.slice(*fields.map { it['keyname'] }).reject { |_, selected| selected.empty? }
+    end
+  end
+end

data/lib/trmnlp/outbound_request.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'cgi'
+require 'faraday'
+require 'ipaddr'
+require 'socket'
+require 'timeout'
+
+module TRMNLP
+  # One polling request as TRMNL makes it; answers [response, nil] or [nil, failure reason].
+  class OutboundRequest
+    TIMEOUT_SECONDS = 10
+    MAX_REDIRECTS = 5
+    REDIRECT_STATUSES = (301..308)
+    METHOD_PRESERVING_REDIRECTS = [307, 308].freeze
+    PRIVATE_ADDRESS_RANGES = [
+      '0.0.0.0/8', '10.0.0.0/8', '100.64.0.0/10', '127.0.0.0/8', '169.254.0.0/16',
+      '172.16.0.0/12', '192.0.0.0/24', '192.168.0.0/16', '198.18.0.0/15',
+      '::1/128', 'fc00::/7', 'fe80::/10'
+    ].map { IPAddr.new(it) }.freeze
+
+    # TRMNL refuses these hosts; a self-hosted server may not, so trmnlp only warns.
+    def self.private_address?(url)
+      host = URI.parse(url).hostname
+      addresses = begin
+        [IPAddr.new(host).to_s]
+      rescue IPAddr::InvalidAddressError
+        Socket.getaddrinfo(host, nil).map { it[3] }.uniq
+      end
+      addresses.any? { |ip| PRIVATE_ADDRESS_RANGES.any? { it.include?(IPAddr.new(ip)) } }
+    rescue URI::Error, SocketError, ArgumentError
+      false
+    end
+
+    def initialize(on_private_address: ->(_url) {})
+      @on_private_address = on_private_address
+    end
+
+    def call(verb, url, headers:, body:)
+      attempts = 0
+      begin
+        attempts += 1
+        response = Timeout.timeout(TIMEOUT_SECONDS * 2, Faraday::TimeoutError) do
+          follow_redirects(verb, encoded(url), headers, body)
+        end
+        reason = failure_reason(response)
+        reason ? [nil, reason] : [response, nil]
+      rescue Faraday::TimeoutError, Faraday::ConnectionFailed, Faraday::SSLError => e
+        timed_out = e.is_a?(Faraday::TimeoutError) || e.wrapped_exception.is_a?(Net::OpenTimeout)
+        retry if timed_out && attempts < 2
+        [nil, timed_out ? "no response within #{TIMEOUT_SECONDS}s" : "could not connect (#{e.message})"]
+      end
+    end
+
+    private
+
+    def follow_redirects(verb, url, headers, body)
+      hops = 0
+      loop do
+        @on_private_address.call(url) if self.class.private_address?(url)
+        response = perform(verb, url, headers, body)
+        location = response.headers['location']
+        return response unless REDIRECT_STATUSES.cover?(response.status) && location && hops < MAX_REDIRECTS
+
+        hops += 1
+        next_url = URI.join(url, location).to_s
+        unless METHOD_PRESERVING_REDIRECTS.include?(response.status)
+          verb = 'GET'
+          body = nil
+        end
+        headers = headers.reject { |name, _| name.to_s.casecmp?('authorization') } if host(url) != host(next_url)
+        url = next_url
+      end
+    end
+
+    # A GET sends the polling body as its query string, as TRMNL does.
+    def perform(verb, url, headers, body)
+      connection = Faraday.new(url:, headers:, request: { timeout: TIMEOUT_SECONDS, open_timeout: TIMEOUT_SECONDS })
+      return connection.post { |request| request.body = body } if verb == 'POST'
+      return connection.get if body.to_s.empty?
+
+      connection.get("#{url}#{url.include?('?') ? '&' : '?'}#{body}")
+    end
+
+    def failure_reason(response)
+      return 'the host replied 429 Too Many Requests' if response.status == 429
+
+      "the host replied #{response.status}" if response.status >= 500
+    end
+
+    def host(url) = URI.parse(url).host&.downcase
+
+    # The host stays as typed; only what follows it is percent-encoded.
+    def encoded(url)
+      scheme_and_host, rest = url.match(%r{\A([a-z][a-z0-9+.-]*://[^/?#]*)(.*)\z}im)&.captures
+      scheme_and_host ? scheme_and_host + rest.gsub(/[^\x00-\x7F]/) { CGI.escape(it) } : url
+    end
+  end
+end

data/lib/trmnlp/paths.rb

@@ -7,8 +7,9 @@ module TRMNLP
   class Paths
     attr_reader :root_dir
 
-    def initialize(root_dir)
-      @root_dir = Pathname.new(root_dir)
+    def initialize(root_dir, cache_dir: nil)
+      @root_dir = Pathname.new(root_dir).expand_path
+      @cache_dir = cache_dir && Pathname.new(cache_dir)
       @xdg = XDG.new
     end
 
@@ -27,8 +28,7 @@ module TRMNLP
 
     def app_config_dir = xdg.config_home.join('trmnlp')
 
-    def cache_dir = xdg.cache_home.join('trmnl')
-    def create_cache_dir = cache_dir.mkpath
+    def cache_dir = @cache_dir || xdg.cache_home.join('trmnl')
 
     def valid? = trmnlp_config.exist?
 
@@ -44,11 +44,16 @@ module TRMNLP
 
     def app_config = app_config_dir.join('config.yml')
 
-    def user_data = cache_dir.join('data.json')
+    # Cached files are keyed per project root so working on two plugins does not
+    # clobber a shared file.
+    def user_data = cache_dir.join('data', "#{project_key}.json")
 
-    # OAuth tokens are keyed per project root so working on two OAuth plugins
-    # does not clobber a shared token file.
-    def oauth_tokens = cache_dir.join('oauth', "#{Digest::SHA256.hexdigest(root_dir.to_s)[0, 16]}.json")
+    def oauth_tokens = cache_dir.join('oauth', "#{project_key}.json")
+
+    def transform_state = cache_dir.join('state', "#{project_key}.json")
+    def fetch_failed_marker = cache_dir.join('state', "#{project_key}.fetch_failed")
+
+    def transform_output = cache_dir.join('transform_output', "#{project_key}.json")
 
     def render_template = Pathname.new(__dir__).join('..', '..', 'web', 'views', 'render_html.erb')
 
@@ -79,5 +84,7 @@ module TRMNLP
     private
 
     attr_reader :xdg
+
+    def project_key = Digest::SHA256.hexdigest(root_dir.to_s)[0, 16]
   end
 end

data/lib/trmnlp/poller.rb

@@ -1,52 +1,83 @@
 # frozen_string_literal: true
 
 require 'active_support/core_ext/hash/conversions'
-require 'faraday'
+require 'csv'
 require 'json'
 
+require_relative 'outbound_request'
 require_relative 'reporter'
 
 module TRMNLP
   class Poller
-    def initialize(config:, paths:, oauth_session:, reporter: Reporter.new)
+    BYTE_ORDER_MARK = "\xEF\xBB\xBF".b
+
+    # trmnl_variables answers the trmnl namespace TRMNL renders polling urls, headers and bodies with.
+    # rubocop:disable-next Metrics/ParameterLists -- keyword collaborators Context wires once
+    def initialize(config:, paths:, oauth_session:, trmnl_variables: -> { {} }, reporter: Reporter.new,
+                   async_callback: nil, outbound_request: nil)
       @config = config
+      @given_outbound_request = outbound_request
       @paths = paths
       @oauth_session = oauth_session
+      @trmnl_variables = trmnl_variables
       @reporter = reporter
+      @async_callback = async_callback
     end
 
     def poll_data
+      return request_async_data if config.plugin.async_polling?
       return unless config.plugin.polling?
-      raise InvalidConfig, 'config must specify polling_url or polling_urls' if config.plugin.polling_urls.empty?
 
-      data = aggregate_responses
+      missing = config.plugin.missing_required_fields
+      return report_warning("Plugin is not configured — fill in: #{missing.join(', ')}") if missing.any?
+
+      @fetch_failed = false
+      # Like TRMNL: no url is nothing to fetch, and the transform runs on {}.
+      data = config.plugin.polling_urls.empty? ? {} : aggregate_responses
       write_user_data(data)
+      record_fetch_outcome
       data
     # NOTE: trmnlp is a dev tool — a flaky upstream API should surface a warning
     # and keep the preview server alive, not crash the user's session. We
     # deliberately swallow here and return {} so the renderer keeps rendering.
     rescue StandardError => e
-      reporter.info(reporter.yellow("warning: #{e.message}"))
+      report_warning(e.message)
+      record_fetch_outcome
       {}
     end
 
-    def put_webhook(payload)
-      write_user_data(wrap_array(JSON.parse(payload)))
-    # NOTE: Same rationale as #poll_data — a bad webhook payload shouldn't take
-    # down the dev server. Report a warning and keep serving.
-    rescue StandardError => e
-      reporter.info(reporter.yellow("webhook warning: #{e.message}"))
-    end
-
     private
 
-    attr_reader :config, :paths, :oauth_session, :reporter
+    attr_reader :config, :paths, :oauth_session, :trmnl_variables, :reporter, :async_callback
+
+    # Like TRMNL: the API answers 202 and posts the data to callback_url later; the last post renders meanwhile.
+    def request_async_data
+      unless async_callback&.server_url
+        return report_warning('async_polling needs `trmnlp serve` to receive the callback')
+      end
+      return report_warning('Waiting for the async callback; the last data posted renders') if async_callback.awaiting?
+      return if config.plugin.polling_urls.empty?
+
+      report_warning('Async callback not received within 15 minutes') if async_callback.expired?
+      response, url = send_async_request(async_callback.start)
+      return if response&.status == 202
+
+      async_callback.cancel
+      report_warning("Async polling failed: HTTP #{response.status} from #{without_query(url)}") if response
+    end
+
+    def send_async_request(callback_url)
+      variables = trmnl_variables.call.merge(oauth_session.liquid_variables)
+      url = config.plugin.polling_urls(extra_variables: variables.merge('callback_url' => callback_url)).first
+      headers = config.plugin.polling_headers(extra_variables: variables)
+      [fetch_one(url, headers, config.plugin.polling_body(extra_variables: variables)), url]
+    end
 
     def aggregate_responses
       fetched = fetch_all
       # Like the hosted service: a token rejected before its expiry gets one refresh and retry.
-      fetched = fetch_all if fetched.any? { |_url, response| response.status == 401 } && oauth_session.force_refresh!
-      responses = fetched.map { |url, response| parse_response(response, url) }
+      fetched = fetch_all if fetched.any? { |_url, response| response&.status == 401 } && oauth_session.force_refresh!
+      responses = fetched.map { |url, response| response ? parse_response(response, url) : {} }
       return responses.first if responses.size == 1
 
       responses.each_with_index.with_object({}) { |(r, i), h| h["IDX_#{i}"] = r }
@@ -55,62 +86,84 @@ module TRMNLP
     def fetch_all
       # Resolve once per attempt (it refreshes as a side effect), then share across
       # every URL, header, and body render.
-      oauth_variables = oauth_session.liquid_variables
-      urls = config.plugin.polling_urls(extra_variables: oauth_variables)
-      urls.map { |url| [url, fetch_one(url, oauth_variables)] }
+      variables = trmnl_variables.call.merge(oauth_session.liquid_variables)
+      headers = config.plugin.polling_headers(extra_variables: variables)
+      body = config.plugin.polling_body(extra_variables: variables)
+      config.plugin.polling_urls(extra_variables: variables).map { |url| [url, fetch_one(url, headers, body)] }
     end
 
-    def fetch_one(url, oauth_variables)
+    def fetch_one(url, headers, body)
       verb = config.plugin.polling_verb.upcase
-      response = perform_request(url, verb, oauth_variables)
-      reporter.info("#{verb} #{url} — received #{response.body.length} bytes (#{response.status} status)")
+      response, failure = outbound_request.call(verb, url, headers:, body:)
+      return report_warning("Unable to fetch data from url: #{without_query(url)} — #{failure}") if failure
+
+      size = response.body.length
+      reporter.info("#{verb} #{without_query(url)} — received #{size} bytes (#{response.status} status)")
       response
     end
 
-    def perform_request(url, verb, oauth_variables)
-      conn = Faraday.new(url:, headers: config.plugin.polling_headers(extra_variables: oauth_variables))
-      if verb == 'POST'
-        conn.post { |req| req.body = config.plugin.polling_body(extra_variables: oauth_variables) }
-      else
-        conn.get
-      end
+    def outbound_request
+      @given_outbound_request || OutboundRequest.new(on_private_address: lambda { |url|
+        report_warning("TRMNL refuses #{without_query(url)}: the url resolves to a private address")
+      })
     end
 
-    # Like the hosted service: an error status is reported, but its body still reaches the data.
+    # Like the hosted service: a client error is reported, but its body still reaches the data.
     def parse_response(response, url)
       success = (200..299).cover?(response.status)
-      reporter.info(reporter.yellow("warning: HTTP #{response.status} from #{url}")) unless success
-      parse_body(response.body, response.headers['content-type'])
+      report_warning("HTTP #{response.status} from #{url}") unless success
+      parse_body(without_byte_order_mark(response.body.to_s), response.headers['content-type'])
+    rescue JSON::ParserError, CSV::MalformedCSVError => e
+      report_warning("Malformed #{e.is_a?(CSV::MalformedCSVError) ? 'CSV' : 'JSON'} from url: #{url}")
+      {}
     end
 
+    # Unlisted and missing content types are read as JSON, as TRMNL does.
     def parse_body(body, content_type_header)
-      content_type = content_type_header&.split(';')&.first&.strip
-      case content_type
-      when 'application/json', %r{^application/.+\+json} then wrap_array(JSON.parse(body))
+      case content_type_header&.split(';')&.first&.strip
       when 'text/xml', 'application/xml', %r{^application/.+\+xml} then wrap_array(Hash.from_xml(body))
-      when 'text/html', 'text/plain' then sniff_json(body) || { 'data' => body }
-      else log_unknown_type(content_type_header)
+      when 'text/csv' then wrap_array(CSV.parse(body))
+      when 'text/plain', 'text/html', 'text/markdown', 'text/x-markdown' then parse_textual_body(body)
+      else wrap_array(JSON.parse(body))
       end
     end
 
-    def log_unknown_type(header)
-      reporter.info("unknown content type received: #{header}")
-      {}
+    # Some endpoints serve JSON under a textual content type; anything else passes through under `data`.
+    def parse_textual_body(body)
+      parsed = JSON.parse(body)
+      parsed.is_a?(Hash) || parsed.is_a?(Array) ? wrap_array(parsed) : { 'data' => body }
+    rescue JSON::ParserError
+      { 'data' => body }
     end
 
-    def wrap_array(json) = json.is_a?(Array) ? { data: json } : json
+    def without_byte_order_mark(body)
+      return body unless body.byteslice(0, BYTE_ORDER_MARK.bytesize)&.b == BYTE_ORDER_MARK
 
-    def sniff_json(body)
-      trimmed = body.to_s.strip
-      return nil unless trimmed.start_with?('{', '[')
+      body.byteslice(BYTE_ORDER_MARK.bytesize..)
+    end
 
-      wrap_array(JSON.parse(trimmed))
-    rescue JSON::ParserError
+    # A polling url often carries its api key in the query string.
+    def without_query(url) = url.split('?').first
+
+    def wrap_array(json) = json.is_a?(Array) ? { data: json } : json
+
+    def report_warning(message)
+      @fetch_failed = true
+      reporter.info(reporter.yellow("warning: #{message}"))
       nil
     end
 
+    # The transform runs later, from the cached data, so whether this poll failed is kept beside it.
+    def record_fetch_outcome
+      marker = paths.fetch_failed_marker
+      return marker.delete if !@fetch_failed && marker.exist?
+
+      marker.dirname.mkpath
+      marker.write('') if @fetch_failed
+    end
+
     def write_user_data(data)
-      paths.create_cache_dir
+      paths.user_data.dirname.mkpath
       paths.user_data.write(JSON.generate(data))
     end
   end

data/lib/trmnlp/qr_code_intrinsic_size.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'trmnl/liquid'
+
+module TRMNLP
+  # Mirrors core's config/initializers/trmnl_liquid_qr_code_intrinsic_size.rb: a view box alone
+  # gives the code no size of its own, so it renders at zero width in a shrink-to-fit container.
+  module QrCodeIntrinsicSize
+    def qr_code(data, size = 11, level = '', view = 'responsive')
+      svg = super
+      root_element = svg[/<svg[^>]*>/].to_s
+      return svg if root_element.include?('width=')
+
+      side_length = root_element[/viewBox="0 0 (\d+)/, 1]
+      return svg unless side_length
+
+      svg.sub('<svg ', %(<svg width="#{side_length}" height="#{side_length}" style="max-width:100%;height:auto" ))
+    end
+  end
+end
+
+TRMNL::Liquid::Filters.prepend(TRMNLP::QrCodeIntrinsicSize)

data/lib/trmnlp/rails_helpers.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'i18n'
+require 'active_support'
+require 'active_support/number_helper'
+require 'active_support/core_ext/string/inflections'
+
+module TRMNL
+  module Liquid
+    # The ActionView helpers TRMNL::Liquid.load(:rails) gives the filters, without Rails.
+    module RailsHelpers
+      HTML_ESCAPED_OPTIONS = %i[unit separator delimiter].freeze
+
+      module_function
+
+      def number_to_currency(number, **options)
+        number && ActiveSupport::NumberHelper.number_to_currency(number, html_escape_options(options))
+      end
+
+      def number_with_delimiter(number, **options)
+        number && ActiveSupport::NumberHelper.number_to_delimited(number, html_escape_options(options))
+      end
+
+      def pluralize(count, singular, plural: nil, locale: ::I18n.locale)
+        word = count == 1 || count.to_s.match?(/^1(\.0+)?$/) ? singular : plural || singular.pluralize(locale)
+        "#{count || 0} #{word}"
+      end
+
+      def html_escape_options(options)
+        options.to_h { |key, value| [key, HTML_ESCAPED_OPTIONS.include?(key) && value ? ERB::Util.html_escape(value) : value] }
+      end
+    end
+  end
+end
+
+locale_files = Dir[File.expand_path('../../db/data/locales/*.yml', __dir__)]
+I18n.load_path += locale_files
+I18n.available_locales = locale_files.map { |path| File.basename(path, '.yml') }
+I18n.backend.class.include I18n::Backend::Fallbacks
+I18n.fallbacks = I18n::Locale::Fallbacks.new(:en)

data/lib/trmnlp/renderer.rb

@@ -1,12 +1,18 @@
 # frozen_string_literal: true
 
 require 'erb'
+require 'json'
+require 'yaml'
 require 'trmnl/liquid'
 
 require_relative 'screen'
 
 module TRMNLP
   class Renderer
+    # TRMNL refuses to render merge variables past this size.
+    MAX_MERGE_VARIABLES_KB = 100
+    AND_X_MORE = YAML.load_file(File.expand_path('../../db/data/and_x_more.yml', __dir__)).freeze
+
     def initialize(config:, paths:, user_data_assembler:)
       @config = config
       @paths = paths
@@ -23,10 +29,27 @@ module TRMNLP
 
     def framework = config.plugin.framework_version
 
-    def screen_classes(classes = 'screen')
-      classes ||= 'screen' # an explicit nil (omitted screen_classes param) still needs a base
-      classes += ' screen--no-bleed' if config.plugin.no_screen_padding == 'yes'
-      classes
+    # The data the last page was rendered from, for a test to read back.
+    attr_reader :last_data
+
+    def screen_classes(classes = 'screen', theme: nil)
+      classes = (classes || 'screen').split # an explicit nil (omitted screen_classes param) still needs a base
+      # The picker marks every render 1x, which sets the dither ratio; TRMNL's device render has no such class.
+      classes.delete('screen--1x')
+      classes << 'screen--no-bleed' if config.plugin.no_screen_padding == 'yes'
+      classes << 'screen--dark-mode' if config.plugin.dark_mode == 'yes'
+      # Framework 1.x inverts only on the bare dark-mode class.
+      classes << 'dark-mode' if classes.include?('screen--dark-mode')
+      # A new device renders in the TRMNL font unless its owner picks another.
+      classes << 'screen--fonts-trmnl' if classes.none? { it.start_with?('screen--fonts-') }
+      classes << "screen--theme-#{theme}" if FrameworkVersion::THEMES.key?(theme)
+      classes.uniq.join(' ')
+    end
+
+    # TRMNL's window.I18n.andXMore phrase for the user's locale, as [prefix, suffix].
+    def and_x_more
+      locale = config.project.user_data_overrides.dig('trmnl', 'user', 'locale').to_s
+      AND_X_MORE[locale] || AND_X_MORE[locale.split('-').first] || AND_X_MORE['en']
     end
 
     private
@@ -46,8 +69,15 @@ module TRMNLP
     end
 
     def parse_and_render(template_path, device:)
-      Liquid::Template.parse(full_markup(template_path), environment: liquid_environment)
-                      .render(user_data_assembler.call(device:))
+      data = @last_data = user_data_assembler.call(device:)
+      size = JSON.generate(data.except('trmnl')).bytesize
+      if size > MAX_MERGE_VARIABLES_KB * 1024
+        raise RenderError, "Large payload received (#{size} bytes), should be less than #{MAX_MERGE_VARIABLES_KB}kb."
+      end
+
+      Liquid::Template.parse(full_markup(template_path), environment: liquid_environment).render(data)
+    rescue RenderError
+      raise
     rescue StandardError => e
       raise RenderError, e.message
     end
@@ -65,10 +95,7 @@ module TRMNLP
 
     def liquid_environment
       @liquid_environment ||= TRMNL::Liquid.new do |env|
-        config.project.user_filters.each do |module_name, relative_path|
-          require paths.root_dir.join(relative_path)
-          env.register_filter(Object.const_get(module_name))
-        end
+        config.project.user_filter_modules.each { |filter_module| env.register_filter(filter_module) }
       end
     end
 
@@ -76,8 +103,10 @@ module TRMNLP
     class TemplateBinding
       def initialize(renderer, view, params)
         @view = view
-        @screen_classes = renderer.screen_classes(params[:screen_classes])
+        @screen_classes = renderer.screen_classes(params[:screen_classes], theme: params[:theme])
         @framework = renderer.framework
+        @theme_css_url = @framework.theme_css_url(params[:theme])
+        @and_x_more = renderer.and_x_more
         @mashup_classes = Screen.find(view)&.mashup_classes
       end
 

data/lib/trmnlp/screen_generator.rb

@@ -5,6 +5,17 @@ require_relative 'image_quantizer'
 
 module TRMNLP
   class ScreenGenerator
+    # TRMNL's own copies (Converter::Preprocessor); the CDN refuses a page with no Referer.
+    CHART_LIBRARIES = {
+      'https://code.highcharts.com/highcharts.js' => 'https://trmnl.com/js/highcharts/12.3.0/highcharts.js',
+      'https://code.highcharts.com/12.3.0/highcharts.js' => 'https://trmnl.com/js/highcharts/12.3.0/highcharts.js',
+      'https://cdn.jsdelivr.net/npm/chartkick@5.0.1/dist/chartkick.min.js' => 'https://trmnl.com/js/chartkick/5.0.1/chartkick.min.js',
+      'https://code.highcharts.com/highcharts-more.js' => 'https://trmnl.com/js/highcharts/12.3.0/highcharts-more.js',
+      'https://code.highcharts.com/12.3.0/highcharts-more.js' => 'https://trmnl.com/js/highcharts/12.3.0/highcharts-more.js',
+      'https://code.highcharts.com/modules/pattern-fill.js' => 'https://trmnl.com/js/highcharts/12.3.0/pattern-fill.js',
+      'https://code.highcharts.com/12.3.0/modules/pattern-fill.js' => 'https://trmnl.com/js/highcharts/12.3.0/pattern-fill.js'
+    }.freeze
+
     def initialize(html, opts = {})
       @input = html
       @screenshot = opts[:screenshot]
@@ -14,8 +25,9 @@ module TRMNLP
     end
 
     def process
-      output = @screenshot.call(html: @input, width:, height:)
-      ImageQuantizer.new(depth: color_depth).call(output.path)
+      html = CHART_LIBRARIES.reduce(@input) { |page, (from, to)| page.gsub(from, to) }
+      output = @screenshot.call(html:, width:, height:)
+      ImageQuantizer.new(depth: color_depth, dither: @input.include?('image-dither')).call(output.path)
       output
     end