trmnl_preview 0.7.1 → 0.7.2

data/lib/trmnlp/config/plugin.rb

@@ -1,75 +0,0 @@
-require 'yaml'
-
-module TRMNLP
-  class Config
-    class Plugin
-      def initialize(paths, project_config)
-        @paths = paths
-        @project_config = project_config
-        reload!
-      end
-
-      def reload!
-        if paths.plugin_config.exist?
-          @config = YAML.load_file(paths.plugin_config)
-        else
-          @config = {}
-        end
-      end
-      
-      def strategy = @config['strategy']
-      def polling? = strategy == 'polling'
-      def webhook? = strategy == 'webhook'
-      def static? = strategy == 'static'
-
-      def polling_urls
-        # allow project-level config to override
-        urls = project_config.user_data_overrides.dig('trmnl', 'plugin_settings', 'polling_url') || @config['polling_url']
-
-        return [] if urls.nil?
-
-        with_custom_fields(urls).strip.split("\n")
-      end
-
-      def polling_url_text = polling_urls.join("\r\n") # for {{ trmnl }}
-
-      def polling_verb = @config['polling_verb'] || 'GET'
-
-      def polling_headers
-        string_to_hash(@config['polling_headers'] || '').transform_values { |v| with_custom_fields(v) }
-      end
-
-      def polling_headers_encoded = polling_headers.map { |k, v| "#{k}=#{v}" }.join('&') # for {{ trmnl }}
-
-      def polling_body = with_custom_fields(@config['polling_body'] || '')
-      
-      def dark_mode = @config['dark_mode'] || 'no'
-
-      def no_screen_padding = @config['no_screen_padding'] || 'no'
-
-      def id = @config['id']
-
-      def static_data
-        JSON.parse(@config['static_data'] || '{}')
-      rescue JSON::ParserError
-        raise Error, 'invalid JSON in static_data'
-      end
-
-      private
-
-      attr_reader :paths, :project_config
-
-      def with_custom_fields(value) = project_config.with_custom_fields(value)
-
-      # copied from TRMNL core
-      def string_to_hash(str, delimiter: '=')
-        str.split('&').map do |k_v|
-          key, value = k_v.split(delimiter)
-          next if value.nil?
-
-          { key => CGI.unescape_uri_component(value) }
-        end.compact.reduce({}, :merge)
-      end
-    end
-  end
-end

data/lib/trmnlp/config/project.rb

@@ -1,54 +0,0 @@
-require 'trmnl/liquid'
-require 'yaml'
-
-module TRMNLP
-  class Config
-    class Project
-      attr_reader :paths
-
-      def initialize(paths)
-        @paths = paths
-        reload!
-      end
-
-      def reload!
-        if paths.trmnlp_config.exist?
-          @config = YAML.load_file(paths.trmnlp_config)
-        else
-          @config = {}
-        end
-      end
-
-      def user_filters = @config['custom_filters'] || []
-
-      def live_render? = !watch_paths.empty?
-
-      def watch_paths
-        (@config['watch'] || []).map { |watch_path| paths.expand(watch_path) }.uniq
-      end
-
-      def custom_fields = @config.fetch('custom_fields', {}).transform_values(&:to_s)
-
-      def user_data_overrides = @config['variables'] || {}
-
-      # for interpolating custom_fields into polling_* options
-      def with_custom_fields(value)
-        custom_fields_with_env = custom_fields.transform_values { |v| with_env(v) }
-        parse_liquid(value).render(custom_fields_with_env)
-      end
-
-      def time_zone = @config['time_zone'] || 'UTC'
-
-      private
-
-      # for interpolating ENV vars into custom_fields
-      def with_env(value)
-        parse_liquid(value).render({ 'env' => ENV.to_h })
-      end
-
-      def parse_liquid(contents)
-        Liquid::Template.parse(contents, environment: TRMNL::Liquid.build_environment)
-      end
-    end
-  end
-end

data/lib/trmnlp/config.rb

@@ -1,15 +0,0 @@
-require_relative 'config/app'
-require_relative 'config/plugin'
-require_relative 'config/project'
-
-module TRMNLP
-  class Config
-    attr_reader :app, :project, :plugin
-
-    def initialize(path)
-      @app = App.new(path)
-      @project = Project.new(path)
-      @plugin = Plugin.new(path, @project)
-    end
-  end
-end

data/lib/trmnlp/context.rb

@@ -1,238 +0,0 @@
-require 'active_support/time'
-require 'active_support/core_ext/hash/conversions'
-require 'erb'
-require 'faraday'
-require 'filewatcher'
-require 'json'
-require 'trmnl/liquid'
-
-require_relative 'config'
-require_relative 'paths'
-
-module TRMNLP
-  class Context
-    attr_reader :config, :paths
-    
-    def initialize(root_dir)
-      @paths = Paths.new(root_dir)
-      @config = Config.new(paths)
-    end
-
-    def validate!
-      raise Error, "not a plugin directory (did not find #{paths.trmnlp_config})" unless paths.valid?
-    end
-
-    def start_filewatcher
-      @filewatcher_thread ||= Thread.new do
-        loop do
-          begin
-            Filewatcher.new(config.project.watch_paths).watch do |changes|
-              config.project.reload!
-              config.plugin.reload!
-              new_user_data = user_data
-
-              views = changes.map { |path, _change| File.basename(path, '.liquid') }
-              views.each do |view|
-                @view_change_callback.call(view, new_user_data) if @view_change_callback
-              end
-            end
-          rescue => e
-            puts "Error during live render: #{e}"
-          end
-        end
-      end
-    end
-
-    def on_view_change(&block)
-      @view_change_callback = block
-    end
-
-    def user_data
-      merged_data = base_trmnl_data
-
-      if config.plugin.static?
-        merged_data.merge!(config.plugin.static_data)
-      elsif paths.user_data.exist?
-        merged_data.merge!(JSON.parse(paths.user_data.read))
-      end
-
-      # Praise be to ActiveSupport
-      merged_data.deep_merge!(config.project.user_data_overrides)
-    end
-
-    def poll_data
-      return unless config.plugin.polling?
-
-      data = {}
-
-      if config.plugin.polling_urls.empty?
-        raise Error, "config must specify polling_url or polling_urls"
-      end
-
-      config.plugin.polling_urls.each.with_index do |url, i|
-        verb = config.plugin.polling_verb.upcase
-
-        print "#{verb} #{url}... "
-
-        conn = Faraday.new(url:, headers: config.plugin.polling_headers)
-
-        case verb
-        when 'GET'
-          response = conn.get
-        when 'POST'
-          response = conn.post do |req|
-            req.body = config.plugin.polling_body
-          end
-        end
-
-        puts "received #{response.body.length} bytes (#{response.status} status)"
-        if response.status == 200
-          content_type = response.headers['content-type'].split(';').first.strip if response.headers.include?('content-type')
-          case content_type
-          when 'application/json', /^application\/.+\+json/
-            json = wrap_array(JSON.parse(response.body))
-          when 'text/xml', 'application/xml', /^application\/.+\+xml/
-            json = wrap_array(Hash.from_xml(response.body))
-          else
-            puts "unknown content type received: #{response.headers['content-type']}"
-            json = {}
-          end
-        else
-          json = {}
-          puts response.body
-        end
-        
-        if config.plugin.polling_urls.count == 1
-          # For a single polling URL, we just return the JSON directly
-          data = json
-          break
-        else
-          # Multiple URLs are namespaced by index
-          data["IDX_#{i}"] = json
-        end
-      end
-
-      write_user_data(data)
-
-      data
-    rescue StandardError => e
-      puts "error: #{e.message}"
-      {}
-    end
-
-    def put_webhook(payload)
-      data = wrap_array(JSON.parse(payload))
-      write_user_data(data)
-    rescue
-      puts "webhook error: #{e.message}"
-    end
-
-    def render_liquid_template(view)
-      template_path = paths.template(view)
-      return "Missing template: #{template_path}" unless template_path.exist?
-
-      shared_template_path = paths.shared_template
-      if shared_template_path.exist?
-        full_markup = shared_template_path.read + template_path.read
-      else
-        full_markup = template_path.read
-      end
-
-      user_template = Liquid::Template.parse(full_markup, environment: liquid_environment)
-      user_template.render(user_data)
-    rescue StandardError => e
-      e.message
-    end
-
-    def render_full_page(view, params = {})
-      template = paths.render_template.read
-      
-      ERB.new(template).result(TemplateBinding.new(self, view, params).get_binding do
-        render_liquid_template(view)
-      end)
-    end
-
-    def screen_classes(classes = 'screen')
-      classes << ' screen--no-bleed' if config.plugin.no_screen_padding == 'yes'
-      classes
-    end
-
-    private 
-
-    # bindings must match the `GET /render/{view}.html` route in app.rb
-    class TemplateBinding
-      def initialize(context, view, params)
-        @view = view
-        @screen_classes = context.screen_classes(params[:screen_classes])
-
-        case view
-        when 'half_horizontal'
-          @mashup_classes = 'mashup mashup--1Tx1B'
-        when 'half_vertical'
-          @mashup_classes = 'mashup mashup--1Lx1R'
-        when 'quadrant'
-          @mashup_classes = 'mashup mashup--2x2'
-        end
-      end
-
-      def get_binding = binding
-    end
-
-    def wrap_array(json)
-      json.is_a?(Array) ? { data: json } : json
-    end
-
-    def base_trmnl_data
-      tz = ActiveSupport::TimeZone.find_tzinfo(config.project.time_zone)
-      time_zone_iana = tz.name
-      time_zone_name = ActiveSupport::TimeZone::MAPPING.invert[time_zone_iana] || time_zone_iana
-      utc_offset = tz.utc_offset
-
-      {
-        'trmnl' => {
-          'user' => {
-            'name' => 'name',
-            'first_name' => 'first_name',
-            'last_name' => 'last_name',
-            'locale' => 'en',
-            'time_zone' => time_zone_name,
-            'time_zone_iana' => time_zone_iana,
-            'utc_offset' => utc_offset,
-          },
-          'device' => {
-            'friendly_id' => 'ABC123',
-            'percent_charged' => 85.0,
-            'wifi_strength' => 90,
-            'height' => 480,
-            'width' => 800
-          },
-          'system' => {
-            'timestamp_utc' => Time.now.utc.to_i,
-          },
-          'plugin_settings' => {
-            'instance_name' => 'instance_name',
-            'strategy' => config.plugin.strategy,
-            'dark_mode' => config.plugin.dark_mode,
-            'polling_headers' => config.plugin.polling_headers_encoded,
-            'polling_url' => config.plugin.polling_url_text,
-            'custom_fields_values' => config.project.custom_fields
-          }
-        }
-      }
-    end
-
-    def liquid_environment
-      @liquid_environment ||= TRMNL::Liquid.build_environment 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
-      end
-    end
-
-    def write_user_data(data)
-      paths.create_cache_dir
-      paths.user_data.write(JSON.generate(data))
-    end
-  end
-end

data/lib/trmnlp/paths.rb

@@ -1,58 +0,0 @@
-require 'xdg'
-
-module TRMNLP
-  class Paths
-    attr_reader :root_dir
-    
-    def initialize(root_dir)
-      @root_dir = Pathname.new(root_dir)
-      @xdg = XDG.new
-    end
-    
-    # --- trmnlp library ---
-    
-    def gem_dir = Pathname.new(__dir__).join('..', '..').expand_path
-
-    def templates_dir = gem_dir.join('templates')
-
-    # --- directories ---
-    
-    def src_dir = root_dir.join('src')
-
-    def build_dir = root_dir.join('_build')
-    def create_build_dir = build_dir.mkpath
-
-    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?
-
-    # --- files ---
-
-    def trmnlp_config = root_dir.join('.trmnlp.yml')
-
-    def plugin_config = src_dir.join('settings.yml')
-      
-    def template(view) = src_dir.join("#{view}.liquid")
-
-    def shared_template = template('shared')
-      
-    def app_config = app_config_dir.join('config.yml')
-
-    def user_data = cache_dir.join('data.json')
-
-    def render_template = Pathname.new(__dir__).join('..', '..', 'web', 'views', 'render_html.erb')
-    
-    def src_files = src_dir.glob('*').select(&:file?)
-
-    # --- utilities ---
-
-    def expand(path) = Pathname.new(path).expand_path(root_dir)
-
-    private
-
-    attr_reader :xdg
-  end
-end

data/lib/trmnlp/screen_generator.rb

@@ -1,240 +0,0 @@
-require 'mini_magick'
-require 'selenium-webdriver'
-require 'base64'
-require 'thread'
-require 'tempfile'
-require 'fileutils'
-require 'uri'
-
-module TRMNLP
-  class ScreenGenerator
-    # Browser pool management for efficient resource usage
-    class BrowserPool
-      def initialize(max_size: 2)
-        @drivers = []
-        @available = Queue.new
-        @mutex = Mutex.new
-        @max_size = max_size
-        @shutdown = false
-
-        at_exit { shutdown }
-      end
-
-      def with_driver
-        driver = nil
-
-        begin
-          driver = checkout_driver
-          yield driver
-        ensure
-          checkin_driver(driver) if driver
-        end
-      end
-
-      def shutdown
-        @mutex.synchronize do
-          return if @shutdown
-          @shutdown = true
-
-          @drivers.each do |driver|
-            driver.quit rescue nil
-          end
-
-          @drivers.clear
-        end
-      end
-
-      private
-
-      def checkout_driver
-        driver = @available.pop(true) rescue nil
-
-        if driver.nil?
-          @mutex.synchronize do
-            if @drivers.size < @max_size
-              driver = create_driver
-              @drivers << driver
-            end
-          end
-        end
-
-        driver ||= @available.pop
-
-        begin
-          # Ping the driver
-          driver.title
-          driver
-        rescue
-          @mutex.synchronize do
-            @drivers.delete(driver)
-            driver = create_driver
-            @drivers << driver
-          end
-          driver
-        end
-      end
-
-      def checkin_driver(driver)
-        return if @shutdown
-        @available.push(driver)
-      end
-
-      def create_driver
-        options = Selenium::WebDriver::Firefox::Options.new
-        options.add_argument('--headless')
-        options.add_argument('--disable-web-security')
-
-        driver = Selenium::WebDriver.for(:firefox, options: options)
-        # Set a default window size that will be consistent
-        driver.manage.window.maximize
-        driver
-      end
-    end
-
-    @@browser_pool = BrowserPool.new
-
-    def initialize(html, opts = {})
-      self.input = html
-      self.image = !!opts[:image]
-
-      # Accept optional rendering parameters (width/height/color depth/dark mode)
-      @requested_width = opts[:width]
-      @requested_height = opts[:height]
-      @requested_color_depth = opts[:color_depth]
-    end
-
-    attr_accessor :input, :output, :image
-
-    def process
-      convert_to_image
-      image ? mono_image(output) : mono(output)
-      output
-    end
-
-    private
-
-    def convert_to_image
-      retry_count = 0
-
-      begin
-        @@browser_pool.with_driver do |driver|
-          # determine dimensions of toolbars, etc
-          borders = driver.execute_script(<<~JS)
-            return {
-              width: window.outerWidth - window.innerWidth,
-              height: window.outerHeight - window.innerHeight
-            }
-          JS
-
-          window_width = width + borders['width']
-          window_height = height + borders['height']
-          driver.manage.window.size = Selenium::WebDriver::Dimension.new(window_width, window_height)
-          
-          sleep(0.1)
-
-          prepare_page(driver)
-
-          self.output = Tempfile.new(['screenshot', '.png'])
-          driver.save_screenshot(output.path)
-          output.close
-        end
-      rescue Selenium::WebDriver::Error::TimeoutError,
-            Selenium::WebDriver::Error::WebDriverError => e
-        retry_count += 1
-        retry if retry_count <= 1
-        raise
-      end
-    end
-
-    def prepare_page(driver)
-      driver.navigate.to('about:blank')
-
-      driver.execute_script(<<~JS, input)
-        document.open();
-        document.write(arguments[0]);
-        document.close();
-      JS
-
-      Selenium::WebDriver::Wait.new(timeout: 5).until do
-        driver.execute_script('return document.readyState') == 'complete'
-      end
-
-      # Wait for fonts (prevents layout shifts)
-      driver.execute_script('return document.fonts && document.fonts.ready')
-
-      driver.execute_script(<<~JS)
-        document.documentElement.style.overflow = 'hidden';
-        document.body.style.overflow = 'hidden';
-      JS
-    end
-      
-    def convert_with_mini_magick(img, depth)
-      tmp = Tempfile.new(['mono', '.png'])
-      tmp.close
-
-      levels = 2**depth
-
-      MiniMagick::Tool::Convert.new do |m|
-        m << img.path
-        m.colorspace 'Gray'
-        m.dither 'FloydSteinberg'
-
-        yield(m, depth, levels)
-
-        m.depth depth
-        m.define "png:bit-depth=#{depth}"
-        m.strip
-        m << tmp.path
-      end
-
-      FileUtils.mv(tmp.path, img.path, force: true)
-    end
-
-    def mono(img)
-      depth = [[color_depth.to_i, 1].max, 8].min
-
-      convert_with_mini_magick(img, depth) do |m, d, levels|
-        m.posterize levels
-        m.colors levels
-        m.type 'Bilevel' if d == 1
-      end
-    end
-
-    def mono_image(img)
-      depth = [[color_depth.to_i, 1].max, 8].min
-
-      convert_with_mini_magick(img, depth) do |m, d, levels|
-        if d == 1
-          # For true 1-bit, use a halftone/remap and bilevel output
-          m.remap 'pattern:gray50'
-          m.posterize 2
-          m.colors 2
-          m.type 'Bilevel'
-        else
-          m.posterize levels
-          m.colors levels
-        end
-      end
-    end
-
-
-    def width
-      @requested_width || 800
-    end
-
-    def height
-      @requested_height || 480
-    end
-
-    def color_depth
-      return @requested_color_depth if @requested_color_depth
-
-      # Try to infer color depth from the rendered HTML's screen classes
-      if input && input.match(/screen--(\d+)bit/)
-        return $1.to_i
-      end
-
-      1
-    end
-  end
-end

data/lib/trmnlp/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module TRMNLP
-  VERSION = "0.7.1".freeze
-end

data/lib/trmnlp.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module TRMNLP; end
-require 'oj'
-Oj.mimic_JSON()
-require_relative "trmnlp/config"
-require_relative "trmnlp/context"
-require_relative "trmnlp/version"
-
-module TRMNLP
-  VIEWS = %w{full half_horizontal half_vertical quadrant}
-
-  class Error < StandardError; end
-end