luigi-template 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a2d52d440f44dd02a4bfef5a305bef2bae1a3c25e2cbe8874e42a34ac53ce862
+  data.tar.gz: cb991f02739dee48a8f752e68fc2975e936269422e7fd937115824f2335a43de
+SHA512:
+  metadata.gz: 2f977f467899c187c3bf05fa76e9f8f8170bd7edeed8a57452e2ce448f3930456cd80fbee1425d6e5c68121034b0ec3dd0af2c6f6e63f463718e387ee0cb9fc8
+  data.tar.gz: b4595175ca66f28c6bfec2ab31d4d4441dae8877ed12b23e69b3422ffa7bd95c6f41a023a776ee1ee04f7176ce71241ca626d0ba0b254bc2782cca5d49e4a688

data/README.mkd

@@ -0,0 +1,75 @@
+Luigi Template
+==============
+
+Overview
+--------
+Luigi Template is a string templating library for JavaScript, Java,
+Ruby, and PHP.
+
+Here's an example:
+
+*TODO*
+
+Features:
+
+*TODO*
+
+Documentation
+-------------
+The API documentation is available online at the following URL:
+
+https://pablotron.github.io/luigi-template/ruby/
+
+You can generate the API documentation in the `docs/` directory via
+[RDoc][], like so:
+
+    # generate API documentation in docs/ directory
+    rake docs
+
+Tests
+-----
+You can run the [minitest][] test suite via [Rake][], like so:
+
+    # run the test suite
+    rake test
+
+To generate a [JUnit][]-compatible XML report, install the
+[minitest-junit][] gem and then do the following:
+
+    # run the test suite and generate a junit-compatible report.xml
+    rake test TESTOPTS=--junit
+
+Author
+------
+Paul Duncan ([pabs@pablotron.org][me])<br/>
+https://pablotron.org/
+
+License
+-------
+Copyright 2010-2018 Paul Duncan ([pabs@pablotron.org][me])
+
+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.
+
+[JUnit]: https://junit.org/
+[me]: mailto:pabs@pablotron.org
+[minitest]: https://github.com/seattlerb/minitest
+[minitest-junit]: https://github.com/aespinosa/minitest-junit
+[RDoc]: https://github.com/ruby/rdoc
+[Rake]: https://github.com/ruby/rake

data/Rakefile

@@ -0,0 +1,16 @@
+require 'rake/testtask'
+require 'rdoc/task'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+RDoc::Task.new :docs do |t|
+  t.main = "lib/luigi-template.rb"
+  t.rdoc_files.include('lib/*.rb')
+  t.rdoc_dir = 'docs'
+  # t.options << "--all"
+end
+
+desc "Run tests"
+task :default => :test

data/lib/luigi-template.rb

@@ -0,0 +1,914 @@
+#
+# = Luigi Template
+#
+# == Overview
+#
+# Luigi Template is a string template library.
+#
+# == Examples
+#
+# Simple usage example:
+#
+#     # load luigi template
+#     require 'luigi-template'
+#
+#     # create template
+#     tmpl = Luigi::Template.new('hello %{name}')
+#
+#     # run template and print result
+#     puts tmpl.run({
+#       name: 'Paul'
+#     })
+#
+#     # prints "hello Paul"
+#
+# You can also filter values in templates, using the pipe symbol:
+#
+#     # create template that converts name to upper-case
+#     tmpl = Luigi::Template.new('hello %{name | uc}')
+#
+#     # run template and print result
+#     puts tmpl.run({
+#       name: 'Paul'
+#     })
+#
+#     # prints "hello PAUL"
+#
+# Filters can be chained:
+#
+#     # create template that converts name to upper-case and then
+#     # strips leading and trailing whitespace
+#     tmpl = Luigi::Template.new('hello %{name | uc | trim}')
+#
+#     # run template and print result
+#     puts tmpl.run({
+#       name: '   Paul    '
+#     })
+#
+#     # prints "hello PAUL"
+#
+# Filters can take arguments:
+#
+#     # create template that converts name to lowercase and then
+#     # calculates the SHA-1 digest of the result
+#     tmpl = Luigi::Template.new('hello %{name | lc | hash sha1}')
+#
+#     # run template and print result
+#     puts tmpl.run({
+#       name: 'Paul',
+#     })
+#
+#     # prints "hello a027184a55211cd23e3f3094f1fdc728df5e0500"
+#
+# You can define custom global filters:
+#
+#     # create custom global filter named 'foobarify'
+#     Luigi::FILTERS[:foobarify] = proc { |s| "foo-#{s}-bar" }
+#
+#     # create template which uses custom "foobarify" filter
+#     tmpl = Luigi::Template.new('hello %{name | foobarify}')
+#
+#     # run template and print result
+#     puts tmpl.run({
+#       name: 'Paul'
+#     })
+#
+#     # prints "hello foo-Paul-bar"
+#
+# Or define custom filters for a template:
+#
+#     # create template with custom filters rather than global filters
+#     tmpl = Luigi::Template.new('hello %{name | reverse}', {
+#       reverse: proc { |s| s.reverse }
+#     })
+#
+#     # run template and print result
+#     puts tmpl.run({
+#       name: 'Paul',
+#     })
+#
+#     # prints "hello luaP"
+#
+# Your custom filters can accept arguments, too:
+#
+#     # create custom global filter named 'foobarify'
+#     Luigi::FILTERS[:wrap] = proc { |s, args|
+#       case args.length
+#       when 2
+#         '(%s, %s, %s)' % [args[0], s, args[1]]
+#       when 1
+#         '(%s in %s)' % [s, args[0]]
+#       when 0
+#         s
+#       else
+#         raise 'invalid argument count'
+#       end
+#     }
+#
+#     # create template that uses custom "wrap" filter
+#     tmpl = Luigi::Template.new('sandwich: %{meat | wrap slice heel}, taco: %{meat | wrap shell}')
+#
+#     # run template and print result
+#     puts tmpl.run({
+#       meat: 'chicken'
+#     })
+#
+#     # prints "sandwich: (slice, chicken, heel), taco: (chicken in shell)"
+#
+# == Filters
+#
+# The following filters are built-in:
+#
+# * +uc+: Convert string to upper-case.
+# * +lc+: Convert string to lower-case.
+# * +h+: HTML-escape string.
+# * +u+: URL-escape string.
+# * +json+: JSON-encode value.
+# * +trim+: Strip leading and trailing whitespace from string.
+# * +base64+: Base64-encode value.
+# * +hash+: Hash value.  Requires hash algorithm parameter (ex:
+#   "sha1", "md5", etc).
+#
+# You can add your own global filters, like so:
+#
+#     # create custom global filter named 'foobarify'
+#     Luigi::FILTERS[:foobarify] = proc { |s| "foo-#{s}-bar" }
+#
+#     # create template which uses custom "foobarify" filter
+#     tmpl = Luigi::Template.new('hello %{name | foobarify}')
+#
+#     # run template and print result
+#     puts tmpl.run({
+#       name: 'Paul'
+#     })
+#
+#     # prints "hello foo-Paul-bar"
+#
+# == License
+#
+# Copyright 2007-2018 Paul Duncan ({pabs@pablotron.org}[mailto:pabs@pablotron.org])
+#
+# 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.
+#
+
+require 'uri'
+require 'json'
+require 'openssl'
+# require 'pp'
+
+#
+# Top-level Luigi namespace.  See Luigi::Template for details.
+#
+# Example:
+#
+#     # load luigi template
+#     require 'luigi-template'
+#
+#     # create template
+#     tmpl = Luigi::Template.new('hello %{name}')
+#
+#     # run template and print result
+#     puts tmpl.run({
+#       name: 'Paul'
+#     })
+#
+#     # prints "hello Paul"
+#
+# You can also filter values in templates, using the pipe symbol:
+#
+#     # create template that converts name to upper-case
+#     tmpl = Luigi::Template.new('hello %{name | uc}')
+#
+#     # run template and print result
+#     puts tmpl.run({
+#       name: 'Paul'
+#     })
+#
+#     # prints "hello PAUL"
+#
+# Filters can be chained:
+#
+#     # create template that converts name to upper-case and then
+#     # strips leading and trailing whitespace
+#     tmpl = Luigi::Template.new('hello %{name | uc | trim}')
+#
+#     # run template and print result
+#     puts tmpl.run({
+#       name: '   Paul    '
+#     })
+#
+#     # prints "hello PAUL"
+#
+# Filters can take arguments:
+#
+#     # create template that converts name to lowercase and then
+#     # calculates the SHA-1 digest of the result
+#     tmpl = Luigi::Template.new('hello %{name | lc | hash sha1}')
+#
+#     # run template and print result
+#     puts tmpl.run({
+#       name: 'Paul',
+#     })
+#
+#     # prints "hello a027184a55211cd23e3f3094f1fdc728df5e0500"
+#
+# You can define custom global filters:
+#
+#     # create custom global filter named 'foobarify'
+#     Luigi::FILTERS[:foobarify] = proc { |s| "foo-#{s}-bar" }
+#
+#     # create template which uses custom "foobarify" filter
+#     tmpl = Luigi::Template.new('hello %{name | foobarify}')
+#
+#     # run template and print result
+#     puts tmpl.run({
+#       name: 'Paul'
+#     })
+#
+#     # prints "hello foo-Paul-bar"
+#
+# Or define custom filters for a template:
+#
+#     # create template with custom filters rather than global filters
+#     tmpl = Luigi::Template.new('hello %{name | reverse}', {
+#       reverse: proc { |s| s.reverse }
+#     })
+#
+#     # run template and print result
+#     puts tmpl.run({
+#       name: 'Paul',
+#     })
+#
+#     # prints "hello luaP"
+#
+# Your custom filters can accept arguments, too:
+#
+#     # create custom global filter named 'foobarify'
+#     Luigi::FILTERS[:wrap] = proc { |s, args|
+#       case args.length
+#       when 2
+#         '(%s, %s, %s)' % [args[0], s, args[1]]
+#       when 1
+#         '(%s in %s)' % [s, args[0]]
+#       when 0
+#         s
+#       else
+#         raise 'invalid argument count'
+#       end
+#     }
+#
+#     # create template that uses custom "wrap" filter
+#     tmpl = Luigi::Template.new('sandwich: %{meat | wrap slice heel}, taco: %{meat | wrap shell}')
+#
+#     # run template and print result
+#     puts tmpl.run({
+#       meat: 'chicken'
+#     })
+#
+#     # prints "sandwich: (slice, chicken, heel), taco: (chicken in shell)"
+#
+module Luigi
+  #
+  # Version of Luigi Template.
+  #
+  VERSION = '0.5.0'
+
+  #
+  # Base class for all errors raised by Luigi Template.
+  #
+  class LuigiError < Exception
+  end
+
+  #
+  # Base class for unknown entry errors raised by Luigi Template.
+  #
+  class BaseUnknownError < LuigiError
+    #
+    # Type of unknown entry (Symbol).
+    #
+    attr_reader :type
+
+    #
+    # Name of unknown entry (String).
+    #
+    attr_reader :name
+
+    #
+    # Create a new BaseUnknownError instance.
+    #
+    # Parameters:
+    #
+    # * +type+: Type name (ex: "template", "filter", or "key").
+    # * +name+: Item name.
+    #
+    def initialize(type, name)
+      @type, @name = type, name
+      super("unknown #{type}: #{name}")
+    end
+  end
+
+  #
+  # Thrown by Luigi::Template#run when an unknown key is encountered.
+  #
+  # The key is available in the +name+ attribute.
+  #
+  class UnknownKeyError < BaseUnknownError
+    #
+    # Create a new UnknownFilterError instance.
+    #
+    # Parameters:
+    #
+    # * +name+: Unknown key.
+    #
+    def initialize(name)
+      super(:key, name)
+    end
+  end
+
+  #
+  # Thrown by Luigi::Template#run when an unknown filter is encountered.
+  #
+  # The unknown filter name is available in the +name+ attribute.
+  #
+  class UnknownFilterError < BaseUnknownError
+    #
+    # Create a new UnknownFilterError instance.
+    #
+    # Parameters:
+    #
+    # * +name+: Name of the unknown filter.
+    #
+    def initialize(name)
+      super(:filter, name)
+    end
+  end
+
+
+  #
+  # Thrown by Luigi::Cache#run when an unknown template is encountered.
+  #
+  # The unknown template name is available in the +name+ attribute.
+  #
+  class UnknownTemplateError < BaseUnknownError
+    #
+    # Create a new UnknownTemplateError instance.
+    #
+    # Parameters:
+    #
+    # * +name+: Unknown template name.
+    #
+    def initialize(name)
+      super(:template, name);
+    end
+  end
+
+  #
+  # HTML entity map.
+  #
+  # Used by built-in +h+ filter.
+  #
+  HTML_ENTITIES = {
+    38 => '&amp;',
+    60 => '&lt;',
+    62 => '&gt;',
+    34 => '&quot;',
+    39 => '&apos;',
+  }
+
+  #
+  # Map of built-in global filters.
+  #
+  # Default Filters:
+  #
+  # * +uc+: Convert string to upper-case.
+  # * +lc+: Convert string to lower-case.
+  # * +h+: HTML-escape string.
+  # * +u+: URL-escape string.
+  # * +json+: JSON-encode value.
+  # * +trim+: Strip leading and trailing whitespace from string.
+  # * +base64+: Base64-encode value.
+  # * +hash+: Hash value.  Requires hash algorithm parameter (ex:
+  #   "sha1", "md5", etc).
+  #
+  # You can add your own global filters, like so:
+  #
+  #     # create custom global filter named 'foobarify'
+  #     Luigi::FILTERS[:foobarify] = proc { |s| "foo-#{s}-bar" }
+  #
+  #     # create template which uses custom "foobarify" filter
+  #     tmpl = Luigi::Template.new('hello %{name | foobarify}')
+  #
+  #     # run template and print result
+  #     puts tmpl.run({
+  #       name: 'Paul'
+  #     })
+  #
+  #     # prints "hello foo-Paul-bar"
+  #
+  FILTERS = {
+    # upper-case string
+    uc: proc { |v|
+      (v || '').to_s.upcase
+    },
+
+    # lower-case string
+    lc: proc { |v|
+      (v || '').to_s.downcase
+    },
+
+    # html-escape string
+    h: proc { |v|
+      (v || '').to_s.bytes.map { |b|
+        if b < 32 || b > 126
+          "&##{b};"
+        elsif HTML_ENTITIES.key?(b)
+          HTML_ENTITIES[b]
+        else
+          b.chr
+        end
+      }.join
+    },
+
+    # uri-escape string
+    u: proc { |v|
+      URI.encode_www_form_component((v || '').to_s)
+    },
+
+    # json-encode value
+    json: proc { |v|
+      JSON.unparse(v)
+    },
+
+    # trim leading and trailing whitespace from string
+    trim: proc { |v, args, row, t|
+      (v || '').to_s.strip
+    },
+
+    # base64-encode string
+    base64: proc { |v, args, row, t|
+      [(v || '').to_s].pack('m').strip
+    },
+
+    # hash string
+    hash: proc { |v, args, row, t|
+      OpenSSL::Digest.new(args[0]).hexdigest((v || '').to_s)
+    },
+  }
+
+  #
+  # Template parser.
+  #
+  module Parser # :nodoc: all
+    RES = {
+      action: %r{
+        # match opening brace
+        %\{
+
+        # match optional whitespace
+        \s*
+
+        # match key
+        (?<key>[^\s\|\}]+)
+
+        # match filter(s)
+        (?<filters>(\s*\|(\s*[^\s\|\}]+)+)*)
+
+        # match optional whitespace
+        \s*
+
+        # match closing brace
+        \}
+
+        # or match up all non-% chars or a single % char
+        | (?<text>[^%]* | %)
+      }mx,
+
+      filter: %r{
+        # match filter name
+        (?<name>\S+)
+
+        # match filter arguments (optional)
+        (?<args>(\s*\S+)*)
+
+        # optional trailing whitespace
+        \s*
+      }mx,
+
+      delim_filters: %r{
+        \s*\|\s*
+      }mx,
+
+      delim_args: %r{
+        \s+
+      },
+    }.reduce({}) do |r, row|
+      r[row[0]] = row[1].freeze
+      r
+    end.freeze
+
+    #
+    # Parse a (possibly empty) string into an array of actions.
+    #
+    def self.parse_template(str)
+      str.scan(RES[:action]).map { |m|
+        if m[0] && m[0].length > 0
+          fs = parse_filters(m[1]).freeze
+          { type: :action, key: m[0].intern, filters: fs }
+        else
+          # literal text
+          { type: :text, text: m[2].freeze }
+        end.freeze
+      }.freeze
+    end
+
+    #
+    # Parse a (possibly empty) string into an array of filters.
+    #
+    def self.parse_filters(str)
+      # strip leading and trailing whitespace
+      str = (str || '').strip
+
+      if str.length > 0
+        str.strip.split(RES[:delim_filters]).inject([]) do |r, f|
+          # strip whitespace
+          f = f.strip
+
+          if f.length > 0
+            md = f.match(RES[:filter])
+            raise "invalid filter: #{f}" unless md
+            # pp md
+
+            # get args
+            args = md[:args].strip
+
+            # add to result
+            r << {
+              name: md[:name].intern,
+              args: args.length > 0 ? args.split(RES[:delim_args]) : [],
+            }
+          end
+
+          # return result
+          r
+        end
+      else
+        # return empty filter set
+        []
+      end
+    end
+  end
+
+  #
+  # Template class.
+  #
+  # Parse a template string into a Luigi::Template instance, and then
+  # apply the Luigi::Template via the Luigi::Template#run() method.
+  #
+  # Example:
+  #
+  #     # load luigi template
+  #     require 'luigi-template'
+  #
+  #     # create template
+  #     tmpl = Luigi::Template.new('hello %{name}')
+  #
+  #     # run template and print result
+  #     puts tmpl.run({
+  #       name: 'Paul'
+  #     })
+  #
+  #     # prints "hello Paul"
+  #
+  # You can also filter values in templates, using the pipe symbol:
+  #
+  #     # create template that converts name to upper-case
+  #     tmpl = Luigi::Template.new('hello %{name | uc}')
+  #
+  #     # run template and print result
+  #     puts tmpl.run({
+  #       name: 'Paul'
+  #     })
+  #
+  #     # prints "hello PAUL"
+  #
+  # Filters can be chained:
+  #
+  #     # create template that converts name to upper-case and then
+  #     # strips leading and trailing whitespace
+  #     tmpl = Luigi::Template.new('hello %{name | uc | trim}')
+  #
+  #     # run template and print result
+  #     puts tmpl.run({
+  #       name: '   Paul    '
+  #     })
+  #
+  #     # prints "hello PAUL"
+  #
+  # Filters can take arguments:
+  #
+  #     # create template that converts name to lowercase and then
+  #     # calculates the SHA-1 digest of the result
+  #     tmpl = Luigi::Template.new('hello %{name | lc | hash sha1}')
+  #
+  #     # run template and print result
+  #     puts tmpl.run({
+  #       name: 'Paul',
+  #     })
+  #
+  #     # prints "hello a027184a55211cd23e3f3094f1fdc728df5e0500"
+  #
+  # You can define custom global filters:
+  #
+  #     # create custom global filter named 'foobarify'
+  #     Luigi::FILTERS[:foobarify] = proc { |s| "foo-#{s}-bar" }
+  #
+  #     # create template which uses custom "foobarify" filter
+  #     tmpl = Luigi::Template.new('hello %{name | foobarify}')
+  #
+  #     # run template and print result
+  #     puts tmpl.run({
+  #       name: 'Paul'
+  #     })
+  #
+  #     # prints "hello foo-Paul-bar"
+  #
+  # Or define custom filters for a template:
+  #
+  #     # create template with custom filters rather than global filters
+  #     tmpl = Luigi::Template.new('hello %{name | reverse}', {
+  #       reverse: proc { |s| s.reverse }
+  #     })
+  #
+  #     # run template and print result
+  #     puts tmpl.run({
+  #       name: 'Paul',
+  #     })
+  #
+  #     # prints "hello luaP"
+  #
+  # Your custom filters can accept arguments, too:
+  #
+  #     # create custom global filter named 'foobarify'
+  #     Luigi::FILTERS[:wrap] = proc { |s, args|
+  #       case args.length
+  #       when 2
+  #         '(%s, %s, %s)' % [args[0], s, args[1]]
+  #       when 1
+  #         '(%s in %s)' % [s, args[0]]
+  #       when 0
+  #         s
+  #       else
+  #         raise 'invalid argument count'
+  #       end
+  #     }
+  #
+  #     # create template that uses custom "wrap" filter
+  #     tmpl = Luigi::Template.new('sandwich: %{meat | wrap slice heel}, taco: %{meat | wrap shell}')
+  #
+  #     # run template and print result
+  #     puts tmpl.run({
+  #       meat: 'chicken'
+  #     })
+  #
+  #     # prints "sandwich: (slice, chicken, heel), taco: (chicken in shell)"
+  #
+  class Template
+    #
+    # Original template string.
+    #
+    attr_reader :str
+
+    #
+    # Create a new template, expand it with the given arguments and
+    # filters, and print the result.
+    #
+    # Parameters:
+    #
+    # * +str+: Template string.
+    # * +args+: Argument key/value map.
+    # * +filters+: Hash of filters.  Defaults to Luigi::FILTERS if
+    #   unspecified.
+    #
+    # Example:
+    #
+    #     # create a template object, expand it, and print the result
+    #     puts Luigi::Template.run('hello %{name}', {
+    #       name: 'Paul'
+    #     })
+    #
+    #     # prints "hello Paul"
+    #
+    def self.run(str, args = {}, filters = FILTERS)
+      Template.new(str, filters).run(args)
+    end
+
+    #
+    # Create a new Template from the given string.
+    #
+    def initialize(str, filters = FILTERS)
+      @str, @filters = str.freeze, filters
+      @actions = Parser.parse_template(str).freeze
+    end
+
+    #
+    # Expand template with the given arguments and return the result.
+    #
+    # Parameters:
+    #
+    # * +args+: Argument key/value map.
+    #
+    # Example:
+    #
+    #     # create a template object
+    #     tmpl = Luigi::Template.new('hello %{name}')
+    #
+    #     # apply template, print result
+    #     puts tmpl.run({ name: 'Paul'})
+    #
+    #     # prints "hello Paul"
+    #
+    # This method is aliased as "%", so you can do this:
+    #
+    #     # create template
+    #     tmpl = Luigi::Template.new('hello %{name | uc}')
+    #
+    #     # run template and print result
+    #     puts tmpl % { name: 'Paul' }
+    #
+    #     # prints "hello PAUL"
+    #
+    def run(args)
+      @actions.map { |a|
+        # pp a
+
+        case a[:type]
+        when :action
+          # check key and get value
+          val = if args.key?(a[:key])
+            args[a[:key]]
+          elsif args.key?(a[:key].to_s)
+            args[a[:key].to_s]
+          else
+            # invalid key
+            raise UnknownKeyError.new(a[:key])
+          end
+
+          # filter value
+          a[:filters].inject(val) do |r, f|
+            # check filter name
+            unless @filters.key?(f[:name])
+              raise UnknownFilterError.new(f[:name])
+            end
+
+            # call filter, return result
+            @filters[f[:name]].call(r, f[:args], args, self)
+          end
+        when :text
+          # literal text
+          a[:text]
+        else
+          # never reached
+          raise "unknown action type: #{a[:type]}"
+        end
+      }.join
+    end
+
+    alias :'%' :run
+
+    #
+    # Return the input template string.
+    #
+    # Example:
+    #
+    #     # create a template object
+    #     tmpl = Luigi::Template.new('hello %{name}')
+    #
+    #     # create a template object
+    #     puts tmpl.to_s
+    #
+    #     # prints "hello %{name}"
+    #
+    def to_s
+      @str
+    end
+  end
+
+  #
+  # Minimal lazy-loading template cache.
+  #
+  # Group a set of templates together and only parse them on an
+  # as-needed basis.
+  #
+  class Cache
+    #
+    # Create a new template cache with the given templates.
+    #
+    # Parameters:
+    #
+    # * +strings+: Map of template names to template strings.
+    # * +filters+: Hash of filters.  Defaults to Luigi::FILTERS if
+    #   unspecified.
+    #
+    # Example:
+    #
+    #     # create template cache
+    #     cache = Luigi::Cache.new({
+    #       hi: 'hi %{name}!'
+    #     })
+    #
+    #     # run template from cache
+    #     puts cache.run(:hi, {
+    #       name: 'Paul'
+    #     })
+    #
+    #     # prints "hi paul!"
+    #
+    def initialize(strings, filters = FILTERS)
+      # work with frozen copy of strings hash
+      strings = strings.freeze
+
+      @templates = Hash.new do |h, k|
+        # always deal with symbols
+        k = k.intern
+
+        # make sure template exists
+        raise UnknownTemplateError.new(k) unless strings.key?(k)
+
+        # create template
+        h[k] = Template.new(strings[k], filters)
+      end
+    end
+
+    #
+    # Get given template, or raise an UnknownTemplateError if the given
+    # template does not exist.
+    #
+    # Example:
+    #
+    #     # create template cache
+    #     cache = Luigi::Cache.new({
+    #       hi: 'hi %{name}!'
+    #     })
+    #
+    #     # get template from cache
+    #     tmpl = cache[:hi]
+    #
+    #     # run template, print result
+    #     puts tmpl.run(:hi, {
+    #       name: 'Paul'
+    #     })
+    #
+    #     # prints "hi Paul"
+    #
+    def [](key)
+      @templates[key]
+    end
+
+    #
+    # Run specified template from cache with the given templates.
+    #
+    # Raises an UnknownTemplateError if the given template key does not
+    # exist.
+    #
+    # Parameters:
+    #
+    # * +key+: Template key.
+    # * +args+: Argument key/value map.
+    #
+    # Example:
+    #
+    #     # create template cache
+    #     cache = Luigi::Cache.new({
+    #       hi: 'hi %{name}!'
+    #     })
+    #
+    #     # run template from cache
+    #     puts cache.run(:hi, {
+    #       name: 'Paul'
+    #     })
+    #
+    #     # prints "hi paul!"
+    #
+    def run(key, args)
+      # run template with args and return result
+      @templates[key].run(args)
+    end
+  end
+end

data/test/test_cache.rb

@@ -0,0 +1,28 @@
+require 'minitest/autorun'
+require 'luigi-template'
+
+class CacheTest < MiniTest::Test
+  def test_cache
+    cache = Luigi::Cache.new({
+      foo: 'foo%{bar}',
+    })
+
+    r = cache.run(:foo, bar: 'foo')
+
+    assert_equal 'foofoo', r
+  end
+
+  def test_cache_with_custom_filters
+    cache = Luigi::Cache.new({
+      foo: 'foo%{bar | barify}',
+    }, {
+      barify: proc { |v| 
+        "bar-#{v}-bar"
+      },
+    })
+
+    r = cache.run(:foo, bar: 'foo')
+
+    assert_equal 'foobar-foo-bar', r
+  end
+end

data/test/test_default_filters.rb

@@ -0,0 +1,86 @@
+require 'minitest/autorun'
+require 'luigi-template'
+
+class FiltersTest < MiniTest::Test
+  def test_uc
+    r = Luigi::Template.run('foo%{bar|uc}', {
+      bar: 'bar',
+    })
+
+    assert_equal 'fooBAR', r
+  end
+
+  def test_lc
+    r = Luigi::Template.run('foo%{bar|lc}', {
+      bar: 'BAR',
+    })
+
+    assert_equal 'foobar', r
+  end
+
+  def test_h
+    r = Luigi::Template.run('%{bar|h}', {
+      bar: "<>&\"'\x0f",
+    })
+
+    assert_equal '&lt;&gt;&amp;&quot;&apos;&#15;', r
+  end
+
+  def test_u
+    r = Luigi::Template.run('%{bar|u}', {
+      bar: "asdf<>&\"' \x0f",
+    })
+
+    assert_equal 'asdf%3C%3E%26%22%27+%0F', r
+  end
+
+  def test_json
+    want = '{"true":true,"false":false,"null":null,"number":5,"string":"foo","hash":{"foo":"bar"},"array":[0,1]}';
+
+    r = Luigi::Template.run('%{bar|json}', {
+      bar: {
+        true: true,
+        false: false,
+        null: nil,
+        number: 5,
+        string: 'foo',
+        hash: { foo: 'bar' },
+        array: [0, 1],
+      },
+    })
+
+    assert_equal want, r
+  end
+
+  def test_trim
+    r = Luigi::Template.run('foo%{bar|trim}', {
+      bar: "\r\n\t\v foo \r\n\t\v",
+    })
+
+    assert_equal 'foofoo', r
+  end
+
+  def test_base64
+    r = Luigi::Template.run('%{bar|base64}', {
+      bar: "foo",
+    })
+
+    assert_equal 'Zm9v', r
+  end
+
+  def test_hash_md5
+    r = Luigi::Template.run('%{bar|hash md5}', {
+      bar: "foo",
+    })
+
+    assert_equal 'acbd18db4cc2f85cedef654fccc4a4d8', r
+  end
+
+  def test_hash_sha1
+    r = Luigi::Template.run('%{bar|hash sha1}', {
+      bar: "foo",
+    })
+
+    assert_equal '0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33', r
+  end
+end

data/test/test_errors.rb

@@ -0,0 +1,32 @@
+require 'minitest/autorun'
+require 'luigi-template'
+
+class ErrorsTest < MiniTest::Test
+  def test_unknown_key_error
+    assert_raises(Luigi::UnknownKeyError) do
+      Luigi::Template.run('foo%{unknown-key}', {
+        bar: 'foo',
+      })
+    end
+  end
+
+  def test_unknown_filter_error
+    assert_raises(Luigi::UnknownFilterError) do
+      Luigi::Template.run('foo%{bar | unknown-filter}', {
+        bar: 'foo',
+      })
+    end
+  end
+
+  def test_unknown_template_error
+    assert_raises(Luigi::UnknownTemplateError) do
+      cache = Luigi::Cache.new({
+        foo: 'foo%{bar}',
+      })
+
+      cache.run('unknown-template', {
+        bar: 'foo'
+      })
+    end
+  end
+end

data/test/test_filters.rb

@@ -0,0 +1,51 @@
+require 'minitest/autorun'
+require 'luigi-template'
+
+class FiltersTest < MiniTest::Test
+  def test_filter
+    r = Luigi::Template.run('foo%{bar|h}', {
+      bar: '<',
+    })
+
+    assert_equal 'foo&lt;', r
+  end
+
+  def test_filter_chain
+    want = 'foofeab40e1fca77c7360ccca1481bb8ba5f919ce3a'
+    r = Luigi::Template.run('foo%{bar | uc | hash sha1}', {
+      bar: 'foo',
+    })
+
+    assert_equal want, r
+  end
+
+  def test_custom_global_filter
+    Luigi::FILTERS[:barify] = proc { |v| 'BAR' }
+
+    r = Luigi::Template.run('foo%{bar | barify}', {
+      bar: 'foo',
+    })
+
+    assert_equal 'fooBAR', r
+  end
+
+  def test_custom_template_filter
+    r = Luigi::Template.run('foo%{bar | barify}', {
+      bar: 'foo',
+    }, {
+      barify: proc { |v| 'BAR' }
+    })
+
+    assert_equal 'fooBAR', r
+  end
+
+  def test_filter_args
+    want = 'foo0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33'
+
+    r = Luigi::Template.run('foo%{bar | hash sha1}', {
+      bar: 'foo'
+    })
+
+    assert_equal want, r
+  end
+end

data/test/test_template.rb

@@ -0,0 +1,65 @@
+require 'minitest/autorun'
+require 'luigi-template'
+
+class TemplateTest < MiniTest::Test
+  def test_new
+    t = Luigi::Template.new('foo%{bar}')
+    assert_instance_of Luigi::Template, t
+  end
+
+  def test_run
+    t = Luigi::Template.new('foo%{bar}')
+    r = t.run(bar: 'foo')
+
+    assert_equal 'foofoo', r
+  end
+
+  def test_run_with_string_key
+    t = Luigi::Template.new('foo%{bar}')
+    r = t.run('bar' => 'foo')
+
+    assert_equal 'foofoo', r
+  end
+
+  def test_self_run
+    r = Luigi::Template.run('foo%{bar}', bar: 'foo')
+    assert_equal 'foofoo', r
+  end
+
+  def test_multiple_keys
+    r = Luigi::Template.run('foo%{bar}%{baz}', {
+      bar: 'foo',
+      baz: 'bar',
+    })
+
+    assert_equal 'foofoobar', r
+  end
+
+  def test_whitespace
+    r = Luigi::Template.run('%{ bar}%{ bar }%{ bar}', {
+      bar: 'foo',
+    })
+
+    assert_equal 'foofoofoo', r
+  end
+
+  def test_newlines
+    r = Luigi::Template.run('%{
+      bar}%{
+      bar
+
+      }%{
+        bar}', {
+      bar: 'foo',
+    })
+
+    assert_equal 'foofoofoo', r
+  end
+
+  def test_to_s
+    want = '%{val | h}'
+    t = Luigi::Template.new(want)
+
+    assert_equal want, t.to_s
+  end
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: luigi-template
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Paul Duncan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-09-05 00:00:00.000000000 Z
+dependencies: []
+description: Simple string templating library.
+email: pabs@pablotron.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.mkd
+- Rakefile
+- lib/luigi-template.rb
+- test/test_cache.rb
+- test/test_default_filters.rb
+- test/test_errors.rb
+- test/test_filters.rb
+- test/test_template.rb
+homepage: https://github.com/pablotron/luigi-template
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Simple string templating library.
+test_files: []