RubyGems - lifer - Versions diffs - 0.2.0 → 0.3.0 - Mend

lifer 0.2.0 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (60) hide show

checksums.yaml +4 -4
data/.github/workflows/main.yml +1 -1
data/.gitignore +1 -0
data/CHANGELOG.md +26 -0
data/Gemfile +9 -0
data/Gemfile.lock +110 -25
data/LICENSE +18 -0
data/README.md +79 -14
data/Rakefile +2 -4
data/bin/lifer +4 -2
data/lib/lifer/brain.rb +171 -21
data/lib/lifer/builder/html/from_erb.rb +92 -0
data/lib/lifer/builder/html/from_liquid/drops/collection_drop.rb +40 -0
data/lib/lifer/builder/html/from_liquid/drops/collections_drop.rb +40 -0
data/lib/lifer/builder/html/from_liquid/drops/entry_drop.rb +63 -0
data/lib/lifer/builder/html/from_liquid/drops/frontmatter_drop.rb +45 -0
data/lib/lifer/builder/html/from_liquid/drops/settings_drop.rb +42 -0
data/lib/lifer/builder/html/from_liquid/drops.rb +15 -0
data/lib/lifer/builder/html/from_liquid/filters.rb +27 -0
data/lib/lifer/builder/html/from_liquid/layout_tag.rb +67 -0
data/lib/lifer/builder/html/from_liquid.rb +116 -0
data/lib/lifer/builder/html.rb +107 -51
data/lib/lifer/builder/rss.rb +113 -0
data/lib/lifer/builder/txt.rb +60 -0
data/lib/lifer/builder.rb +100 -1
data/lib/lifer/cli.rb +105 -0
data/lib/lifer/collection.rb +87 -8
data/lib/lifer/config.rb +159 -31
data/lib/lifer/dev/response.rb +61 -0
data/lib/lifer/dev/router.rb +44 -0
data/lib/lifer/dev/server.rb +97 -0
data/lib/lifer/entry/html.rb +39 -0
data/lib/lifer/entry/markdown.rb +162 -0
data/lib/lifer/entry/txt.rb +41 -0
data/lib/lifer/entry.rb +142 -41
data/lib/lifer/message.rb +58 -0
data/lib/lifer/selection/all_markdown.rb +16 -0
data/lib/lifer/selection/included_in_feeds.rb +15 -0
data/lib/lifer/selection.rb +79 -0
data/lib/lifer/shared/finder_methods.rb +35 -0
data/lib/lifer/shared.rb +6 -0
data/lib/lifer/templates/cli.txt.erb +10 -0
data/lib/lifer/templates/config.yaml +77 -0
data/lib/lifer/templates/its-a-living.png +0 -0
data/lib/lifer/templates/layout.html.erb +1 -1
data/lib/lifer/uri_strategy/pretty.rb +14 -6
data/lib/lifer/uri_strategy/pretty_root.rb +24 -0
data/lib/lifer/uri_strategy/pretty_yyyy_mm_dd.rb +32 -0
data/lib/lifer/uri_strategy/root.rb +17 -0
data/lib/lifer/uri_strategy/simple.rb +10 -6
data/lib/lifer/uri_strategy.rb +46 -6
data/lib/lifer/utilities.rb +117 -0
data/lib/lifer/version.rb +3 -0
data/lib/lifer.rb +130 -23
data/lifer.gemspec +12 -6
data/locales/en.yml +54 -0
metadata +142 -9
data/lib/lifer/layout.rb +0 -25
data/lib/lifer/templates/config +0 -4
data/lib/lifer/uri_strategy/base.rb +0 -15

data/lib/lifer/builder/html/from_erb.rb ADDED Viewed

@@ -0,0 +1,92 @@
+require "erb"
+class Lifer::Builder::HTML
+  # If the HTML builder is given an ERB template, it uses this class to parse
+  # the ERB into HTML. Lifer project metadata is provided as context. For
+  # example:
+  #
+  #     <html>
+  #       <head>
+  #         <title><%= my_collection.name %></title>
+  #       </head>
+  #
+  #       <body>
+  #         <h1><%= my_collection.name %></h1>
+  #
+  #         <% my_collection.entries.each do |entry| %>
+  #           <section>
+  #             <h2><%= entry.title %></h2>
+  #             <p><%= entry.summary %></p>
+  #             <a href="<%= entry.permalink %>">Read more</a>
+  #           </section>
+  #         <% end %>
+  #       </body>
+  #     </html>
+  #
+  class FromERB
+    class << self
+      # Build and render an entry.
+      #
+      # @param entry [Lifer::Entry] The entry to be rendered.
+      # @return [String] The rendered entry.
+      def build(entry:)
+        new(entry: entry).render
+      end
+    end
+    # Reads the entry as ERB, given our renderer context (see the documentation
+    # for `#build_binding_context`) and renders the production-ready entry.
+    #
+    # @return [String] The rendered entry.
+    def render
+      ERB.new(File.read layout_file).result context
+    end
+    private
+    attr_reader :context, :entry, :layout_file
+    # @private
+    # @param entry [Lifer::Entry] The entry to be rendered.
+    # @return [void]
+    def initialize(entry:)
+      @entry = entry
+      @layout_file = entry.collection.layout_file
+      @context = build_binding_context
+    end
+    # @private
+    # Each collection name is provided as a local variable. This allows you to
+    # make ERB files that contain loops like:
+    #
+    #     <% my_collection_name.entries.each do |entry| %>
+    #       <%= entry.title %>
+    #     <% end %>
+    #
+    # @return [Binding] A binding object with preset context from the current
+    #   Lifer project and in-scope entry.
+    def build_binding_context
+      binding.tap { |binding|
+        Lifer.collections.each do |collection|
+          binding.local_variable_set collection.name, collection
+          collection_context_class.define_method(collection.name) do
+            collection
+          end
+        end
+        collections = collection_context_class.new Lifer.collections.to_a
+        binding.local_variable_set :collections, collections
+        binding.local_variable_set :settings, Lifer.settings
+        binding.local_variable_set :content,
+          ERB.new(entry.to_html).result(binding)
+      }
+    end
+    # @private
+    def collection_context_class
+      @collection_context_class ||= Class.new(Array) do end
+    end
+  end
+end

data/lib/lifer/builder/html/from_liquid/drops/collection_drop.rb ADDED Viewed

@@ -0,0 +1,40 @@
+module Lifer::Builder::HTML::FromLiquid::Drops
+  # This drop allows users to access Lifer collection information from within
+  # Liquid templates. Example:
+  #
+  #     {{ collection.name }}
+  #
+  #     {% for entries in collection.entries %}
+  #       {{ entry.title }}
+  #     {% endfor %}
+  #
+  class CollectionDrop < Liquid::Drop
+    attr_accessor :lifer_collection
+    def initialize(lifer_collection) = (@lifer_collection = lifer_collection)
+    # The collection name.
+    #
+    # @return [Symbol]
+    def name = (@name ||= lifer_collection.name)
+    # Gets all entries in a collection and converts them to entry drops that can
+    # be accessed in Liquid templates. Example:
+    #
+    #     {% for entry in collections.root.entries %}
+    #       {{ entry.title }}
+    #     {% endfor %}
+    #
+    # @return [Array<EntryDrop>]
+    def entries
+      @entries ||= lifer_collection.entries.map {
+        EntryDrop.new _1, collection: self
+      }
+    end
+    # The collection's layout file path.
+    #
+    # @return [String] The path to the layout file.
+    def layout_file = (@lifer_collection.layout_file)
+  end
+end

data/lib/lifer/builder/html/from_liquid/drops/collections_drop.rb ADDED Viewed

@@ -0,0 +1,40 @@
+module Lifer::Builder::HTML::FromLiquid::Drops
+  # This drop allows users to iterate over their Lifer collections in Liquid
+  # templates. Example:
+  #
+  #     {% for collection in collections %}
+  #       {{ collection.name }}
+  #     {% endfor %}
+  #
+  class CollectionsDrop < Liquid::Drop
+    attr_accessor :collections
+    def initialize
+      @collections = Lifer.collections.map { CollectionDrop.new _1 }
+    end
+    # Allow collections to be iterable in Liquid templates.
+    #
+    # @yield [CollectionDrop] All available collection drops.
+    def each(&block)
+      collections.each(&block)
+    end
+    # Allow collections to be rendered as an array in Liquid templates.
+    #
+    # @return [Array]
+    def to_a = @collections
+    # Dynamically define Liquid accessors based on the Lifer project's
+    # collection names. For example, to get the root collection's name:
+    #
+    #    {{ collections.root.name }}
+    #
+    # @param arg [String] The name of a collection.
+    # @return [CollectionDrop, NilClass]
+    def liquid_method_missing(arg)
+      collections.detect { arg.to_sym == _1.name }
+    end
+  end
+end

data/lib/lifer/builder/html/from_liquid/drops/entry_drop.rb ADDED Viewed

@@ -0,0 +1,63 @@
+module Lifer::Builder::HTML::FromLiquid::Drops
+  # This drop represents a Lifer entry and allows users to access entry
+  # metadata and content in Liquid templates.
+  #
+  # Example usage:
+  #
+  #     <h1>{{ entry.title }}</h1>
+  #     <small>Published on <datetime>{{ entry.date }}</datetime></small>
+  #
+  class EntryDrop < Liquid::Drop
+    attr_accessor :lifer_entry, :collection
+    def initialize(lifer_entry, collection:)
+      @lifer_entry = lifer_entry
+      @collection = collection
+    end
+    # The entry author (or authors).
+    #
+    # @return [String]
+    def author = authors
+    # The entry authors (or author).
+    #
+    # @return [String]
+    def authors = (@authors ||= lifer_entry.authors.join(", "))
+    # The entry content.
+    #
+    # @return [String]
+    def content = (@content ||= lifer_entry.to_html)
+    # The entry date (as a string).
+    #
+    # @return [String]
+    def date = (@date ||= lifer_entry.date)
+    # The entry frontmatter data.
+    #
+    # @return [FrontmatterDrop]
+    def frontmatter = (@frontmatter ||= FrontmatterDrop.new(lifer_entry))
+    # The path to the entry.
+    #
+    # @return [String] The path to the entry.
+    def path = (@path ||= lifer_entry.path)
+    # The entry permalink.
+    #
+    # @return [String] The entry permalink.
+    def permalink = (@permalink ||= lifer_entry.permalink)
+    # The summary of the entry.
+    #
+    # @return [String] The summary of the entry.
+    def summary = (@summary ||= lifer_entry.summary)
+    # The entry title.
+    #
+    # @return [String] The entry title.
+    def title = (@title ||= lifer_entry.title)
+  end
+end

data/lib/lifer/builder/html/from_liquid/drops/frontmatter_drop.rb ADDED Viewed

@@ -0,0 +1,45 @@
+module Lifer::Builder::HTML::FromLiquid::Drops
+  # Markdown entries may contain YAML frontmatter. And if they do, we need a way
+  # for the Liquid templates to access that data.
+  #
+  # Example usage:
+  #
+  #     {{ entry.frontmatter.any_available_frontmatter_key }}
+  #
+  class FrontmatterDrop < Liquid::Drop
+    def initialize(entry)
+      @frontmatter = Lifer::Utilities.stringify_keys(entry.frontmatter)
+    end
+    # Ensure that the frontmatter can be output wholly into a rendered template
+    # if need be.
+    #
+    # @return [String]
+    def to_s = frontmatter.to_json
+    # Dynamically define Liquid accessors based on the Lifer settings object.
+    # For example, to get a collections URI strategy:
+    #
+    #    {{ settings.my_collection.uri_strategy }}
+    #
+    # @param arg [String] The name of a collection.
+    # @return [CollectionDrop, NilClass]
+    def liquid_method_missing(arg)
+      value = frontmatter[arg]
+      if value.is_a?(Hash)
+        as_drop(value)
+      elsif value.is_a?(Array) && value.all? { _1.is_a?(Hash) }
+        value.map { as_drop(_1) }
+      else
+        value
+      end
+    end
+    private
+    attr_reader :frontmatter
+    def as_drop(hash) = self.class.new(hash)
+  end
+end

data/lib/lifer/builder/html/from_liquid/drops/settings_drop.rb ADDED Viewed

@@ -0,0 +1,42 @@
+module Lifer::Builder::HTML::FromLiquid::Drops
+  # This drop allows users to access the current Lifer project settings from
+  # Liquid templates. Example:
+  #
+  #     {{ settings.my_collection.uri_strategy }}
+  #
+  class SettingsDrop < Liquid::Drop
+    def initialize(settings = Lifer.settings)
+      @settings = Lifer::Utilities.stringify_keys(settings)
+    end
+    # Ensure the settings tree can be output to a rendered template if need be.
+    #
+    # @return [String]
+    def to_s = settings.to_json
+    # Dynamically define Liquid accessors based on the Lifer settings object.
+    # For example, to get a collections URI strategy:
+    #
+    #    {{ settings.my_collection.uri_strategy }}
+    #
+    # @param arg [String] The name of a collection.
+    # @return [CollectionDrop, NilClass]
+    def liquid_method_missing(arg)
+      value = settings[arg]
+      if value.is_a?(Hash)
+        as_drop(value)
+      elsif value.is_a?(Array) && value.all? { _1.is_a?(Hash) }
+        value.map { as_drop(_1) }
+      else
+        value
+      end
+    end
+    private
+    attr_accessor :settings
+    def as_drop(hash) = self.class.new(hash)
+  end
+end

data/lib/lifer/builder/html/from_liquid/drops.rb ADDED Viewed

@@ -0,0 +1,15 @@
+class Lifer::Builder::HTML::FromLiquid
+  # This module contains all of custom Liquid data drops used in order to render
+  # Lifer entries.
+  #
+  # For more information about drops, see the `liquid` gem source code. (The
+  # docs are awful.)
+  #
+  module Drops; end
+end
+require_relative "drops/collection_drop"
+require_relative "drops/collections_drop"
+require_relative "drops/entry_drop"
+require_relative "drops/frontmatter_drop"
+require_relative "drops/settings_drop"

data/lib/lifer/builder/html/from_liquid/filters.rb ADDED Viewed

@@ -0,0 +1,27 @@
+# This module provides Liquid filters to be used within Liquid templates.
+# In many cases these utilities exist to be pseudo-compatible with Jekyll.
+#
+# For example, a filter (in a Liquid template):
+#
+#     {{ entry.date | date_to_xmlschema }}
+#
+module Lifer::Builder::HTML::FromLiquid::Filters
+  # @!visibility private
+  Util = Lifer::Utilities
+  # Converts date to ISO-8601 format.
+  #
+  # @param input [String] A date string, I hope.
+  # @return [String] The transformed date string.
+  def date_to_xmlschema(input) = Util.date_as_iso8601(input)
+  # Transforms a string to kabab-case.
+  #
+  # For example:
+  #
+  #     Before: hello_there
+  #     After: hello-there
+  # @param input [String] A string.
+  # @return [String] The transformed string.
+  def handleize(input) = Util.handleize(input)
+end

data/lib/lifer/builder/html/from_liquid/layout_tag.rb ADDED Viewed

@@ -0,0 +1,67 @@
+class Lifer::Builder::HTML::FromLiquid
+  # Note that if you want to learn more about the shape of this class, check out
+  # `Liquid::Block` in the `liquid` gem.
+  #
+  # The layout tag is a bit magic. The idea here is to emulate how Jekyll
+  # handles `layout:` YAML frontmatter within entries to change the normal
+  # parent layout to an override parent layout--but without the need for
+  # frontmatter.
+  #
+  # The reason we took this strategy was to avoid pre-processing every entry for
+  # frontmatter when we didn't need to. Maybe in the long run this was a bad
+  # call? I don't know.
+  #
+  # Example usage (from a Liquid template):
+  #
+  #     {% layout "path/to/my_liquid_layout_template" %}
+  #
+  # (The required `endlayout` tag will be appended to the end of the file
+  # on render if you do not insert it yourself.
+  #
+  class LayoutTag < Liquid::Block
+    # The name of the tag in Liquid templates, `layout`.
+    #
+    NAME = :layout
+    # The end name of the tag in Liquid templates, `endlayout`.
+    #
+    ENDNAME = ("end%s" % NAME).to_sym
+    def initialize(layout, path, options)
+      @path = path.delete("\"").strip
+      super
+    end
+    # A layout tag wraps an entire document and outputs it inside of whatever
+    # the `@layout` is. This lets a child document specify a parernt layout!
+    # Very confusing stuff.
+    #
+    # @param context [Liquid::Context] All of the context of the Liquid
+    #   document that would be rendered.
+    # @return [String] A rendered document.
+    def render(context)
+      document_context = context.environments.first
+      parse_options = document_context["parse_options"]
+      liquid_file_system = parse_options[:environment].file_system
+      render_options = document_context["render_options"]
+      current_layout_file = File
+        .read(document_context["entry"]["collection"]["layout_file"])
+        .gsub(/\{%\s*#{tag_name}.+%\}/, "")
+      content_with_layout = Liquid::Template
+        .parse(current_layout_file, error_mode: :strict)
+        .render(document_context, render_options)
+      Liquid::Template
+        .parse(
+          liquid_file_system.read_template_file(@path),
+          **parse_options
+        )
+        .render(
+          document_context.merge({"content" => content_with_layout}),
+          **render_options
+        )
+    end
+  end
+end

data/lib/lifer/builder/html/from_liquid.rb ADDED Viewed

@@ -0,0 +1,116 @@
+require "liquid"
+require_relative "from_liquid/drops"
+require_relative "from_liquid/filters"
+require_relative "from_liquid/layout_tag"
+class Lifer::Builder::HTML
+  # If the HTML builder is given a Liquid template, it uses this class to parse
+  # the Liquid into HTML. Lifer project metadata is provided as context. For
+  # example:
+  #
+  #     <html>
+  #       <head>
+  #         <title>{{ collections.my_collection.name }}</title>
+  #       </head>
+  #
+  #       <body>
+  #         <h1>{{ collections.my_collection.name }}</h1>
+  #
+  #         {% for entry in collections.my_collection.entries %}
+  #           <section>
+  #             <h2>{{ entry.title }}</h2>
+  #             <p>{{ entry.summary }}</p>
+  #             <a href="{{ entry.permalink }}">Read more</a>
+  #           </section>
+  #         {% endfor %}
+  #       </body>
+  #     </html>
+  #
+  class FromLiquid
+    class << self
+      # Render and build a Lifer entry.
+      #
+      # @param entry [Lifer::Entry] The entry to render.
+      # @return [String] The rendered entry, ready for output.
+      def build(entry:) = new(entry:).render
+    end
+    attr_accessor :entry, :layout_file
+    # Reads the entry as Liquid, given our document context, and renders
+    # an entry.
+    #
+    # @return [String] The rendered entry.
+    def render
+      document_context = context.merge!(
+        "content" => Liquid::Template
+          .parse(entry.to_html, **parse_options)
+          .render(context, **render_options)
+      )
+      Liquid::Template
+        .parse(layout, **parse_options)
+        .render(document_context, **render_options)
+    end
+    private
+    def initialize(entry:)
+      @entry = entry
+      @layout_file = entry.collection.layout_file
+    end
+    def context
+      collections = Drops::CollectionsDrop.new
+      collection = collections
+        .to_a
+        .detect { _1.name.to_sym == entry.collection.name }
+      {
+        "collections" => collections,
+        "entry" => Drops::EntryDrop.new(entry, collection:),
+        "parse_options" => parse_options,
+        "render_options" => render_options,
+        "settings" => Drops::SettingsDrop.new
+      }
+    end
+    # @private
+    # It's possible for the provided layout to request a parent layout, which
+    # makes this method a bit complicated.
+    #
+    # @return [String] A Liquid layout document, ready for parsing.
+    def layout
+      contents = File.read layout_file
+      return contents unless contents.match?(/\{%\s*#{LayoutTag::NAME}.*%\}/)
+      contents + "\n{% #{LayoutTag::ENDNAME} %}"
+    end
+    def liquid_environment
+      @liquid_environment ||= Liquid::Environment.build do |environment|
+        environment.file_system =
+          Liquid::LocalFileSystem.new(Lifer.root, "%s.html.liquid")
+        environment.register_filter Lifer::Builder::HTML::FromLiquid::Filters
+        environment.register_tag "layout",
+          Lifer::Builder::HTML::FromLiquid::LayoutTag
+      end
+    end
+    def parse_options
+      {
+        environment: liquid_environment,
+        error_mode: :strict
+      }
+    end
+    def render_options
+      {
+        strict_variables: true,
+        strict_filters: true
+      }
+    end
+  end
+end