trmnl-liquid 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f21152bc330bde8f49978e8a4680e4e1ef79e19c8dd63e657ada328567c85e1c
-  data.tar.gz: 58fc02a7aa0dbbb0e2fcf66d08019e59a76a63cb18f8bacf63e462df4d50f39b
+  metadata.gz: f138875593bd56d979eed237763c5e72a4dc5fdc3df60c35d6eeadffcb72bc87
+  data.tar.gz: 71bf4b24705129b781c295e3acf17fd70620df8773be3b15a1d4eaee7f734771
 SHA512:
-  metadata.gz: bca98684b5fa6857652231dfbf9ce04cdb49d42feeb0025c3f2862f7eb589d92d1bb42d0142728e12c103fbac42d519a65d87e1cdf4a6b03f6855a9128807745
-  data.tar.gz: 0eaad3ce40e20868d4560eacdd1810b1dc19ee8d9676907e87a588141e23949ab80c9bb7fd9daab07da7fea2b69e002311f6e9c83ec33e9880ddb3e6ea63ac06
+  metadata.gz: c0bff6334290e4eb2cbba125672faa0b9a63707bae29112e3d439f95401b259db3f3d0e8525f9c9fb61a77e1d38fe70b6bb4211929358f042f3ce59133a50a39
+  data.tar.gz: 909f77f15b1c3cc2027e295f97da11145978e0e80fcb3d46a5ca901b9fb17cc80cc6100eb729747ba21859122cefb10a52cdf23f4e4c75f9a425aae9d6a7e19d

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Rockwell Schrock
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,130 @@
+# TRMNL Liquid
+
+A set of Liquid filters and tags used to render custom plugins for [TRMNL](https://trmnl.com).
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add trmnl-liquid
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install trmnl-liquid
+```
+
+## Setup
+
+For [Rails](https://rubyonrails.org) folks, you'll need to load the Rails feature but you *only need to do this once* (typically via an initializer). Example:
+
+``` ruby
+TRMNL::Liquid.load :rails
+```
+
+The above will load the Rails i18n support and other functionality for you to use this gem within a Rails application. For any application that isn't using Rails, we have fallbacks that should be sufficient but we're working to close that gap further. For instance, here's how you can configure this gem within a [Hanami](https://hanamirb.org) application as a *provider*:
+
+
+``` ruby
+Hanami.app.register_provider :liquid, namespace: true do
+  prepare { require "trmnl/liquid" }
+
+  start do
+    default = TRMNL::Liquid.new { |environment| environment.error_mode = :strict }
+
+    renderer = lambda do |template, data, environment: default|
+      Liquid::Template.parse(template, environment:).render data
+    end
+
+    register :default, renderer
+  end
+end
+```
+
+If you ignore the provider logic and only focus on the body of the provider `start` life cyle, this can provide inspiration on how you can configure this gem further and use within your own application regardless of web stack.
+
+## Usage
+
+Functionality is achieved by parsing a template with the option `{ environment: TRMNL::Liquid.new }`. The environment concept was introduced in [v5.6.0](https://github.com/Shopify/liquid/releases/tag/v5.6.0) of the  `liquid` gem as a safer alternative to global registration of tags, filters, and so on. See [lib/trmnl/liquid/filters.rb](lib/trmnl/liquid/filters.rb) for the currently-supported filters.
+
+```ruby
+require "trmnl/liquid"
+
+markup = "Hello {{ count | number_with_delimiter }} people!"
+environment = TRMNL::Liquid.new # same arguments as Liquid::Environment.build
+template = Liquid::Template.parse(markup, environment: environment)
+rendered = template.render(count: 1337)
+# => "Hello 1,337 people!"
+```
+
+
+Additionally, the `{% template %}` tag defines reusable chunks of markup:
+
+```liquid
+{% template say_hello %}
+<h1>Why hello there, {{ name }}!</h1>
+{% endtemplate %}
+
+{% render "say_hello", name: "General Kenobi" %}
+```
+
+For more information, check out our help guides:
+
+- [Liquid 101](https://help.trmnl.com/en/articles/10671186-liquid-101)
+- [Advanced Liquid](https://help.trmnl.com/en/articles/10693981-advanced-liquid)
+- [Custom Plugin Filters](https://help.trmnl.com/en/articles/10347358-custom-plugin-filters)
+
+### Rails (optional)
+
+The following is optional and only works for Rails applications. Once again, you'll want to enable Rails support by adding the following as an initializer:
+
+``` ruby
+TRMNL::Liquid.load :rails
+```
+
+Then you can include internationalization and/or number and text formatting as described below.
+
+#### Internationalization
+
+Some filter functions (e.g. `number_to_currency`, `l_word`, and `l_date`) require translations provided by the [rails-i18n](https://rubygems.org/gems/rails-i18n) and [trmnl-i18n](https://rubygems.org/gems/trmnl-i18n) gems. These dependencies are optional, and if missing will fall back to default behavior. If you want to internationalize, also include these gems:
+
+```ruby
+# optional peer dependencies
+gem "rails-i18n", "~> 8.0"
+gem "trmnl-i18n", github: "usetrmnl/trmnl-i18n", branch: "main" # recommended for the latest changes
+```
+
+#### Number and Text Formatting
+
+This gem does not _require_ ActionView, but it will leverage ActionView helpers if they are available.
+
+```ruby
+# optional peer dependency
+gem "actionview", "~> 8.0"
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To publish, run the following:
+
+``` ruby
+# Step 0: You only need to do this once.
+bundle install gemsmith
+
+# Step 1: Edit the version number in trmnl-liquid.gemspec and update it to your desired version.
+
+# Step 2: Publish the new version.
+gemsmith --publish
+```
+
+## Contributing
+
+Enhancements, bugs, code reviews, and other requests are welcome via [GitHub](https://github.com/usetrmnl/trmnl-liquid).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/trmnl/liquid/fallback.rb

@@ -1,17 +1,21 @@
+# frozen_string_literal: true
+
 module TRMNL
   module Liquid
     # library-native formatting functions that don't rely on ActionView helpers
     module Fallback
-      extend self
+      module_function
 
-      def number_with_delimiter(number, delimiter, separator)
-        str = number.to_s
+      # :reek:TooManyStatements
+      # rubocop:todo Metrics/MethodLength
+      def number_with_delimiter number, delimiter, separator
+        value = number.to_s
 
         # return early if it's not a simple numeric-like string
-        return str unless str.match?(/\A-?\d+(\.\d+)?\z/)
+        return value unless value.match?(/\A-?\d+(\.\d+)?\z/)
 
-        integer, fractional = str.split('.')
-        negative = integer.start_with?('-')
+        integer, fractional = value.split "."
+        negative = integer.start_with? "-"
         integer = integer[1..] if negative
 
         integer_with_delimiters = integer.reverse.scan(/\d{1,3}/).join(delimiter).reverse
@@ -23,39 +27,40 @@ module TRMNL
           integer_with_delimiters
         end
       end
+      # rubocop:enable Metrics/MethodLength
 
-      def number_to_currency(number, unit, delimiter, separator, precision)
-        result = number_with_delimiter(number, delimiter, separator)
-        dollars, cents = result.split(separator)
+      # rubocop:disable Metrics/ParameterLists
+      def number_to_currency number, unit, delimiter, separator, precision
+        result = number_with_delimiter number, delimiter, separator
+        dollars, cents = result.split separator
 
         if precision <= 0
           "#{unit}#{dollars}"
         else
-          cents = cents.to_s[0..(precision - 1)].ljust(precision, '0')
+          cents = cents.to_s[0..(precision - 1)].ljust precision, "0"
           "#{unit}#{dollars}#{separator}#{cents}"
         end
       end
+      # rubocop:enable Metrics/ParameterLists
+
+      # :reek:TooManyStatements
+      def ordinalize number
+        return "#{number}th" if (11..13).cover? number % 100
 
-      def ordinalize(number)
-        suffix =
-          if (11..13).include?(number % 100)
-            'th'
-          else
-            case number % 10
-            when 1 then 'st'
-            when 2 then 'nd'
-            when 3 then 'rd'
-            else 'th'
-            end
-          end
+        suffix = case number % 10
+                   when 1 then "st"
+                   when 2 then "nd"
+                   when 3 then "rd"
+                   else "th"
+                 end
 
         "#{number}#{suffix}"
       end
 
-      def pluralize(count, singular, plural)
+      def pluralize count, singular, plural
         plural ||= "#{singular}s"
-        count == 1 ? "1 #{singular}"  : "#{count} #{plural}"
+        count == 1 ? "1 #{singular}" : "#{count} #{plural}"
       end
     end
   end
-end
+end

data/lib/trmnl/liquid/filters.rb

@@ -1,225 +1,198 @@
-require 'date'
-require 'json'
-require 'redcarpet'
-require 'tzinfo'
-require 'rqrcode'
-require 'securerandom'
-
-require_relative 'fallback'
-
-# optional
-%w[
-  i18n
-  action_view
-  active_support/core_ext/integer/inflections
-].each do |lib|
-  begin
-    require lib
-  rescue LoadError
-    nil
-  end
-end
+# frozen_string_literal: true
+
+require "json"
+require "redcarpet"
+require "rqrcode"
+require "securerandom"
+require "tzinfo"
+
+require_relative "fallback"
 
 module TRMNL
   module Liquid
+    # rubocop:todo Metrics/ModuleLength
     module Filters
-      def append_random(var)
-        "#{var}#{SecureRandom.hex(2)}"
-      end
+      def append_random(value) = "#{value}#{SecureRandom.hex 2}"
 
-      def days_ago(num, tz = 'Etc/UTC')
-        tzinfo = TZInfo::Timezone.get(tz)
-        tzinfo.now.to_date - num.to_i
+      def days_ago value, timezone = "Etc/UTC"
+        TZInfo::Timezone.get(timezone).now.to_date - value.to_i
       end
 
-      def group_by(collection, key)
-        collection.group_by { |obj| obj[key] }
-      end
+      def group_by(collection, key) = collection.group_by { it[key] }
 
-      def find_by(collection, key, value, fallback = nil)
+      # :reek:ControlParameter
+      # rubocop:todo Metrics/ParameterLists
+      def find_by collection, key, value, fallback = nil
         collection.find { |obj| obj[key] == value } || fallback
       end
+      # rubocop:enable Metrics/ParameterLists
 
-      def markdown_to_html(markdown)
-        markdown ||= ''
-        renderer = Redcarpet::Render::HTML.new(_render_options = {})
-        service = Redcarpet::Markdown.new(renderer, _extensions = {})
-        service.render(markdown)
+      def markdown_to_html markdown
+        markdown ||= ""
+        renderer = Redcarpet::Render::HTML.new _render_options = {}
+        service = Redcarpet::Markdown.new renderer, _extensions = {}
+        service.render markdown
       end
 
-      def number_with_delimiter(number, delimiter = ',', separator = '.')
-        if helpers.respond_to?(:number_with_delimiter)
-          helpers.number_with_delimiter(number, delimiter: delimiter, separator: separator)
+      def number_with_delimiter number, delimiter = ",", separator = "."
+        if RailsHelpers.respond_to? :number_with_delimiter
+          RailsHelpers.number_with_delimiter number, delimiter: delimiter, separator: separator
         else
-          Fallback.number_with_delimiter(number, delimiter, separator)
+          Fallback.number_with_delimiter number, delimiter, separator
         end
       end
 
-      def number_to_currency(number, unit_or_locale = '$', delimiter = ',', separator = '.', precision = 2)
-        if helpers.respond_to?(:number_to_currency)
-          cur_switcher = with_i18n(:unit) do |i18n|
+      # :reek:TooManyStatements
+      # rubocop:todo Metrics/ParameterLists
+      def number_to_currency number,
+                             unit_or_locale = "$",
+                             delimiter = ",",
+                             separator = ".",
+                             precision = 2
+        if RailsHelpers.respond_to? :number_to_currency
+          cur_switcher = with_i18n :unit do |i18n|
             i18n.available_locales.include?(unit_or_locale.to_sym) ? :locale : :unit
           end
-          opts = { delimiter:, separator:, precision: }.merge(cur_switcher => unit_or_locale)
-          helpers.number_to_currency(number, **opts)
+          opts = {delimiter:, separator:, precision:}.merge cur_switcher => unit_or_locale
+          RailsHelpers.number_to_currency(number, **opts)
         else
-          Fallback.number_to_currency(number, unit_or_locale, delimiter, separator, precision)
+          Fallback.number_to_currency number, unit_or_locale, delimiter, separator, precision
         end
       end
+      # rubocop:enable Metrics/ParameterLists
 
-      def l_word(word, locale)
-        with_i18n("custom_plugins.#{word}") do |i18n|
-          i18n.t("custom_plugins.#{word}", locale: locale)
-        end
+      def l_word word, locale
+        with_i18n("custom_plugins.#{word}") { |i18n| i18n.t "custom_plugins.#{word}", locale: }
       end
 
-      def l_date(date, format, locale = 'en')
-        with_i18n(date.to_s) do |i18n|
-          format = format.to_sym unless format.include?('%')
-          i18n.l(to_datetime(date), format: format, locale: locale)
+      # :reek:FeatureEnvy
+      def l_date value, format, locale = "en"
+        with_i18n value.to_s do |i18n|
+          format = format.to_sym unless format.include? "%"
+          i18n.l to_time(value), format:, locale:
         end
       end
 
-      def map_to_i(collection)
-        collection.map(&:to_i)
-      end
+      def map_to_i(collection) = collection.map(&:to_i)
 
-      def pluralize(singular, count, opts = {})
-        plural = opts['plural']
-        locale = opts['locale'] || with_i18n(nil) { |i18n| i18n.locale } || 'en'
+      # :reek:FeatureEnvy
+      # rubocop:todo Style/OptionHash
+      def pluralize singular, count, options = {}
+        plural = options["plural"]
+        locale = options["locale"] || with_i18n(nil, &:locale) || "en"
 
-        if helpers.respond_to?(:pluralize)
-          helpers.pluralize(count, singular, plural: plural, locale: locale) 
+        if RailsHelpers.respond_to? :pluralize
+          RailsHelpers.pluralize count, singular, plural: plural, locale: locale
         else
-          Fallback.pluralize(count, singular, plural)
+          Fallback.pluralize count, singular, plural
         end
       end
+      # rubocop:enable Style/OptionHash
 
-      def json(obj)
-        JSON.generate(obj)
-      end
+      def json(value) = JSON.generate value
 
-      def parse_json(obj)
-        JSON.parse(obj)
-      end
+      def parse_json(value) = JSON.parse value
 
       def sample(array) = array.sample
 
+      # :reek:TooManyStatements
       # source: https://github.com/jekyll/jekyll/blob/40ac06ed3e95325a07868dd2ac419e409af823b6/lib/jekyll/filters.rb#L209
-      def where_exp(input, variable, expression)
-        return input unless input.respond_to?(:select)
+      def where_exp input, variable, expression
+        return input unless input.respond_to? :select
 
-        input = input.values if input.is_a?(Hash)
+        input = input.values if input.is_a? Hash
+        condition = parse_condition expression
 
-        condition = parse_condition(expression)
         @context.stack do
           input.select do |object|
             @context[variable] = object
-            condition.evaluate(@context)
+            condition.evaluate @context
           end
         end || []
       end
 
-      def ordinalize(date_str, strftime_exp)
-        date = Date.parse(date_str) 
-        
-        ordinal_day = if date.day.respond_to?(:ordinalize)
-                        date.day.ordinalize
-                      else
-                        Fallback.ordinalize(date.day)
-                      end
-        
-        date.strftime(strftime_exp.gsub('<<ordinal_day>>', ordinal_day))
+      # :reek:FeatureEnvy
+      def ordinalize value, strftime_format
+        time = to_time value
+        day = time.day
+        ordinal_day = day.respond_to?(:ordinalize) ? day.ordinalize : Fallback.ordinalize(day)
+
+        time.strftime strftime_format.gsub("<<ordinal_day>>", ordinal_day)
       end
 
-      def qr_code(data, size = 11, level = '')
-        level.downcase!
-        level = 'h' unless %w[l m q h].include?(level)
+      # rubocop:todo Metrics/MethodLength
+      def qr_code data, size = 11, level = ""
+        level = "h" unless %w[l m q h].include? level.downcase
 
         qrcode = RQRCode::QRCode.new(data, level:)
         qrcode.as_svg(
-          color: '000',
-          fill: 'fff',
-          shape_rendering: 'crispEdges',
+          color: "000",
+          fill: "fff",
+          shape_rendering: "crispEdges",
           module_size: size,
           standalone: true,
           use_path: true,
           svg_attributes: {
-            class: 'qr-code'
+            class: "qr-code"
           }
         )
       end
+      # rubocop:enable Metrics/MethodLength
 
       private
 
-      def with_i18n(fallback, &block)
+      def with_i18n fallback
         if defined?(::I18n)
-          block.call(::I18n)
+          yield ::I18n
         else
           fallback
         end
       end
 
-      def to_datetime(obj)
-        case obj
-        when DateTime
-          obj
-        when Date
-          obj.to_datetime
-        when Time
-          DateTime.parse(obj.iso8601)
-        else
-          DateTime.parse(obj.to_s)
+      def to_time value
+        case value
+          when "now", "today" then Time.now
+          when Integer then Time.at(value)
+          else Time.parse value
         end
       end
 
-      def parse_condition(exp)
-        parser = ::Liquid::Parser.new(exp)
-        condition = parse_binary_comparison(parser)
+      def parse_condition expression
+        parser = ::Liquid::Parser.new expression
+        condition = parse_binary_comparison parser
 
-        parser.consume(:end_of_string)
+        parser.consume :end_of_string
         condition
       end
 
-      def parse_binary_comparison(parser)
-        condition = parse_comparison(parser)
+      # :reek:TooManyStatements
+      # :reek:DuplicateMethodCall
+      def parse_binary_comparison parser
+        condition = parse_comparison parser
         first_condition = condition
-        while (binary_operator = parser.id?('and') || parser.id?('or'))
-          child_condition = parse_comparison(parser)
-          condition.send(binary_operator, child_condition)
+
+        while (binary_operator = parser.id?("and") || parser.id?("or"))
+          child_condition = parse_comparison parser
+          condition.public_send binary_operator, child_condition
           condition = child_condition
         end
+
         first_condition
       end
 
-      def parse_comparison(parser)
-        left_operand = ::Liquid::Expression.parse(parser.expression)
-        operator     = parser.consume?(:comparison)
+      # :reek:DuplicateMethodCall
+      def parse_comparison parser
+        left_operand = ::Liquid::Expression.parse parser.expression
+        operator     = parser.consume? :comparison
 
         # No comparison-operator detected. Initialize a Liquid::Condition using only left operand
-        return ::Liquid::Condition.new(left_operand) unless operator
+        return ::Liquid::Condition.new left_operand unless operator
 
         # Parse what remained after extracting the left operand and the `:comparison` operator
         # and initialize a Liquid::Condition object using the operands and the comparison-operator
-        ::Liquid::Condition.new(left_operand, operator, ::Liquid::Expression.parse(parser.expression))
-      end
-
-      class Helpers
-        %w[
-          ::ActionView::Helpers::TextHelper
-          ::ActionView::Helpers::NumberHelper
-        ].each do |name|
-          begin
-            include Object.const_get(name)
-          rescue NameError
-            next
-          end
-        end
-      end
-
-      def helpers
-        @helpers ||= Helpers.new
+        ::Liquid::Condition.new left_operand, operator, ::Liquid::Expression.parse(parser.expression)
       end
     end
+    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/trmnl/liquid/memory_system.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module TRMNL
+  module Liquid
+    # An in-memory file system for storing custom templates defined with {% template [name] %} tags.
+    class MemorySystem < ::Liquid::BlankFileSystem
+      def initialize
+        super
+        @templates = {}
+      end
+
+      def register name, body
+        templates[name] = body
+      end
+
+      def read_template_file name
+        templates[name] || fail(::Liquid::FileSystemError, "Template not found: #{name}.")
+      end
+
+      private
+
+      attr_reader :templates
+    end
+  end
+end

data/lib/trmnl/liquid/rails_helpers.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "action_view"
+
+module TRMNL
+  module Liquid
+    # Defines Rails helpers for use in filters.
+    module RailsHelpers
+      extend ActionView::Helpers::TextHelper
+      extend ActionView::Helpers::NumberHelper
+    end
+  end
+end

data/lib/trmnl/liquid/template_tag.rb

@@ -1,33 +1,44 @@
+# frozen_string_literal: true
+
 module TRMNL
   module Liquid
-    # The {% template [name] %} tag block is used in conjunction with InlineTemplatesFileSystem to allow users to define
-    # custom templates within the context of the current Liquid template. Generally speaking, they will define their own
-    # templates in the "shared" markup content, which is prepended to the individual screen templates before rendering.
+    # The {% template [name] %} tag block is used in conjunction with InlineTemplatesFileSystem to
+    # allow users to define custom templates within the context of the current Liquid template.
+    # Generally speaking, they will define their own templates in the "shared" markup content,
+    # which is prepended to the individual screen templates before rendering.
     class TemplateTag < ::Liquid::Block
-      NAME_REGEX = %r{\A[a-zA-Z0-9_/]+\z}
+      NAME_PATTERN = %r(\A[a-zA-Z0-9_/]+\z)
 
-      def initialize(tag_name, markup, options)
+      def initialize tag_name, markup, options
         super
+
         @name = markup.strip
+        @body = +""
       end
 
-      def parse(tokens)
-        @body = ""
+      def parse tokens
+        body.clear
+
         while (token = tokens.shift)
           break if token.strip == "{% endtemplate %}"
 
-          @body << token
+          body << token
         end
       end
 
-      def render(context)
-        unless @name =~ NAME_REGEX
-          return "Liquid error: invalid template name #{@name.inspect} - template names must contain only letters, numbers, underscores, and slashes"
+      def render context
+        unless NAME_PATTERN.match? name
+          return "Liquid error: invalid template name #{name.inspect} - template names " \
+                 "must contain only letters, numbers, underscores, and slashes"
         end
 
-        context.registers[:file_system].register(@name, @body.strip)
-        ''
+        context.registers[:file_system].register name, body.strip
+        ""
       end
+
+      private
+
+      attr_reader :name, :body
     end
   end
-end
+end

data/lib/trmnl/liquid.rb

@@ -1,36 +1,39 @@
 # frozen_string_literal: true
 
-require 'liquid'
+require "liquid"
+require "trmnl/liquid/filters"
+require "trmnl/liquid/memory_system"
+require "trmnl/liquid/template_tag"
 
-require 'trmnl/liquid/filters'
-require 'trmnl/liquid/file_system'
-require 'trmnl/liquid/template_tag'
-require 'trmnl/liquid/version'
+module TRMNL
+  # Main namespace.
+  module Liquid
+    def self.build_environment(...)
+      warn "`#{self.class}##{__method__}` is deprecated, use `new` instead.", category: :deprecated
+      new(...)
+    end
 
-# optional
-begin
-  require 'trmnl/i18n'
-rescue LoadError
-  nil
-end
+    # :reek:TooManyStatements
+    def self.load key
+      case key
+        when :rails
+          require "trmnl/liquid/rails_helpers"
 
-if defined?(::TRMNL::I18n)
-  ::TRMNL::I18n.load_locales
-end
+          require "trmnl/i18n"
 
-if Gem.loaded_specs['rails-i18n']
-  ::I18n.load_path += Pathname.new(Gem.loaded_specs['rails-i18n'].full_gem_path).join('rails', 'locale').glob('*.yml')
-end
+          TRMNL::I18n.load_locales
+          path = Pathname Gem.loaded_specs["rails-i18n"].full_gem_path
+          ::I18n.load_path += path.join("rails/locale").glob("*.yml")
+        else fail KeyError, "Unable to load extension due to invalid key: #{key.inspect}."
+      end
+    end
 
-module TRMNL
-  module Liquid
-    def self.build_environment(*args)
-      ::Liquid::Environment.build(*args) do |env|
-        env.register_filter(TRMNL::Liquid::Filters)
-        env.register_tag('template', TRMNL::Liquid::TemplateTag)
-        env.file_system = TRMNL::Liquid::FileSystem.new
-        yield(env) if block_given?
+    def self.new(file_system: TRMNL::Liquid::MemorySystem.new, **)
+      ::Liquid::Environment.build(file_system:, **) do |environment|
+        environment.register_filter TRMNL::Liquid::Filters
+        environment.register_tag "template", TRMNL::Liquid::TemplateTag
+        yield environment if block_given?
       end
     end
   end
-end
+end

data/trmnl-liquid.gemspec

@@ -1,17 +1,13 @@
 # frozen_string_literal: true
 
-require_relative "lib/trmnl/liquid/version"
-
 Gem::Specification.new do |spec|
   spec.name = "trmnl-liquid"
-  spec.version = TRMNL::Liquid::VERSION
+  spec.version = "0.5.0"
   spec.authors = ["TRMNL"]
-  spec.email = ["engineering@usetrmnl.com"]
+  spec.email = ["engineering@trmnl.com"]
   spec.homepage = "https://github.com/usetrmnl/trmnl-liquid"
-
   spec.summary = "Liquid templating engine for TRMNL plugins"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.2.0"
 
   spec.metadata = {
     "bug_tracker_uri" => "https://github.com/usetrmnl/trmnl-liquid/issues",
@@ -22,15 +18,16 @@ Gem::Specification.new do |spec|
     "source_code_uri" => "https://github.com/usetrmnl/trmnl-liquid"
   }
 
-  # 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["*.gemspec", "lib/**/*"]
-  spec.require_paths = ["lib"]
+  spec.signing_key = Gem.default_key_path
+  spec.cert_chain = [Gem.default_cert_path]
 
-  spec.add_dependency "base64"
-  spec.add_dependency "liquid", "~> 5.6"
+  spec.required_ruby_version = ">= 4.0"
+
+  spec.add_dependency "liquid", "~> 5.11"
   spec.add_dependency "redcarpet", "~> 3.6"
-  spec.add_dependency "rqrcode", "~> 3.0"
-  spec.add_dependency "securerandom", ">= 0.3"
-  spec.add_dependency "tzinfo"
+  spec.add_dependency "rqrcode", "~> 3.2"
+  spec.add_dependency "tzinfo", "~> 2.0"
+
+  spec.extra_rdoc_files = Dir["README*", "LICENSE*"]
+  spec.files = Dir["*.gemspec", "lib/**/*"]
 end

metadata

@@ -1,42 +1,54 @@
 --- !ruby/object:Gem::Specification
 name: trmnl-liquid
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - TRMNL
 bindir: bin
-cert_chain: []
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIENjCCAp6gAwIBAgIBAjANBgkqhkiG9w0BAQsFADBBMQ8wDQYDVQQDDAZicm9v
+  a2UxGjAYBgoJkiaJk/IsZAEZFgphbGNoZW1pc3RzMRIwEAYKCZImiZPyLGQBGRYC
+  aW8wHhcNMjUwMzIyMTQ1NDE3WhcNMjYwMzIyMTQ1NDE3WjBBMQ8wDQYDVQQDDAZi
+  cm9va2UxGjAYBgoJkiaJk/IsZAEZFgphbGNoZW1pc3RzMRIwEAYKCZImiZPyLGQB
+  GRYCaW8wggGiMA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQCro8tj5/E1Hg88
+  f4qfiwPVd2zJQHvdYt4GHVvuHRRgx4HGhJuNp+4BId08RBn7V6V1MW6MY3kezRBs
+  M+7QOQ4b1xNLTvY7FYQB1wGK5a4x7TTokDrPYQxDB2jmsdDYCzVbIMrAvUfcecRi
+  khyGZCdByiiCl4fKv77P12tTT+NfsvXkLt/AYCGwjOUyGKTQ01Z6eC09T27GayPH
+  QQvIkakyFgcJtzSyGzs8bzK5q9u7wQ12MNTjJoXzW69lqp0oNvDylu81EiSUb5S6
+  QzzPxZBiRB1sgtbt1gUbVI262ZDq1gR+HxPFmp+Cgt7ZLIJZAtesQvtcMzseXpfn
+  hpmm0Sw22KGhRAy/mqHBRhDl5HqS1SJp2Ko3lcnpXeFResp0HNlt8NSu13vhC08j
+  GUHU9MyIXbFOsnp3K3ADrAVjPWop8EZkmUR3MV/CUm00w2cZHCSGiXl1KMpiVKvk
+  Ywr1gd2ZME4QLSo+EXUtLxDUa/W3xnBS8dBOuMMz02FPWYr3PN8CAwEAAaM5MDcw
+  CQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0OBBYEFAFgmv0tYMZnItuPycSM
+  F5wykJEVMA0GCSqGSIb3DQEBCwUAA4IBgQBlzRfyAYx/fCFjizS0Npxw4+4T3aYL
+  hbXoDqQRWjxuhFZcXUymhz3r8/Ltyri9lSof8grzB+8/+mrMVms7Gwt5qolk6zdn
+  FkySGy/jmpN12ldOHFbBEnyVBZNBvOBVb8zkkw8PhiHdBdXOUm4Jy39yJvBLfjcC
+  iM1aeWPmgPy1GbvZU+leRGZLt6dRIR9oCDXcWLRjha8xLMoz6Yn9fJBYexBA3iEz
+  h5S7pn4AX/JhVRiSyl8pAy4jEKydpyQrliH3gHkpNmUS/XDczP+9xX1bAB4BvqL2
+  NCxMcQ+hiJNqCKpPgHxaOOHZfIxV33logIuPEQ8NryHAwZ9ZWnwtYDE8kQGGKskI
+  Kkm6QT474hZl7MpwiJjWgW313CR7jUEekQahX1QxCxHPI7LSrKpno0plH3uWIOQp
+  KUlkb9uyACBgyRO52ZHiDVI8YvtU5O/j9pSes9/3XgvBeC1onx4qWp+uRX7eVsYS
+  GiijocTc3enZVrXERetaXj8/9XWs3fB3HWY=
+  -----END CERTIFICATE-----
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: base64
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: liquid
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.6'
+        version: '5.11'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.6'
+        version: '5.11'
 - !ruby/object:Gem::Dependency
   name: redcarpet
   requirement: !ruby/object:Gem::Requirement
@@ -57,54 +69,44 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: securerandom
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0.3'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: tzinfo
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
 email:
-- engineering@usetrmnl.com
+- engineering@trmnl.com
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
 files:
+- LICENSE.txt
+- README.md
 - lib/trmnl/liquid.rb
 - lib/trmnl/liquid/fallback.rb
-- lib/trmnl/liquid/file_system.rb
 - lib/trmnl/liquid/filters.rb
+- lib/trmnl/liquid/memory_system.rb
+- lib/trmnl/liquid/rails_helpers.rb
 - lib/trmnl/liquid/template_tag.rb
-- lib/trmnl/liquid/version.rb
 - trmnl-liquid.gemspec
 homepage: https://github.com/usetrmnl/trmnl-liquid
 licenses:
@@ -123,14 +125,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: '4.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.5
 specification_version: 4
 summary: Liquid templating engine for TRMNL plugins
 test_files: []

data/lib/trmnl/liquid/file_system.rb

@@ -1,21 +0,0 @@
-module TRMNL
-  module Liquid
-    # This in-memory "file system" is the backing storage for custom templates defined {% template [name] %} tags.
-    class FileSystem < ::Liquid::BlankFileSystem
-      def initialize
-        super
-        @templates = {}
-      end
-
-      # called by Markup::LiquidTemplateTag to save users' custom shared templates via our custom {% template %} tag
-      def register(name, body)
-        @templates[name] = body
-      end
-
-      # called by ::Liquid::Template for {% render 'foo' %} when rendering screen markup
-      def read_template_file(name)
-        @templates[name] || raise(::Liquid::FileSystemError, "Template not found: #{name}")
-      end
-    end
-  end
-end

data/lib/trmnl/liquid/version.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-module TRMNL
-  module Liquid
-    VERSION = "0.4.0"
-  end
-end