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

lifer 0.2.0 → 0.3.0

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