superfluid 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 46ef69a407c3fbeaa0e095f67b3cf42bf8862e4fc6d9a8327807619d6058bdcc
+  data.tar.gz: fddb30cd353a521163f394fd9fc3b5b30235d19a3e48be6357d791d89a7ec13e
+SHA512:
+  metadata.gz: 900585c327e6a3539a6feb06be51b7d217b2b6bb8712ac7d436ff9d37ff774b12f4c6be89b9f4b7170b8f7b0779664fa43ea3e64b940419ec7a4620f19eafb55
+  data.tar.gz: 0e398a2b3683039d6b247ea8b1fa33d75491b702d938534918d969ea86b1d8f1ce1daac4295d8de0ef5283228d7e3e3ff3771bac0f636a79d58d8fc39b2a23d1

data/LICENSE.adoc

@@ -0,0 +1,134 @@
+= Hippocratic License
+
+Version: 2.1.0.
+
+Purpose. The purpose of this License is for the Licensor named above to
+permit the Licensee (as defined below) broad permission, if consistent
+with Human Rights Laws and Human Rights Principles (as each is defined
+below), to use and work with the Software (as defined below) within the
+full scope of Licensor’s copyright and patent rights, if any, in the
+Software, while ensuring attribution and protecting the Licensor from
+liability.
+
+Permission and Conditions. The Licensor grants permission by this
+license ("License"), free of charge, to the extent of Licensor’s
+rights under applicable copyright and patent law, to any person or
+entity (the "Licensee") obtaining a copy of this software and
+associated documentation files (the "Software"), to do everything with
+the Software that would otherwise infringe (i) the Licensor’s copyright
+in the Software or (ii) any patent claims to the Software that the
+Licensor can license or becomes able to license, subject to all of the
+following terms and conditions:
+
+* Acceptance. This License is automatically offered to every person and
+entity subject to its terms and conditions. Licensee accepts this
+License and agrees to its terms and conditions by taking any action with
+the Software that, absent this License, would infringe any intellectual
+property right held by Licensor.
+* Notice. Licensee must ensure that everyone who gets a copy of any part
+of this Software from Licensee, with or without changes, also receives
+the License and the above copyright notice (and if included by the
+Licensor, patent, trademark and attribution notice). Licensee must cause
+any modified versions of the Software to carry prominent notices stating
+that Licensee changed the Software. For clarity, although Licensee is
+free to create modifications of the Software and distribute only the
+modified portion created by Licensee with additional or different terms,
+the portion of the Software not modified must be distributed pursuant to
+this License. If anyone notifies Licensee in writing that Licensee has
+not complied with this Notice section, Licensee can keep this License by
+taking all practical steps to comply within 30 days after the notice. If
+Licensee does not do so, Licensee’s License (and all rights licensed
+hereunder) shall end immediately.
+* Compliance with Human Rights Principles and Human Rights Laws.
+[arabic]
+. Human Rights Principles.
+[loweralpha]
+.. Licensee is advised to consult the articles of the United Nations
+Universal Declaration of Human Rights and the United Nations Global
+Compact that define recognized principles of international human rights
+(the "Human Rights Principles"). Licensee shall use the Software in a
+manner consistent with Human Rights Principles.
+.. Unless the Licensor and Licensee agree otherwise, any dispute,
+controversy, or claim arising out of or relating to (i) Section 1(a)
+regarding Human Rights Principles, including the breach of Section 1(a),
+termination of this License for breach of the Human Rights Principles,
+or invalidity of Section 1(a) or (ii) a determination of whether any Law
+is consistent or in conflict with Human Rights Principles pursuant to
+Section 2, below, shall be settled by arbitration in accordance with the
+Hague Rules on Business and Human Rights Arbitration (the "Rules");
+provided, however, that Licensee may elect not to participate in such
+arbitration, in which event this License (and all rights licensed
+hereunder) shall end immediately. The number of arbitrators shall be one
+unless the Rules require otherwise.
++
+Unless both the Licensor and Licensee agree to the contrary: (1) All
+documents and information concerning the arbitration shall be public and
+may be disclosed by any party; (2) The repository referred to under
+Article 43 of the Rules shall make available to the public in a timely
+manner all documents concerning the arbitration which are communicated
+to it, including all submissions of the parties, all evidence admitted
+into the record of the proceedings, all transcripts or other recordings
+of hearings and all orders, decisions and awards of the arbitral
+tribunal, subject only to the arbitral tribunal’s powers to take such
+measures as may be necessary to safeguard the integrity of the arbitral
+process pursuant to Articles 18, 33, 41 and 42 of the Rules; and (3)
+Article 26(6) of the Rules shall not apply.
+. Human Rights Laws. The Software shall not be used by any person or
+entity for any systems, activities, or other uses that violate any Human
+Rights Laws. "Human Rights Laws" means any applicable laws,
+regulations, or rules (collectively, "Laws") that protect human,
+civil, labor, privacy, political, environmental, security, economic, due
+process, or similar rights; provided, however, that such Laws are
+consistent and not in conflict with Human Rights Principles (a dispute
+over the consistency or a conflict between Laws and Human Rights
+Principles shall be determined by arbitration as stated above). Where
+the Human Rights Laws of more than one jurisdiction are applicable or in
+conflict with respect to the use of the Software, the Human Rights Laws
+that are most protective of the individuals or groups harmed shall
+apply.
+. Indemnity. Licensee shall hold harmless and indemnify Licensor (and
+any other contributor) against all losses, damages, liabilities,
+deficiencies, claims, actions, judgments, settlements, interest, awards,
+penalties, fines, costs, or expenses of whatever kind, including
+Licensor’s reasonable attorneys’ fees, arising out of or relating to
+Licensee’s use of the Software in violation of Human Rights Laws or
+Human Rights Principles.
+* Failure to Comply. Any failure of Licensee to act according to the
+terms and conditions of this License is both a breach of the License and
+an infringement of the intellectual property rights of the Licensor
+(subject to exceptions under Laws, e.g., fair use). In the event of a
+breach or infringement, the terms and conditions of this License may be
+enforced by Licensor under the Laws of any jurisdiction to which
+Licensee is subject. Licensee also agrees that the Licensor may enforce
+the terms and conditions of this License against Licensee through
+specific performance (or similar remedy under Laws) to the extent
+permitted by Laws. For clarity, except in the event of a breach of this
+License, infringement, or as otherwise stated in this License, Licensor
+may not terminate this License with Licensee.
+* Enforceability and Interpretation. If any term or provision of this
+License is determined to be invalid, illegal, or unenforceable by a
+court of competent jurisdiction, then such invalidity, illegality, or
+unenforceability shall not affect any other term or provision of this
+License or invalidate or render unenforceable such term or provision in
+any other jurisdiction; provided, however, subject to a court
+modification pursuant to the immediately following sentence, if any term
+or provision of this License pertaining to Human Rights Laws or Human
+Rights Principles is deemed invalid, illegal, or unenforceable against
+Licensee by a court of competent jurisdiction, all rights in the
+Software granted to Licensee shall be deemed null and void as between
+Licensor and Licensee. Upon a determination that any term or provision
+is invalid, illegal, or unenforceable, to the extent permitted by Laws,
+the court may modify this License to affect the original purpose that
+the Software be used in compliance with Human Rights Principles and
+Human Rights Laws as closely as possible. The language in this License
+shall be interpreted as to its fair meaning and not strictly for or
+against any party.
+* Disclaimer. TO THE FULL EXTENT ALLOWED BY LAW, THIS SOFTWARE COMES
+"AS IS," WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED, AND LICENSOR AND
+ANY OTHER CONTRIBUTOR SHALL NOT BE LIABLE TO ANYONE FOR ANY DAMAGES OR
+OTHER LIABILITY ARISING FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE
+OR THIS LICENSE, UNDER ANY KIND OF LEGAL CLAIM.
+
+This Hippocratic License is an link:https://ethicalsource.dev[Ethical Source license] and is offered
+for use by licensors and licensees at their own risk, on an "AS IS" basis, and with no warranties
+express or implied, to the maximum extent permitted by Laws.

data/README.adoc

@@ -0,0 +1,226 @@
+:toc: macro
+:toclevels: 5
+:figure-caption!:
+
+:command_pattern_link: link:https://alchemists.io/articles/command_pattern[Command Pattern]
+:core_link: link:https://alchemists.io/projects/core[Core]
+:liquid_link: link:https://shopify.github.io/liquid/[Liquid]
+:structs_link: link:https://alchemists.io/articles/ruby_structs[Structs]
+
+= Superfluid
+
+toc::[]
+
+== Features
+
+* Simple renderer initialization.
+* Powerful, and customizable, default environment with a cleaner Object API.
+* Ability to register filters as commands (see {command_pattern_link} for details).
+
+== Requirements
+
+. link:https://www.ruby-lang.org[Ruby].
+. {liquid_link}.
+
+== Setup
+
+To install _with_ security, run:
+
+[source,bash]
+----
+# 💡 Skip this line if you already have the public certificate installed.
+gem cert --add <(curl --compressed --location https://alchemists.io/gems.pem)
+gem install superfluid --trust-policy HighSecurity
+----
+
+To install _without_ security, run:
+
+[source,bash]
+----
+gem install superfluid
+----
+
+You can also add the gem directly to your project:
+
+[source,bash]
+----
+bundle add superfluid
+----
+
+Once the gem is installed, you only need to require it:
+
+[source,ruby]
+----
+require "superfluid"
+----
+
+== Usage
+
+The quickest way to get started is to create a new instance:
+
+[source,ruby]
+----
+renderer = Superfluid.new
+----
+
+Now you can render your template and associated data:
+
+[source,ruby]
+----
+renderer.call "Wow, that was {{ value }}!", "value" => "quick"
+----
+
+The above will yield the following output:
+
+----
+"Wow, that was quick!"
+----
+
+=== Environments
+
+To build the default environment, use:
+
+[source,ruby]
+----
+environment = Superfluid.build
+----
+
+You can also build the default environment directly (which is what the above does:
+
+[source,ruby]
+----
+environment = Superfluid::Environment.for
+----
+
+Both of the above produce a _frozen_ environment (including frozen tags). If you need an environment that isn't frozen (tags included), use:
+
+[source,ruby]
+----
+environment = Superfluid::Environment.new
+----
+
+You can, later, freeze the environment once you've registered any/all filters and tags as follows:
+
+[source,ruby]
+----
+environment.freeze
+----
+
+Finally, the environment is an instance of a `Struct` which means you can leverage all of the power of {structs_link}.
+
+When using `Superfluid.build`, `Superfluid::Environment.for`, or `Superfluid::Environment.new`, you can customize behavior via the following keyword arguments:
+
+* `default_resource_limits`: The resource limits you want to set. Default: `{}`.
+* `error_mode`: The error mode. Default: `:strict`.
+* `exception_renderer`: The exception renderer. Default: `Core::Identity` (see {core_link} for details).
+* `file_system`: The file system. Default: `Superfluid::Systems::Memory.new`.
+* `filter_registry`: The filter registry. Default: `Superfluid::Registries::Filter.new`.
+* `tags`: The default tags. Default: `Liquid::Tags::STANDARD_TAGS`.
+
+=== Filters
+
+By default, {liquid_link} only allows registration of filters as instance methods on a namespace (`Module`). Unfortunately, this leads to terrible design, bad practices, and unnecessarily hard to test objects. You can still register namespaces but this gem encourages the use of commands (see {command_pattern_link}) which allows you tap into Functional Programming by using procs, lambdas, and any object that responds to `#call`. This allow you to build -- and reuse -- more powerful filters.
+
+[source,ruby]
+----
+primary = Module.new { def one = 1 }
+
+secondary = Module.new do
+  def two = 2
+
+  def three = 3
+end
+
+function_a = proc { "four" }
+function_b = proc { "five" }
+
+class Sayer
+  def initialize prefix = "Demo"
+    @prefix = prefix
+  end
+
+  def call(message) = "#{prefix}: #{message}"
+
+  private
+
+  attr_reader :prefix
+end
+
+environment = Superfluid.build do |instance|
+  instance.register_filter(primary)
+          .register_filter(primary, four: function_a, sayer: Sayer.new)
+          .register_filters(primary, secondary, four: function_a, five: function_b)
+end
+----
+
+While the above is contrived, duplicate keys are ignored. Use of `#register_filter` is for backwards compatibility with {liquid_link}. All you need is `#register_filters` to register both namespaces (modules) and commands.
+
+=== Tags
+
+As per {liquid_link} documentation, tags only need to inherit from `Liquid::Tag` and be initialized with `tag_name`, `factor`, and `tokens`. Then you can implement a render method which accepts a `context`. Example:
+
+[source,ruby]
+----
+class Multiply < Liquid::Tag
+  def initialize(tag_name, factor, tokens)
+     super
+     @factor = factor.to_f
+  end
+
+  def render(context) = (factor * context["multiply_by"].to_f).to_s
+
+  private
+
+  attr_reader :factor
+end
+
+environment = Superfluid.build do |instance|
+  instance.register_tag(:multiply, Multiply)
+end
+----
+
+== Development
+
+To contribute, run:
+
+[source,bash]
+----
+git clone https://github.com/bkuhlmann/superfluid
+cd superfluid
+bin/setup
+----
+
+You can also use the IRB console for direct access to all objects:
+
+[source,bash]
+----
+bin/console
+----
+
+== Tests
+
+To test, run:
+
+[source,bash]
+----
+bin/rake
+----
+
+== link:https://alchemists.io/policies/license[License]
+
+== link:https://alchemists.io/policies/security[Security]
+
+== link:https://alchemists.io/policies/code_of_conduct[Code of Conduct]
+
+== link:https://alchemists.io/policies/contributions[Contributions]
+
+== link:https://alchemists.io/policies/developer_certificate_of_origin[Developer Certificate of Origin]
+
+== link:https://alchemists.io/projects/superfluid/versions[Versions]
+
+== link:https://alchemists.io/community[Community]
+
+== Credits
+
+* Built with link:https://alchemists.io/projects/gemsmith[Gemsmith].
+* Engineered by link:https://alchemists.io/team/brooke_kuhlmann[Brooke Kuhlmann].

data/lib/superfluid/environment.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "core"
+
+module Superfluid
+  # The default Liquid environment.
+  Environment = Struct.new(
+    :default_resource_limits,
+    :error_mode,
+    :exception_renderer,
+    :file_system,
+    :filter_registry,
+    :tags
+  ) do
+    def self.for(**)
+      instance = new(**)
+
+      yield instance if block_given?
+
+      instance.freeze
+    end
+
+    def self.default
+      @default ||= new
+    end
+
+    def initialize(**)
+      super
+
+      self[:default_resource_limits] ||= Core::EMPTY_HASH
+      self[:error_mode] ||= :strict
+      self[:exception_renderer] ||= Core::Identity
+      self[:file_system] ||= Systems::Memory.new
+      self[:filter_registry] ||= Registries::Filter.for mode: error_mode
+      self[:tags] ||= Liquid::Tags::STANDARD_TAGS.dup
+
+      @filters_cache = {}
+    end
+
+    def create_filter_registry _context = nil,
+                               filters = Core::EMPTY_ARRAY,
+                               namespace: Liquid::StandardFilters
+      return filter_registry if filters.empty?
+
+      filter_registry.add(namespace, *filters)
+    end
+
+    alias_method :create_strainer, :create_filter_registry
+
+    def filter_names = filter_registry.names
+
+    alias_method :filter_method_names, :filter_names
+
+    def register_filter(namespace, **)
+      filters_cache.clear
+      filter_registry.add(namespace, **)
+      self
+    end
+
+    def register_filters(*, **)
+      filters_cache.clear
+      filter_registry.add(*, **)
+      self
+    end
+
+    def register_tag name, klass
+      tags[name.to_s] = klass
+      self
+    end
+
+    def find_tag(name) = tags[name.to_s]
+
+    alias_method :tag_for_name, :find_tag
+
+    def freeze
+      tags.freeze
+      super
+    end
+
+    private
+
+    attr_reader :filters_cache
+  end
+end

data/lib/superfluid/registries/filter.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Superfluid
+  module Registries
+    # A filter registry.
+    Filter = Data.define :mode, :commands do
+      def self.for(namespace = Liquid::StandardFilters, mode: :strict) = new(mode:).add namespace
+
+      def initialize mode: :strict, commands: {}
+        super
+      end
+
+      def add(*, **)
+        add_namespaces(*)
+        add_commands(**)
+        self
+      end
+
+      def call(name, *)
+        dispatch(name, *)
+      rescue ArgumentError => error
+        raise Liquid::ArgumentError, error.message, error.backtrace
+      end
+
+      alias_method :invoke, :call
+
+      def clear
+        commands.clear
+        self
+      end
+
+      def names = commands.keys
+
+      private
+
+      def add_namespaces(*all) = all.each { add_methods it }
+
+      def add_methods namespace
+        shadow = Class.new.include(namespace).new
+
+        all = namespace.instance_methods
+                       .each
+                       .with_object({}) do |method, all|
+                         name = method.name
+                         all[name] = shadow.method name
+                       end
+
+        add_commands(**all)
+      end
+
+      def add_commands(**all) = all.each { |name, command| add_command name, command }
+
+      # :reek:ManualDispatch
+      def add_command name, function
+        key = name.to_s
+
+        return if commands.key? key
+
+        case function
+          in Proc | Method | Object if function.respond_to? :call then commands[key] = function
+          else fail Liquid::ArgumentError, "Filter must be callable."
+        end
+      end
+
+      def dispatch name, *positionals
+        key = name.to_s
+
+        if commands.key? key
+          commands[key].call(*positionals)
+        elsif mode == :strict
+          fail Liquid::UndefinedFilter, "Undefined filter: #{name}."
+        else
+          positionals.first
+        end
+      end
+    end
+  end
+end

data/lib/superfluid/renderer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Superfluid
+  # Renders template and associated data.
+  class Renderer
+    def initialize environment: Environment.for, parser: Liquid::Template
+      @environment = environment
+      @parser = parser
+    end
+
+    def call(template, data) = parser.parse(template, environment:).render data
+
+    private
+
+    attr_reader :environment, :parser
+  end
+end

data/lib/superfluid/systems/memory.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Superfluid
+  module Systems
+    # An in-memory file system for storing templates.
+    Memory = Data.define :templates do
+      def initialize templates: {}
+        super
+      end
+
+      def register name, content
+        templates[name.to_s] = content
+        self
+      end
+
+      def read_template_file name
+        templates.fetch(name) { fail Liquid::FileSystemError, "Template not found: #{name}." }
+      end
+    end
+  end
+end

data/lib/superfluid/tags/template.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Superfluid
+  module Tags
+    # Define custom templates within the context of the current template.
+    class Template < Liquid::Block
+      NAME_PATTERN = %r(\A[0-9a-zA-Z_/]+\z)
+
+      def initialize tag_name, markup, options
+        super
+
+        @name = markup.strip
+        @content = +""
+      end
+
+      def parse tokens
+        content.clear
+
+        while (token = tokens.shift)
+          break if token.strip == "{% endtemplate %}"
+
+          content << token
+        end
+      end
+
+      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 forward slashes."
+        end
+
+        context.registers[:file_system].register name, content.strip
+        ""
+      end
+
+      private
+
+      attr_reader :name, :content
+    end
+  end
+end

data/lib/superfluid.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "liquid"
+require "zeitwerk"
+
+Zeitwerk::Loader.new.then do |loader|
+  loader.tag = File.basename __FILE__, ".rb"
+  loader.push_dir __dir__
+  loader.setup
+end
+
+# Main namespace.
+module Superfluid
+  def self.loader registry = Zeitwerk::Registry
+    @loader ||= registry.loaders.each.find do |loader|
+      loader.tag == File.basename(__FILE__, ".rb")
+    end
+  end
+
+  def self.build(**) = Environment.for(**) { yield it if block_given? }
+
+  def self.new(**) = Renderer.new(**)
+end

data/superfluid.gemspec

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |spec|
+  spec.name = "superfluid"
+  spec.version = "0.0.0"
+  spec.authors = ["Brooke Kuhlmann"]
+  spec.email = ["brooke@alchemists.io"]
+  spec.homepage = "https://alchemists.io/projects/superfluid"
+  spec.summary = "Enhances Liquid with object composition and functional design."
+  spec.license = "Hippocratic-2.1"
+
+  spec.metadata = {
+    "bug_tracker_uri" => "https://github.com/bkuhlmann/superfluid/issues",
+    "changelog_uri" => "https://alchemists.io/projects/superfluid/versions",
+    "homepage_uri" => "https://alchemists.io/projects/superfluid",
+    "funding_uri" => "https://github.com/sponsors/bkuhlmann",
+    "label" => "Superfluid",
+    "rubygems_mfa_required" => "true",
+    "source_code_uri" => "https://github.com/bkuhlmann/superfluid"
+  }
+
+  spec.signing_key = Gem.default_key_path
+  spec.cert_chain = [Gem.default_cert_path]
+
+  spec.required_ruby_version = ">= 4.0"
+
+  spec.add_dependency "base64", "~> 0.3"
+  spec.add_dependency "core", "~> 3.3"
+  spec.add_dependency "liquid", "~> 5.13"
+  spec.add_dependency "refinements", "~> 14.0"
+  spec.add_dependency "zeitwerk", "~> 2.8"
+
+  spec.extra_rdoc_files = Dir["README*", "LICENSE*"]
+  spec.files = Dir["*.gemspec", "lib/**/*"]
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: superfluid
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Brooke Kuhlmann
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIENjCCAp6gAwIBAgIBAzANBgkqhkiG9w0BAQsFADBBMQ8wDQYDVQQDDAZicm9v
+  a2UxGjAYBgoJkiaJk/IsZAEZFgphbGNoZW1pc3RzMRIwEAYKCZImiZPyLGQBGRYC
+  aW8wHhcNMjYwMzI1MTI0OTEyWhcNMjcwMzI1MTI0OTEyWjBBMQ8wDQYDVQQDDAZi
+  cm9va2UxGjAYBgoJkiaJk/IsZAEZFgphbGNoZW1pc3RzMRIwEAYKCZImiZPyLGQB
+  GRYCaW8wggGiMA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQCro8tj5/E1Hg88
+  f4qfiwPVd2zJQHvdYt4GHVvuHRRgx4HGhJuNp+4BId08RBn7V6V1MW6MY3kezRBs
+  M+7QOQ4b1xNLTvY7FYQB1wGK5a4x7TTokDrPYQxDB2jmsdDYCzVbIMrAvUfcecRi
+  khyGZCdByiiCl4fKv77P12tTT+NfsvXkLt/AYCGwjOUyGKTQ01Z6eC09T27GayPH
+  QQvIkakyFgcJtzSyGzs8bzK5q9u7wQ12MNTjJoXzW69lqp0oNvDylu81EiSUb5S6
+  QzzPxZBiRB1sgtbt1gUbVI262ZDq1gR+HxPFmp+Cgt7ZLIJZAtesQvtcMzseXpfn
+  hpmm0Sw22KGhRAy/mqHBRhDl5HqS1SJp2Ko3lcnpXeFResp0HNlt8NSu13vhC08j
+  GUHU9MyIXbFOsnp3K3ADrAVjPWop8EZkmUR3MV/CUm00w2cZHCSGiXl1KMpiVKvk
+  Ywr1gd2ZME4QLSo+EXUtLxDUa/W3xnBS8dBOuMMz02FPWYr3PN8CAwEAAaM5MDcw
+  CQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0OBBYEFAFgmv0tYMZnItuPycSM
+  F5wykJEVMA0GCSqGSIb3DQEBCwUAA4IBgQAG+ykjp+DIXSybGEtX+/ve974mYfN6
+  8U7qcVfRM+qDSOZ+97iu30qUTbVAKIHlHCDKRn3SgOffDUB5VU2MsJBh/3TPKWBZ
+  anB/uzMcwOfru+qyA3b7ZFqZzRLWmR5FtPObFxc0gYMT3YvLNHk2Nb9Vjq/PoiGG
+  e75PXweDOokwDA5m1gMOz1rdp/dlGMXkSFQg94PPVyUKXgO4VzWTgePSDxOIL+v6
+  +OWV6AaEH9BaqxnmdA5ubi0L7bhl0gbN92FxpNO3kpTjww8kme856a+wCK3qyM5w
+  7ZLbUexynDN0Au8eSpT2Bf6ztGmB1S9ffzDJsGX1/lkpMIB51e48Xe2+gzzOgemk
+  CdZaGupj6WkarnT8kh/cPtyA5ax4rGX6GOS8meGxzkv8Uy0JSEOYAp6wLfIisYZp
+  IJBIXIOkwKKJ0eB5YHrUSJxzpP4LlcIg/eTftaXmJdYjy+2VRrCZYDjfguyLmMjR
+  KR9w4/Fjvqy87kCHmxMWa6IL2Vzt1Clm2cA=
+  -----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.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: liquid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.13'
+- !ruby/object:Gem::Dependency
+  name: refinements
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '14.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '14.0'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+email:
+- brooke@alchemists.io
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.adoc
+- README.adoc
+files:
+- LICENSE.adoc
+- README.adoc
+- lib/superfluid.rb
+- lib/superfluid/environment.rb
+- lib/superfluid/registries/filter.rb
+- lib/superfluid/renderer.rb
+- lib/superfluid/systems/memory.rb
+- lib/superfluid/tags/template.rb
+- superfluid.gemspec
+homepage: https://alchemists.io/projects/superfluid
+licenses:
+- Hippocratic-2.1
+metadata:
+  bug_tracker_uri: https://github.com/bkuhlmann/superfluid/issues
+  changelog_uri: https://alchemists.io/projects/superfluid/versions
+  homepage_uri: https://alchemists.io/projects/superfluid
+  funding_uri: https://github.com/sponsors/bkuhlmann
+  label: Superfluid
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/bkuhlmann/superfluid
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '4.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.19
+specification_version: 4
+summary: Enhances Liquid with object composition and functional design.
+test_files: []