distorted-jekyll 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5eaf5c713e61dd6cea6fee1d1cb031b7ec25331e8cdeb9aa79f1ea96c61d94a8
-  data.tar.gz: '068625124864b575107596d9b91761171eecdb76cdaf8f34a66fa37f4d34b69e'
+  metadata.gz: a5fe548492f52f0b4bb138fbd93ca2fb127f53baf7a3657d73aefc904c22a51b
+  data.tar.gz: 2444637db29356d306f2e1e31a41b0fe9c758574d77bc40d691f51c0ab514af5
 SHA512:
-  metadata.gz: 4b55e4771aadea12c70adf95995432b4cff70cf0548b06ae76dcb8a55f11de273531a3f2def6be56de9b7043a9f752a6f7d7cc1f66299475409ac269be80dc77
-  data.tar.gz: 4c152988ef67bd5717429578de241169b13f7ffee38cb255979184e2b3cdf4d551d1b50d9c4472ca98bbb9695d8892f09b0b2d9d0e2a02deeeb1dd54d8415f66
+  metadata.gz: 6aff9df826afc000fea96df60f7a4305195ea4518e5c96a1c38b5899e72d47860d7866cbad2d5184cd820221d8d15bc86ed946a278345773972b5bdaccaf0008
+  data.tar.gz: 26efca75634c2c45d9b2d01116b96f64585b1c3a00e98471d6659adeeb0d545224911af048faef4df5afc228923f4ea44ebe2eb6e055ff2217ecf73ea6ed64d2

data/README.md

@@ -156,7 +156,7 @@ Clone the DistorteD repository and modify your Jekyll `Gemfile` to refer to your
 gem 'distorted-jekyll', :path => '~/repos/DistorteD/DistorteD-Jekyll/'[, :branch => 'NEW-SENSATION']
 ```
 
-The `DistorteD-Jekyll` Gem will automatically use its local sibling `DistorteD-Ruby` Gem if used in this way.
+The `DistorteD-Jekyll` Gem will automatically use its local sibling `DistorteD-Floor` Gem if used in this way.
 
 ## License
 

data/lib/distorted-jekyll.rb

@@ -40,10 +40,6 @@ if [
   Hash.method_defined?(:transform_keys),  # 2.5
   Enumerable.method_defined?(:filter_map),  # 2.7
 ].all?
-  # Monkey-patch preferred_extensions iff we're going to load.
-  # My JPEGs coming out with a '.jpeg' file extension just annoys me so much.
-  require 'distorted/monkey_business/mnemoniq'
-
   # Monkey-patch Jekyll::Cleaner to not nuke DistorteD-generated variations
   # for our media files. This makes DistorteD fast!
   require 'distorted-jekyll/monkey_business/jekyll/cleaner'

data/lib/distorted-jekyll/13th-style.rb

@@ -35,7 +35,7 @@ module Jekyll
       end
 
       def render_to_output_buffer(context, output)
-        css_filename = File.join(File.dirname(__FILE__), 'template'.freeze, '13th-style.css'.freeze)
+        css_filename = File.join(File.dirname(__FILE__), '13th-style.css'.freeze)
 
         # Use IO.foreach() to call a block on each line of our template file
         # without slurping the entire file into memory like File.read() / File.readlines()

data/lib/distorted-jekyll/_config_default.yml

@@ -6,34 +6,16 @@
 # so duplicate Array values will be compacted!
 
 standard_image: &standard_image
-  - tag: full
-    crop: none
-  - tag: small
-    width: 400
-    height: 400
-    media: "(max-width: 400px)"
-  - tag: medium
-    width: 800
-    height: 800
-    media: "(min-width: 400px) and (max-width: 800px)"
-  - tag: large
-    width: 1500
-    height: 1500
-    media: "(min-width: 800px)"
-
+  - crop: none
+    breaks: [333, 555, 777, 1111]
 
 distorted:
 
-  # Liquid template caching is default as of Jekyll 4.0,
-  # but it can be disabled if needed.
-  # I just can't think of when it would be needed :)
-  cache_templates: true
-
   # Should unrecognized media-types fall back to a bare
   # <img> tag around the original media file?
   # If not, the site build will fail when an unrecognized
   # file is encountered.
-  last_resort: true
+  never_let_you_down: true
 
   # Configure DistorteD format changes by media_type, then by sub_type.
   # The list of target formats is plain text, media_type/sub_type.

data/lib/distorted-jekyll/invoker.rb

@@ -1,259 +1,234 @@
 # Our custom Exceptions
 require 'distorted/error_code'
 
+# Molecule loading and plugging functionality
+require 'distorted/invoker'
+
 # MIME::Typer
 require 'distorted/checking_you_out'
 
 # Configuration-loading code
-require 'distorted-jekyll/floor'
+require 'distorted-jekyll/the_setting_sun'
 require 'distorted-jekyll/static_state'
 
-# Media-type drivers
-require 'distorted-jekyll/molecule/font'
-require 'distorted-jekyll/molecule/image'
-require 'distorted-jekyll/molecule/text'
-require 'distorted-jekyll/molecule/pdf'
-require 'distorted-jekyll/molecule/svg'
-require 'distorted-jekyll/molecule/video'
-require 'distorted-jekyll/molecule/lastresort'
-
-# Set.to_hash
-require 'distorted/monkey_business/set'
-
 # Slip in and out of phenomenon
 require 'liquid/tag'
 require 'liquid/tag/parser'
+require 'distorted-jekyll/liquid_liquid'
+
+require 'distorted-jekyll/media_molecule'
 
 # Explicitly required for l/t/parser since a1cfa27c27cf4d4c308da2f75fbae88e9d5ae893
 require 'shellwords'
 
 # Set is in stdlib but is not in core.
 require 'set'
+# Set.to_hash
+require 'distorted/monkey_business/set'
 
 # I mean, this is why we're here, right?
 require 'jekyll'
 
 
-module Jekyll
-  module DistorteD
-    class Invoker < Liquid::Tag
-
-      GEM_ROOT = File.dirname(__FILE__).freeze
-
-      # Mix in config-loading methods.
-      include Jekyll::DistorteD::Floor
-      include Jekyll::DistorteD::StaticState
-
-      # Enabled media_type drivers. These will be attempted back to front.
-      # TODO: Make this configurable.
-      MEDIA_MOLECULES = [
-        Jekyll::DistorteD::Molecule::LastResort,
-        Jekyll::DistorteD::Molecule::Font,
-        Jekyll::DistorteD::Molecule::Text,
-        Jekyll::DistorteD::Molecule::PDF,
-        Jekyll::DistorteD::Molecule::SVG,
-        Jekyll::DistorteD::Molecule::Video,
-        Jekyll::DistorteD::Molecule::Image,
-      ]
-      # Reduce the above to a Hash of Sets of MediaMolecules-per-Type, keyed by Type.
-      TYPE_MOLECULES = MEDIA_MOLECULES.reduce(
-        Hash.new{|hash, key| hash[key] = Set[]}
-      ) { |types, molecule|
-        if molecule.const_defined?(:LOWER_WORLD)
-          molecule.const_get(:LOWER_WORLD).each { |t|
-            types.update(t => Set[molecule]) { |k,o,n| o.merge(n) }
-          }
-        end
-        types
-      }
+class Jekyll::DistorteD::Invoker < Liquid::Tag
 
-      # Any any attr value will get a to_sym if shorter than this
-      # totally arbitrary length, or if the attr key is in the plugged
-      # Molecule's set of attrs that take only a defined set of values.
-      # My chosen boundary length fits all of the outer-limit tag names I use,
-      # like 'medium'. It fits the longest value of Vips::Interesting too,
-      # though `crop` will be symbolized based on the other condition.
-      ARBITRARY_ATTR_SYMBOL_STRING_LENGTH_BOUNDARY = 13
-
-
-      # 𝘏𝘖𝘞 𝘈𝘙𝘌 𝘠𝘖𝘜 𝘎𝘌𝘕𝘛𝘓𝘌𝘔𝘌𝘕 ！！
-      def initialize(tag_name, arguments, liquid_options)
-        super
-        # Tag name as given to Liquid::Template.register_tag().
-        @tag_name = tag_name.to_sym
-
-        # Liquid leaves argument parsing totally up to us.
-        # Use the envygeeks/liquid-tag-parser library to wrangle them.
-        parsed_arguments = Liquid::Tag::Parser.new(arguments)
-
-        # Filename is the only non-keyword argument our tag should ever get.
-        # It's spe-shul and gets its own definition outside the attr loop.
-        if parsed_arguments.key?(:src)
-          @name = parsed_arguments.delete(:src)
-        else
-          @name = parsed_arguments.delete(:argv1)
-        end
-        @liquid_liquid = parsed_arguments.select{ |attr, val|
-          not [nil, ''.freeze].include?(val)
-        }.transform_keys { |attr|
-          attr.length <= ARBITRARY_ATTR_SYMBOL_STRING_LENGTH_BOUNDARY ? attr.to_sym : attr.freeze
-        }.transform_values { |val|
-          if val.respond_to?(:length)
-            val.length <= ARBITRARY_ATTR_SYMBOL_STRING_LENGTH_BOUNDARY ? val.to_sym : val.freeze
-          else
-            val
-          end
-        }
+  GEM_ROOT = File.dirname(__FILE__).freeze
 
-        # If we didn't get one of the two above options there is nothing we
-        # can do but bail.
-        unless @name
-          raise "Failed to get a usable filename from #{arguments}"
-        end
+  include Jekyll::DistorteD::Setting       # Config-loading methods.
+  include Jekyll::DistorteD::StaticState   # Jekyll::StaticFile impersonation methods.
+  include Cooltrainer::DistorteD::Invoker  # Instance-setup methods.
 
-      end
 
-      # Returns a Set of DD MIME::Types descriving our file,
-      # optionally falling through to a plain file copy.
-      def type_mars
-        @type_mars ||= begin
-          mime = CHECKING::YOU::OUT(@name)
-          if mime.empty?
-            if Jekyll::DistorteD::Floor::config(Jekyll::DistorteD::Floor::CONFIG_ROOT, :last_resort)
-              mime = Jekyll::DistorteD::Molecule::LastResort::LOWER_WORLD
-            end
-          end
-          mime
-        end
-      end
+  # 𝘏𝘖𝘞 𝘈𝘙𝘌 𝘠𝘖𝘜 𝘎𝘌𝘕𝘛𝘓𝘌𝘔𝘌𝘕 ！！
+  def initialize(tag_name, arguments, liquid_options)
+    super
+    # Tag name as given to Liquid::Template.register_tag().
+    @tag_name = tag_name.to_sym
 
-      # Return any arguments given by the user to our Liquid tag.
-      # This method name is generic across all DD entrypoints so it can be
-      # referenced from lower layers in the pile.
-      def user_arguments
-        @liquid_liquid || Hash[]
-      end
+    # Liquid leaves argument parsing totally up to us.
+    # Use the envygeeks/liquid-tag-parser library to wrangle them.
+    parsed_arguments = Liquid::Tag::Parser.new(arguments)
 
-      # Decides which MediaMolecule is most appropriate for our file and returns it.
-      def media_molecule
-        available_molecules = TYPE_MOLECULES.keys.to_set & type_mars
-        # TODO: Handle multiple molecules for the same file
-        case available_molecules.length
-        when 0
-          raise MediaTypeNotImplementedError.new(@name)
-        when 1
-          return TYPE_MOLECULES[available_molecules.first].first
-        end
-      end
+    # Filename is the only non-keyword argument our tag should ever get.
+    # It's spe-shul and gets its own definition outside the attr loop.
+    if parsed_arguments.key?(:src)
+      @name = parsed_arguments.delete(:src)
+    else
+      @name = parsed_arguments.delete(:argv1)
+    end
 
-      def plug
-        unless self.singleton_class.instance_variable_defined?(:@media_molecule)
-          self.singleton_class.instance_variable_set(:@media_molecule, media_molecule)
-          self.singleton_class.prepend(media_molecule)
-          Jekyll.logger.info(@name, "Plugging #{media_molecule}")
-        end
+    # Load contextual variables for abstract()
+    @tag_arguments = parsed_arguments.select{ |attr, val|
+      not [nil, ''.freeze].include?(val)
+    }.transform_keys(&:to_sym).transform_values { |val|
+      case val
+      when 'true' then true
+      when 'false' then false
+      when String then (val.length <= Jekyll::DistorteD::ARBITRARY_ATTR_SYMBOL_STRING_LENGTH_BOUNDARY) ? val.to_sym : val.freeze
+      else val
       end
+    }
 
-      # Called by Jekyll::Renderer
-      # https://github.com/jekyll/jekyll/blob/HEAD/lib/jekyll/renderer.rb
-      # https://jekyllrb.com/tutorials/orderofinterpretation/
-      def render(context)
-        plug
-        render_to_output_buffer(context, '')
-      end
+    # If we didn't get one of the two above options there is nothing we
+    # can do but bail.
+    unless @name
+      raise "Failed to get a usable filename from #{arguments}"
+    end
+
+  end
 
-      # A future Liquid version (5.0?) will call this function directly
-      # instead of calling render()
-      def render_to_output_buffer(context, output)
-        plug
-        # Get Jekyll Site object back from tag rendering context registers so we
-        # can get configuration data and path information from it and
-        # then pass it along to our StaticFile subclass.
-        @site = context.registers[:site]
-
-        # The rendering context's `first` page will be the one that invoked us.
-        page_data = context.environments.first['page'.freeze]
-
-        #
-        # Our subclass' additional args:
-        # dest - The String path to the generated `url` folder of the page HTML output
-        @base = @site.source
-
-        # `relative_path` doesn't seem to always exist, but `path` does? idk.
-        # I was testing with `relative_path` only with `_posts`, but it broke
-        # when I invoked DD on a _page. Both have `path`.
-        @dir = File.dirname(page_data['path'.freeze])
-
-        # Every one of Ruby's `File.directory?` / `Pathname.directory?` /
-        # `FileTest.directory?` methods actually tests that path on the
-        # real filesystem, but we shouldn't look at the FS here because
-        # this function gets called when the Site.dest directory does
-        # not exist yet!
-        # Hackily look at the last character to see if the URL is a
-        # directory (like configured on cooltrainer) or a `.html`
-        # (or other extension) like the default Jekyll config.
-        # Get the dirname if the url is not a dir itself.
-        @relative_dest = page_data['url'.freeze]
-        unless @relative_dest[-1] == Jekyll::DistorteD::Floor::PATH_SEPARATOR
-          @relative_dest = File.dirname(@relative_dest)
-          # Append the trailing slash so we don't have to do it
-          # in the Liquid templates.
-          @relative_dest << Jekyll::DistorteD::Floor::PATH_SEPARATOR
-        end
-
-        # Add our new file to the list that will be handled
-        # by Jekyll's built-in StaticFile generator.
-        @site.static_files << self
-        output
+  # Returns a Set of DD MIME::Types descriving our file,
+  # optionally falling through to a plain file copy.
+  def type_mars
+    @type_mars ||= (CHECKING::YOU::OUT(path, so_deep: true) & lower_world.keys.to_set).tap { |gemini|
+      if gemini.empty? && the_setting_sun(:never_let_you_down)
+        gemini << CHECKING::YOU::OUT['application/x.distorted.never-let-you-down']
       end
+    }
+    raise MediaTypeNotImplementedError.new(@name) if @type_mars.empty?
+    @type_mars
+  end
+
+  # Returns an Array[Change] for every intended output Type
+  # and every variation (e.g. resolution, bitrate) on each Type.
+  def changes
+    # The available/desired output Media Types and (variations on those Types)
+    # are based on the input Type and the Molecule(s) available to service those Types.
+    # Use an Array, since order might be important here when generating many variations
+    # at multiple levels of the DistorteD stack, e.g. the actual files on the Floor level
+    # and the templates/markup here in the Jekyll level.
+    @changes ||= type_mars.each_with_object(Array[]) { |lower, wanted|
+      # Query our configuration for Type changes, e.g. image/webp to (image/png and image/webp).
+      # Handle empty sub_types by compacting and splatting a sub-Array.
+      change_config = the_setting_sun(:changes, *(lower.settings_paths))
+      # If there is no config, treat it as a change to the same Type as the input,
+      # otherwise instantiate each "mediatype/subtype" config String to a MIME::Type.
+      ((change_config.nil? || change_config&.empty?) ? Set[lower] : change_config.map {|t| CHECKING::YOU::OUT[t]}).each { |type|
+        # Query our configuration again for variations on each Type.
+        # For example, one single image Type may want multiple resolutions to enable responsive <picture> tags,
+        # or a single video Type may want multiple bitrates for adaptive streaming.
+        limit_breaks = the_setting_sun(:outer_limits, *(type&.settings_paths)) || Array[Hash[]]
+        # Which MediaMolecule Modules support this Type as an output? Probably just one.
+        outer_limits.keep_if { |k, v| v.has_key?(type) }.keys.each { |molecule|
+          # As before, if there is nothing in the config just treat it as a Change to
+          # the full resolution/bitrate/whatever as the input, so this will always run at least once.
+          limit_breaks.each { |limit_break|
+            # Merge each variation's config with any/all attributes given to our Liquid Tag,
+            # as well as any Jekyll Stuff™ like the relative destination path.
+            change_arguments = limit_break.merge(Hash[:dir => @relative_dest]).merge(context_arguments)
+            # Each Change will carry instance Compound data in Atom Structs so we can avoid modifying
+            # the Compound Struct with any variation-specific values since they will be reused.
+            atoms = Hash.new
+            # We will always want an Atom from every Compound even if it only carries the :default.
+            Cooltrainer::DistorteD::IMPLANTATION(:OUTER_LIMITS, molecule)&.dig(type)&.each_pair { |aka, compound|
+              next if aka != compound.element  # Skip alias Compounds since they will all be handled at once.
+              # Look for a user-given argument matching any supported alias of a Compound,
+              # and check those values against the Compound for validity.
+              atoms.store(compound.element, Cooltrainer::Atom.new(compound.isotopes.reduce(nil) { |value, isotope|
+                # TODO: valid?
+                value || change_arguments&.delete(isotope)
+              }, compound.default))
+            }
+            # After looping through the Compounds and calling :delete for matched values,
+            # this bag will be left with only the freeform non-Compound-associated arguments, if any.
+            # Separate those into arguments that match Change member names, and arguments that don't.
+            change_member_keys, atom_keys = change_arguments.keys.partition(&Cooltrainer::Change.members.method(:include?))
+            # Instantiate a no-default Atom for every remaining argument that isn't a Change member.
+            atom_keys.each { |attribute| atoms.store(attribute, Cooltrainer::Atom.new(change_arguments.delete(attribute), nil)) }
+            # Instantiate each variation of each Type into a Change struct
+            # that will handle some of the details like output-filename generation.
+            wanted.append(Cooltrainer::Change.new(type, src: @name, molecule: molecule, **change_arguments, **atoms))
+          }
+        }
+      }
+      wanted
+    }
+  end
 
-      # Generic Liquid template loader that will be used in every MediaMolecule.
-      # Callers will call `render(**{:template => vars})` on the Object returned
-      # by this method.
-      def parse_template(site: nil, name: nil)
-        site = site || @site || Jekyll.sites.first
-        begin
-          # Use a given filename, or detect one based on media-type.
-          if name.nil?
-            # e.g. Jekyll::DistorteD::Molecule::Image -> 'image.liquid'
-            name = "#{self.singleton_class.instance_variable_get(:@media_molecule).name.gsub(/^.*::/, '').downcase}.liquid".freeze
-          elsif not name.include?('.liquid'.freeze)
-            # Support filename arguments with and without file extension.
-            # The given String might already be frozen, so concatenating
-            # the extension might fail. Just set a new version.
-            name = "#{name}.liquid"
-          end
-          template = File.join(
-            self.singleton_class.const_get(:GEM_ROOT),
-            'template'.freeze,
-            name,
-          )
-
-          # Jekyll's Liquid renderer caches in 4.0+.
-          if Jekyll::DistorteD::Floor::config(
-              Jekyll::DistorteD::Floor::CONFIG_ROOT,
-              :cache_templates,
-          )
-            # file(path) is the caching function, with path as the cache key.
-            # The `template` here will be the full path, so no versions of this
-            # gem should ever conflict. For example, right now during dev it's:
-            # `/home/okeeblow/Works/DistorteD/lib/image.liquid`
-            Jekyll.logger.debug('DistorteD', "Parsing #{template} with caching renderer.")
-            site.liquid_renderer.file(template).parse(File.read(template))
-          else
-            # Re-read the template just for this piece of media.
-            Jekyll.logger.debug('DistorteD', "Parsing #{template} with fresh (uncached) renderer.")
-            Liquid::Template.parse(File.read(template))
-          end
-
-        rescue Liquid::SyntaxError => l
-          # This shouldn't ever happen unless a new version of Liquid
-          # breaks syntax compatibility with our templates somehow.
-          l.message
-        end
-      end  # parse_template
+  # Return any arguments given by the user to our Liquid tag.
+  # This method name is generic across all DD entrypoints so it can be
+  # referenced from lower layers in the pile.
+  def context_arguments
+    @tag_arguments ||= Hash[]
+  end
 
+  # Returns a context-only setting from our Liquid attributes.
+  def abstract(key)
+    context_arguments.dig(key)
+  end
 
+  # Called by Jekyll::Renderer
+  # https://github.com/jekyll/jekyll/blob/HEAD/lib/jekyll/renderer.rb
+  # https://jekyllrb.com/tutorials/orderofinterpretation/
+  def render(context)
+    # Get Jekyll Site object back from tag rendering context registers so we
+    # can get configuration data and path information from it and
+    # then pass it along to our StaticFile subclass.
+    @site = context.registers[:site]
+
+    # The rendering context's `first` page will be the one that invoked us.
+    page_data = context.environments.first['page'.freeze]
+
+    #
+    # Our subclass' additional args:
+    # dest - The String path to the generated `url` folder of the page HTML output
+    @base = @site.source
+
+    # `relative_path` doesn't seem to always exist, but `path` does? idk.
+    # I was testing with `relative_path` only with `_posts`, but it broke
+    # when I invoked DD on a _page. Both have `path`.
+    @dir = File.dirname(page_data['path'.freeze])
+
+    # Every one of Ruby's `File.directory?` / `Pathname.directory?` /
+    # `FileTest.directory?` methods actually tests that path on the
+    # real filesystem, but we shouldn't look at the FS here because
+    # this function gets called when the Site.dest directory does
+    # not exist yet!
+    # Hackily look at the last character to see if the URL is a
+    # directory (like configured on cooltrainer) or a `.html`
+    # (or other extension) like the default Jekyll config.
+    # Get the dirname if the url is not a dir itself.
+    @relative_dest = page_data['url'.freeze]
+    unless @relative_dest[-1] == Jekyll::DistorteD::PATH_SEPARATOR
+      @relative_dest = File.dirname(@relative_dest)
+      # Append the trailing slash so we don't have to do it
+      # in the Liquid templates.
+      @relative_dest << Jekyll::DistorteD::PATH_SEPARATOR
     end
+
+    # Add our new file to the list that will be handled
+    # by Jekyll's built-in StaticFile generator.
+    @site.static_files << self
+    render_to_output_buffer(context, '')
   end
+
+  # A future Liquid version (5.0?) will call this function directly
+  # instead of calling render()
+  def render_to_output_buffer(context, output)
+    roots_of_my_way = Cooltrainer::ElementalCreation.new(:root).tap { |wrapper|
+      wrapper.dan = "distorted #{changes.reduce(Set[]) { |classes, change|
+        classes.add(change.molecule&.name.split('::'.freeze).last.downcase)
+        classes.add(change.type.sub_type.to_s.split(MIME::Type::SUB_TYPE_SEPARATORS)[0])
+      }.to_a.join(' ')}"
+    }
+
+    changes&.each { |change|
+      unless self.respond_to_missing?(change.type.distorted_template_method)
+        Jekyll.logger.error(@name, "Missing template method #{change.type.distorted_template_method}")
+        raise MediaTypeOutputNotImplementedError.new(@name, type_mars, self.class.name)
+      end
+      Jekyll.logger.debug("DistorteD::#{change.type.distorted_template_method}", File.join(change.dir, change.name))
+
+      # Get an ElementalCreation Struct from the MediaMolecule's render method.
+      # WISHLIST: Remove the empty final positional Hash argument once we require a Ruby version
+      # that will not perform the implicit Change-to-Hash conversion due to Change's
+      # implementation of :to_hash. Ruby 2.7 will complain but still do the conversion,
+      # breaking downstream callers that want a Struct they can call arbitrary key methods on.
+      # https://www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-keyword-arguments-in-ruby-3-0/
+      roots_of_my_way.mad_child(self.send(change.type.distorted_template_method, change, **{}))
+    }
+
+    output << roots_of_my_way.render
+  end
+
 end