trmnl_preview 0.14.2 → 0.16.0

data/lib/trmnlp/lint/source.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'trmnl/liquid'
+require 'yaml'
+
 module TRMNLP
   module Lint
     # The plugin data every lint check examines: markup per view, shared
@@ -23,6 +26,11 @@ module TRMNLP
       def custom_field_values = config.project.custom_fields
       def custom_field_definitions = config.plugin.custom_field_definitions
 
+      def local_only_filter_names
+        config.project.user_filter_modules.flat_map(&:public_instance_methods).map(&:to_s).uniq -
+          TRMNL::Liquid.new.filter_method_names
+      end
+
       def view_markup
         @view_markup ||= VIEWS.to_h { |view| [view, read(paths.template(view))] }
       end
@@ -44,10 +52,55 @@ module TRMNLP
         end
       end
 
+      # Keep the original whitespace here: stripped templates cannot provide
+      # accurate line/column numbers. All paths in reports are project-relative.
+      def markup_files
+        @markup_files ||= (VIEWS + ['shared']).to_h do |view|
+          ["src/#{view}.liquid", raw_read(paths.template(view))]
+        end
+      end
+
+      def locations(pattern, files: markup_files)
+        files.flat_map do |path, contents|
+          contents.to_enum(:scan, pattern).map do
+            offset = Regexp.last_match.begin(0)
+            prefix = contents[0...offset]
+            line = prefix.count("\n") + 1
+            { path:, line:, column: offset - (prefix.rindex("\n") || -1),
+              snippet: contents.lines[line - 1].to_s.chomp[0, 240] }
+          end
+        end.uniq
+      end
+
+      def yaml_location(file, *keys)
+        path = file == '.trmnlp.yml' ? paths.trmnlp_config : paths.plugin_config
+        contents = raw_read(path)
+        node = Psych.parse_stream(contents).children.first&.root
+        keys.each do |key|
+          node = if key.is_a?(Integer) && node.is_a?(Psych::Nodes::Sequence)
+                   node.children[key]
+                 else
+                   mapping_value(node, key)
+                 end
+        end
+        return [] unless node
+
+        [{ path: file, line: node.start_line + 1, column: node.start_column + 1,
+           snippet: contents.lines[node.start_line].to_s.chomp[0, 240] }]
+      end
+
       private
 
       attr_reader :config, :paths
 
+      def raw_read(path) = path.exist? ? path.read : ''
+
+      def mapping_value(node, key)
+        return unless node.is_a?(Psych::Nodes::Mapping)
+
+        node.children.each_slice(2).to_a.rfind { |name, _| name.value == key.to_s }&.last
+      end
+
       def read(path) = path.exist? ? path.read.strip : ''
     end
   end

data/lib/trmnlp/lint.rb

@@ -18,6 +18,7 @@ require_relative 'lint/checks/highcharts_elements_unique'
 require_relative 'lint/checks/image_links_reachable'
 require_relative 'lint/checks/custom_fields_used'
 require_relative 'lint/checks/form_fields_valid'
+require_relative 'lint/checks/no_custom_filters'
 
 module TRMNLP
   # Markup best-practice checks behind `trmnlp lint`.
@@ -39,7 +40,8 @@ module TRMNLP
       Checks::HighchartsElementsUnique,
       Checks::ImageLinksReachable,
       Checks::CustomFieldsUsed,
-      Checks::FormFieldsValid
+      Checks::FormFieldsValid,
+      Checks::NoCustomFilters
     ].freeze
   end
 end

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

@@ -8,7 +8,7 @@ module TRMNLP
     attr_reader :root_dir
 
     def initialize(root_dir)
-      @root_dir = Pathname.new(root_dir)
+      @root_dir = Pathname.new(root_dir).expand_path
       @xdg = XDG.new
     end
 
@@ -28,7 +28,6 @@ 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 valid? = trmnlp_config.exist?
 
@@ -44,11 +43,15 @@ 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 transform_output = cache_dir.join('transform_output', "#{project_key}.json")
 
     def render_template = Pathname.new(__dir__).join('..', '..', 'web', 'views', 'render_html.erb')
 
@@ -79,5 +82,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,22 +1,34 @@
 # 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)
       @config = config
       @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?
+
+      missing = config.plugin.missing_required_fields
+      return report_warning("Plugin is not configured — fill in: #{missing.join(', ')}") if missing.any?
       raise InvalidConfig, 'config must specify polling_url or polling_urls' if config.plugin.polling_urls.empty?
 
       data = aggregate_responses
@@ -26,27 +38,42 @@ module TRMNLP
     # 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)
       {}
     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?
+      raise InvalidConfig, 'config must specify polling_url' 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 +82,74 @@ 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
+      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'])
+      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)
+      reporter.info(reporter.yellow("warning: #{message}"))
       nil
     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/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,24 @@ 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
+    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 +66,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 = 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 +92,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 +100,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