mime-components 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 27afc059f5c4f3436849f350d1b6046bec7f784a1b8d16dade5a899294dc4511
+  data.tar.gz: faab2883fe9bec8083c59b9fd0777b8de85b70257a3a1f866d37081f497021a9
+SHA512:
+  metadata.gz: dde53597426f25ea0ac45f05b8b06fe436d6ebc8a19412f74dcc4b80a0eca379268a647d1630af5b228b1354b99a3a07d774ab78a4e72e22b4a6f1f4a776245a
+  data.tar.gz: b96bf72013f2fc318a2d8a75d4bab5b96ef7b278a2f493909b1f911aebb71c60df4be7bb9bdb252c9729fafddd4902badd79874eb39f7d59751e40b48afb6a90

data/lib/mime-components/components/builtins.rb

@@ -0,0 +1,17 @@
+# Built-in components.
+# frozen_string_literal: true
+
+
+module Mime
+   # Register default components to an engine. This is done when an engine is
+   # initialized and generally should not be done externally.
+   # @param engine(Mime::Engine) engine to register default components to
+   def self.register_defaults(engine)
+      component_variable = Mime::Component.new('Variable') do |attributes, vars|
+         value = vars[attributes[:name].to_s.to_sym]
+         value = Erubi.h(value) unless Component.attr_true?(attributes[:raw])
+         value
+      end
+      engine.register_component(component_variable)
+   end
+end

data/lib/mime-components/components/components.rb

@@ -0,0 +1,66 @@
+# Component system.
+# frozen_string_literal: true
+
+
+module Mime
+   # A component is a class with a 'render' function. This function's output
+   # will replace the final XML in the rendered document.
+   class Component
+      @name, @proc = nil
+
+      # Check if an attribute's value is truthy.
+      # @param value(String|Symbol) attribute to check
+      # @return (True|False) whether or not the value is truthy
+      def self.attr_true?(value)
+         [1, 'true', 'yes'].include?(value.to_s.strip.downcase)
+      end
+
+      # Create a new component.
+      # @param name(String) component name
+      # @param proc(Proc) block to call on invocation
+      def initialize(name, &proc)
+         @name = name
+         @proc = proc
+      end
+
+      # Call this component's rendering function.
+      # @param attributes(Hash) rendering parameters
+      # @param vars(Hash) template variables
+      # @return (String) rendered component
+      def render(attributes, vars)
+         @proc.call(attributes, vars)
+      end
+
+      attr_reader :name
+   end
+
+   class Engine
+      @registered_components = {}
+
+      # Register a new component for this engine.
+      # @param component(Component) component to register
+      def register_component(component)
+         @registered_components[component.name.downcase] = component
+      end
+
+      # Render a component based on its parsed XML tag.
+      # @param name(String) component name
+      # @param xml(String) raw component XML
+      # @param vars(Hash) variables to pass to component
+      def render_component(name, xml, vars)
+         # get component, raising an error if it doesn't exist
+         if (component = @registered_components[name.downcase]).nil?
+            raise "#{xml}: component '#{name}' was not registered for this engine"
+         end
+
+         # normalize attributes
+         xml = Nokogiri::XML.parse(xml).root
+         attributes = {}
+         xml.attributes.map do |k, v|
+            attributes[k.to_s.strip.downcase.to_sym] = v
+         end
+         # render subcomponents of output
+         render(component.render(attributes, vars).to_s, vars)
+      end
+   end
+end

data/lib/mime-components/engine/engine.rb

@@ -0,0 +1,17 @@
+# Engine class and initializer.
+# frozen_string_literal: true
+
+
+module Mime
+   # The Engine is the primary class responsible for rendering Mime documents. Each
+   # engine contains a component registry as well as a set of built-in components.
+   class Engine
+      # Initialize a new instance of the Mime templating engine.
+      def initialize
+         @global_vars = {}
+         @registered_components = {}
+         @component_regex = %r{(<[MmCc]:((?:[A-z0-9\:\-]+)|\#).*?/?>)}
+         Mime.register_defaults(self)
+      end
+   end
+end

data/lib/mime-components/engine/globals.rb

@@ -0,0 +1,30 @@
+# Global per-engine variables.
+# frozen_string_literal: true
+
+
+module Mime
+   class Engine
+      @global_vars = {}
+
+      # Set a global template variable.
+      # @param name(String) name of variable to set
+      # @param value(Object) new value of variable (nil to unset)
+      # @return (Object) new value
+      def []=(name, value)
+         @global_vars[name] = value
+      end
+
+      # Get a global template variable.
+      # @param name(String) name of variable to get value of
+      # @return (Object) value
+      def [](name)
+         @global_vars[name]
+      end
+
+      # Get a list of set global variables.
+      # @return (Array[Object]) set keys
+      def keys
+         @global_vars.keys
+      end
+   end
+end

data/lib/mime-components/engine/render.rb

@@ -0,0 +1,36 @@
+# Component tag location and rendering.
+# frozen_string_literal: true
+
+
+module Mime
+   class Engine
+      # Render all components in a 'template'.
+      # @param template(String) template as string
+      # @param vars(Hash) variables to render with
+      def render(template, vars)
+         @global_vars.each_key do |k|
+            vars[k] = @global_vars[k]
+         end
+         # we locate, parse and replace tags to render the template. none of these
+         # things work with frozen literals, so we'll make a copy to work on and return
+         output = template.dup
+         # find tags
+         matches = output.scan(@component_regex)
+         matches.each do |n|
+            # render tag
+            tag, component_name = n
+            tag_out = if component_name == '#'
+                         ''
+                      else
+                         render_component(component_name, tag, vars)
+                      end
+            # replace tag in output with its rendered value
+            output.gsub!(tag, tag_out)
+         end
+
+         # freeze and return output
+         output.freeze
+         output
+      end
+   end
+end

data/lib/mime-components/extensions/erb.rb

@@ -0,0 +1,42 @@
+# Erubi templating support.
+# frozen_string_literal: true
+
+
+module Mime
+   # A component wrapped around a compiled Erubi template.
+   class ERBComponent < Component
+      @erubi_engine = nil
+      # Create a new Mime component from an Erubi template. XML arguments will be passed to this
+      # template as an instance variable named `@args`, and variables will be set as instance
+      # varibles (for example, ':my_variable' would be accessible as '@my_variable').
+      def initialize(name, template)
+         # pre-compile template
+         @erubi_engine = Erubi::Engine.new(template, freeze: true, escape: true)
+         # execute template in a new context with few variables
+         super(name) do |args, vars|
+            # george is a sandbox instance that can only access variables and arguments
+            # passed to the template by this component.
+            george = Object.new
+            # pass arguments
+            george.instance_variable_set(:@args, args)
+            # pass global variables
+            vars.each { |var| george.instance_variable_set(:"@#{var[0]}", var[1]) }
+            # pass instance variables
+            instance_variables.each { |var| george.instance_variable_set(var, instance_variable_get(var)) }
+            # evaluate template as george :)
+            george.instance_eval(@erubi_engine.src)
+         end
+      end
+   end
+
+   class Engine
+      # Render an ERB template with Erubi, then post-process with this engine.
+      # @param template(Erubi::Engine) rendered ERB template
+      # @param vars(Hash) map of variables to send to template
+      # @return (String) rendered template
+      def erb(template, vars)
+         template_output = instance_eval(template.src)
+         render(template_output, vars)
+      end
+   end
+end

data/lib/mime-components.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+# Let it be known that I do not like Gems
+
+# Mime is a component (not templating!) system based on XML tags (components).
+module Mime
+   require 'erubi'
+   require 'nokogiri'
+   require_relative 'mime-components/components/builtins'
+   require_relative 'mime-components/components/components'
+   require_relative 'mime-components/engine/engine'
+   require_relative 'mime-components/engine/globals'
+   require_relative 'mime-components/engine/render'
+   require_relative 'mime-components/extensions/erb'
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: mime-components
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- talkingsodapop
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-11-08 00:00:00.000000000 Z
+dependencies: []
+description: A post-processing component system
+email: tobskep@aol.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mime-components.rb
+- lib/mime-components/components/builtins.rb
+- lib/mime-components/components/components.rb
+- lib/mime-components/engine/engine.rb
+- lib/mime-components/engine/globals.rb
+- lib/mime-components/engine/render.rb
+- lib/mime-components/extensions/erb.rb
+homepage: https://rubygems.org/gems/mime-components
+licenses:
+- LGPL-2.1-or-later
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.16
+signing_key:
+specification_version: 4
+summary: Mime
+test_files: []