trmnl_preview 0.3.1 → 0.4.0

data/lib/trmnlp/config/plugin.rb

@@ -0,0 +1,74 @@
+require 'yaml'
+
+module TRMNLP
+  class Config
+    class Plugin
+      def initialize(paths, trmnlp_config)
+        @paths = paths
+        @trmnlp_config = trmnlp_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
+        return [] if @config['polling_url'].nil? || @config['polling_url'].empty?
+
+        urls = @config['polling_url'].split("\n").map(&:strip)
+
+        urls.map { |url| with_custom_fields(url) }
+      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, :trmnlp_config
+
+      def with_custom_fields(value) = trmnlp_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

@@ -0,0 +1,47 @@
+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['custom_fields'] || {}
+
+      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) }
+        Liquid::Template.parse(value).render(custom_fields_with_env)
+      end
+
+      private
+
+      # for interpolating ENV vars into custom_fields
+      def with_env(value)
+        Liquid::Template.parse(value).render({ 'env' => ENV.to_h })
+      end
+    end
+  end
+end

data/lib/trmnlp/config.rb

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,211 @@
+require 'erb'
+require 'faraday'
+require 'filewatcher'
+require 'json'
+require 'liquid'
+
+require_relative 'config'
+require_relative 'custom_filters'
+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
+          json = wrap_array(JSON.parse(response.body))
+        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_template(view)
+      template_path = paths.template(view)
+      return "Missing template: #{template_path}" unless template_path.exist?
+
+      user_template = Liquid::Template.parse(template_path.read, environment: liquid_environment)
+      user_template.render(user_data)
+    rescue StandardError => e
+      e.message
+    end
+
+    def render_full_page(view)
+      template = paths.render_template.read
+      
+      ERB.new(template).result(TemplateBinding.new(self, view).get_binding do
+        render_template(view)
+      end)
+    end
+
+    def screen_classes
+      classes = 'screen'
+      classes << ' screen--no-bleed' if config.plugin.no_screen_padding == 'yes'
+      classes << ' dark-mode' if config.plugin.dark_mode == 'yes'
+      classes
+    end
+
+    private 
+
+    # bindings must match the `GET /render/{view}.html` route in app.rb
+    class TemplateBinding
+      def initialize(context, view)
+        @screen_classes = context.screen_classes
+        @view = view
+      end
+
+      def get_binding = binding
+    end
+
+    def wrap_array(json)
+      json.is_a?(Array) ? { data: json } : json
+    end
+
+    def base_trmnl_data
+      {
+        'trmnl' => {
+          'user' => {
+            'name' => 'name',
+            'first_name' => 'first_name',
+            'last_name' => 'last_name',
+            'locale' => 'en',
+            'time_zone' => 'Eastern Time (US & Canada)',
+            'time_zone_iana' => 'America/New_York',
+            'utc_offset' => -14400
+          },
+          '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 ||= Liquid::Environment.build do |env|
+        env.register_filter(CustomFilters)
+
+        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/custom_filters.rb

@@ -0,0 +1,14 @@
+require 'active_support'
+
+module TRMNLP
+  module CustomFilters
+    # TODO: sync up with core
+    def number_with_delimiter(*args)
+      ActiveSupport::NumberHelper.number_to_delimited(*args)
+    end
+
+    def number_to_currency(*args)
+      ActiveSupport::NumberHelper.number_to_currency(*args)
+    end
+  end
+end

data/lib/trmnlp/paths.rb

@@ -0,0 +1,50 @@
+require 'xdg'
+
+module TRMNLP
+  class Paths
+    attr_reader :root_dir
+    
+    def initialize(root_dir)
+      @root_dir = Pathname.new(root_dir)
+      @xdg = XDG.new
+    end
+
+    # --- 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 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

@@ -0,0 +1,137 @@
+require 'ferrum'
+require 'mini_magick'
+require 'puppeteer-ruby'
+require 'base64'
+
+module TRMNLP
+  class ScreenGenerator
+
+    def initialize(html, opts = {})
+      self.input = html
+      self.image = !!opts[:image]
+    end
+
+    attr_accessor :input, :output, :image, :processor, :img_path
+
+    def process
+      convert_to_image
+      image ? mono_image(output) : mono(output)
+      output.path
+      # IO.copy_stream(output, img_path)
+    end
+
+    private
+
+    # def img_path
+    #   "#{Dir.pwd}/public/images/generated/#{SecureRandom.hex(3)}.bmp"
+    # end
+
+    # Constructs the command and passes the input to the vendor/puppeteer.js
+    # script for processing. Returns a base64 encoded string
+    def convert_to_image
+      retry_count = 0
+      begin
+        # context = browser_instance.create_incognito_browser_context
+        page = firefox_browser.new_page
+        page.viewport = Puppeteer::Viewport.new(width: width, height: height)
+        # NOTE: Use below for chromium
+        # page.set_content(input, wait_until: ['networkidle0', 'domcontentloaded'])
+        # Note: Use below for firefox
+        page.set_content(input, timeout: 10000)
+        page.evaluate(<<~JAVASCRIPT)
+          () => {
+            document.getElementsByTagName('html')[0].style.overflow = "hidden";
+            document.getElementsByTagName('body')[0].style.overflow = "hidden";
+          }
+        JAVASCRIPT
+        self.output = Tempfile.new
+        page.screenshot(path: output.path, type: 'png')
+        firefox_browser.close
+      end
+    rescue Puppeteer::TimeoutError, Puppeteer::FrameManager::NavigationError => e
+      retry_count += 1
+      firefox_browser.close
+      if retry_count <= 1
+        @browser = nil
+        retry
+      else
+        puts "ERROR -> Converter::Html#convert_to_image_by_firefox -> #{e.message}"
+      end
+    end
+
+    # Refer this PR where the author reused the browser instance https://github.com/YusukeIwaki/puppeteer-ruby/pull/100/files
+    # This will increase the throughput of our image rendering process by 60-70%, saving about ~1.5 second per image generation.
+    # On local it takes < 1 second now to generate the subsequent image.
+    def firefox_browser
+      @browser ||= Puppeteer.launch(
+        product: 'firefox',
+        headless: true,
+        args: [
+          "--window-size=#{width},#{height}",
+          "--disable-web-security"
+          # "--hide-scrollbars" #works only on chrome, using page.evaluate for firefox
+        ]
+      )
+    end
+
+    def Ferrum.cached_browser
+      return nil unless $cached_browser
+
+      $cached_browser
+    end
+
+    def Ferrum.cached_browser=(value)
+      $cached_browser = value
+    end
+
+    # Overall at max wait for 2.5 seconds
+    def wait_for_stop_loading(page)
+      count = 0
+      while page.frames.first.state != :stopped_loading && count < 20
+        count += 1
+        sleep 0.1
+      end
+      sleep 0.5 # wait_until: DomContentLoaded event is not available in ferrum
+    end
+
+    def mono(img)
+      MiniMagick::Tool::Convert.new do |m|
+        m << img.path
+        m.monochrome # Use built-in smart monochrome dithering (but it's not working as expected)
+        m.depth(color_depth) # Should be set to 1 for 1-bit output
+        m.strip # Remove any additional metadata
+        m << ('bmp3:' << img.path)
+      end
+    end
+
+    def mono_image(img)
+      # Changelog:
+      # ImageMagick 6.XX used to convert the png to bitmap with dithering while maintaining the channel to 1
+      # The same seems to be broken with imagemagick 7.XX
+      # So in order to reduce the channel from 8 to 1, I just rerun the command, and it's working
+      # TODO for future, find a better way to generate image screens.
+      MiniMagick::Tool::Convert.new do |m|
+        m << img.path
+        m.dither << 'FloydSteinberg'
+        m.remap << 'pattern:gray50'
+        m.depth(color_depth) # Should be set to 1 for 1-bit output
+        m.strip # Remove any additional metadata
+        m << ('bmp3:' << img.path) # Converts to Bitmap.
+      end
+      MiniMagick::Tool::Convert.new do |m|
+        m << img.path
+        m.dither << 'FloydSteinberg'
+        m.remap << 'pattern:gray50'
+        m.depth(color_depth) # Should be set to 1 for 1-bit output
+        m.strip # Remove any additional metadata
+        m << ('bmp3:' << img.path) # Converts to Bitmap.
+      end
+    end
+
+    def width = 800
+
+    def height = 480
+
+    def color_depth = 1
+  end
+end

data/lib/trmnlp/version.rb

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

data/lib/trmnlp.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module TRMNLP; end
+
+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

data/trmnl_preview.gemspec

@@ -1,44 +1,62 @@
 # frozen_string_literal: true
 
-require_relative "lib/trmnl_preview/version"
+require_relative "lib/trmnlp/version"
 
 Gem::Specification.new do |spec|
   spec.name = "trmnl_preview"
-  spec.version = TRMNLPreview::VERSION
+  spec.version = TRMNLP::VERSION
   spec.authors = ["Rockwell Schrock"]
   spec.email = ["rockwell@schrock.me"]
 
   spec.summary = "Local web server to preview TRMNL plugins"
   spec.description = "Automatically rebuild and preview TRNML plugins in multiple views"
-  spec.homepage = "https://github.com/schrockwell/trmnl_preview"
+  spec.homepage = "https://github.com/usetrmnl/trmnlp"
   spec.license = "MIT"
   spec.required_ruby_version = ">= 3.0.0"
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
 
   spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://github.com/schrockwell/trmnl_preview"
+  spec.metadata["source_code_uri"] = "https://github.com/usetrmnl/trmnlp"
 
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (File.expand_path(f) == __FILE__) ||
-        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile Dockerfile])
-    end
+    [
+      'bin/**/*',
+      'lib/**/*',
+      'web/**/*',
+      'CHANGELOG.md',
+      'LICENSE.txt',
+      'README.md',
+      'trmnl_preview.gemspec'
+    ].flat_map { |glob| Dir[glob] }
   end
-  spec.bindir = "exe"
+  spec.bindir = "bin"
   spec.executables = ["trmnlp"]
   spec.require_paths = ["lib"]
 
-  # Uncomment to register a new dependency of your gem
+
+  # Web server
   spec.add_dependency "sinatra", "~> 4.1"
   spec.add_dependency "rackup", "~> 2.2"
   spec.add_dependency "puma", "~> 6.5"
+  spec.add_dependency "faye-websocket", "~> 0.11.3"
+
+  # HTML rendering
   spec.add_dependency "liquid", "~> 5.6"
-  spec.add_dependency "toml-rb", "~> 3.0"
+  spec.add_dependency "activesupport", "~> 8.0"
+  
+  # BMP rendering
+  spec.add_dependency "ferrum", "~> 0.16"
+  spec.add_dependency 'puppeteer-ruby', '~> 0.45.6'
+  spec.add_dependency 'mini_magick', '~> 4.12.0'
+
+  # Utilities
   spec.add_dependency "filewatcher", "~> 2.1"
-  spec.add_dependency "faye-websocket", "~> 0.11.3"
+  spec.add_dependency "faraday", "~> 2.1"
+  spec.add_dependency "faraday-multipart", "~> 1.1"
+  spec.add_dependency "xdg", "~> 9.1"
+  spec.add_dependency "rubyzip", "~> 2.3.0"
+  spec.add_dependency "thor", "~> 1.3"
 
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html