aardi 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6ee9071fced8c74f53967ad02aad285eb7d0f2604c6491531013110838df516e
+  data.tar.gz: f398bf6a84c066b43a86f29ebad0055c8b2d4a8d706f0e43769e6c2ebbec7523
+SHA512:
+  metadata.gz: d29b6326aacdecdebec15c45c2023bc3d10eec76e2a10fff2cc57604b9888c82a7e515cbd07e7e274c78dd787c39854d8dcc0b6a295164996e21526e1aad32b4
+  data.tar.gz: 6e2c8fa1284906984e908968aae84bf3a5757da235e94ffe1856a95db1aac935505259e35d3db1c6a2fab74036eff57095050cf1be2eb54ebc7a5fc9b5c6d171

data/lib/aardi/abstract_blog.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Aardi
+  class AbstractBlog
+    attr_reader :key
+
+    def metadata = (@metadata ||= {})
+
+    def mtime = children.max_by(&:mtime)&.mtime
+
+    def render
+      children.each(&:render)
+      write_target
+    end
+
+    private
+
+    def children
+      []
+    end
+
+    def write_target
+      source = PageContent.new content, title, metadata
+      PageTarget.new(source, target_path).write
+    end
+  end
+end

data/lib/aardi/abstract_feed.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Aardi
+  class AbstractFeed < AbstractBlog
+    def initialize(posts)
+      @posts = posts
+    end
+
+    def render
+      write_target
+    end
+
+    def target_path = "./#{feed_file}"
+
+    private
+
+    def children
+      @posts
+    end
+
+    def creation = children.max_by(&:creation)&.creation
+
+    def feed_url = "#{Aardi.config[:site_url]}/#{feed_file}"
+
+    def updated = children.max_by(&:updated)&.updated
+
+    def write_target
+      source = Content.new(content)
+      FileTarget.new(source, target_path).write
+    end
+  end
+end

data/lib/aardi/abstract_page_support.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Aardi
+  module AbstractPageSupport
+    attr_reader :metadata, :mtime
+
+    def parse_source(path)
+      File.open(path, encoding: "utf-8") do |file|
+        parts = file.read.rpartition("\n----\n")
+        @metadata = YAML.safe_load(parts.first, permitted_classes: [Time]) || {}
+        @src_content = parts.last
+        @mtime = file.mtime.utc
+      end
+    end
+
+    def title
+      metadata["Title"] || @src_content.split("\n").first.sub(/^#+ /, "")
+    end
+  end
+end

data/lib/aardi/archive.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Aardi
+  class Archive < AbstractBlog
+    def initialize(posts, archive_path)
+      @posts = posts
+      @archive_path = archive_path
+    end
+
+    def content
+      year_fmt = "| %<year>s | %<months>s \n"
+      month_fmt = "[&nbsp;%<count>s&nbsp;](#{Aardi.config[:site_url]}/%<archive_path>s/%<year>s/%<month>s/)"
+
+      "#{header}#{years.map { |year| year.archive_row(year_fmt, month_fmt) }.join}"
+    end
+
+    def target_path = "./#{@archive_path}/index.html"
+
+    def title = Aardi.config[:blog_archive_title]
+
+    private
+
+    def calendar
+      index = Hash.new { |hash, year| hash[year] = Year.new(year, @archive_path) }
+      @posts.each do |post|
+        index[post.year] << post
+      end
+
+      index
+    end
+
+    def children
+      years
+    end
+
+    def header
+      "# #{Aardi.config[:blog_archive_title]}
+
+||Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec|
+|---|---|---|---|---|---|---|---|---|---|---|---|---|
+"
+    end
+
+    def years
+      @years ||= calendar.values.sort_by { |date| -date.key }
+    end
+  end
+end

data/lib/aardi/atom_feed.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Aardi
+  class ATOMFeed < AbstractFeed
+    def content
+      atom_feed = Nokogiri::XML::Builder.new(encoding: "UTF-8") do
+        feed("xmlns" => "http://www.w3.org/2005/Atom") do |feed|
+          feed_details(feed)
+        end
+      end
+
+      atom_feed.to_xml
+    end
+
+    # :reek:TooManyStatements
+    def feed_details(feed)
+      aardi_config = Aardi.config
+
+      feed.author do
+        name(aardi_config[:site_author])
+      end
+
+      subnodes = {id: feed_url, link: {href: feed_url, rel: "self"},
+                  title: aardi_config[:site_title], updated: updated.iso8601}
+
+      subnodes.each do |node, value|
+        feed.public_send node, value
+      end
+
+      @posts.each do |post|
+        post_details(post, feed)
+      end
+    end
+
+    private
+
+    def feed_file
+      "index.xml"
+    end
+
+    # :reek:FeatureEnvy
+    # :reek:TooManyStatements
+    def post_details(post, feed)
+      feed.entry do
+        post_url = post.url
+
+        # For safety, must use content_ and not content:
+        content_(post.feed_snippet).type = "html"
+
+        subnodes = {id: post_url, link: {href: post_url}, title: post.title,
+                    published: post.creation.iso8601, updated: post.updated.iso8601}
+        subnodes.each do |node, value|
+          feed.public_send node, value
+        end
+      end
+    end
+  end
+end

data/lib/aardi/blog.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Aardi
+  class Blog < AbstractBlog
+    def initialize(posts_path, archive_path)
+      @posts_path = posts_path
+      @archive_path = archive_path
+    end
+
+    def posts
+      @posts ||= Dir.glob("#{@posts_path}/**/*.md").map { |post_path| Post.new(post_path) }.sort_by(&:creation)
+    end
+
+    def report_recent
+      recent_posts(:blog_recent_posts).each(&:report_field_summary)
+    end
+
+    private
+
+    def archive
+      Archive.new(posts, @archive_path)
+    end
+
+    def atom_feed
+      ATOMFeed.new(feed_posts)
+    end
+
+    def children
+      [archive, home, atom_feed, json_feed]
+    end
+
+    def feed_posts
+      recent_posts(:blog_feed_posts)
+    end
+
+    def home
+      Home.new(recent_posts(:blog_home_posts), @archive_path)
+    end
+
+    def json_feed
+      JSONFeed.new(feed_posts)
+    end
+
+    def recent_posts(conf_key)
+      posts.last(Aardi.config[conf_key]).reverse
+    end
+
+    def write_target = nil
+  end
+end

data/lib/aardi/config.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Aardi
+  class Config
+    def initialize
+      @data = {}
+    end
+
+    def [](key) = @data[key]
+
+    # :reek:TooManyStatements
+    def load(path)
+      config_hash = YAML.safe_load_file(path)
+      config_hash.transform_keys!(&:to_sym)
+      config_hash[:markup_options]&.transform_keys!(&:to_sym)
+      @data.merge!(config_hash)
+      @data.freeze
+      self
+    end
+  end
+end

data/lib/aardi/content.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Aardi
+  class Content
+    def initialize(src_content)
+      @src_content = src_content.strip
+    end
+
+    def output
+      @output ||= @src_content
+    end
+
+    def output_hash
+      @output_hash ||= Zlib.crc32(output)
+    end
+  end
+end

data/lib/aardi/content_hashes.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Aardi
+  class ContentHashes
+    def initialize(path)
+      @path = path
+      read_hashes
+    end
+
+    def [](path)
+      @hashes[path]
+    end
+
+    def []=(path, hash)
+      @hashes[path] = hash
+    end
+
+    def write
+      return if new_hashes == @original_hashes
+
+      File.write(@path, @new_hashes)
+      puts "Wrote: #{@path}\n"
+    end
+
+    private
+
+    def new_hashes
+      @new_hashes ||= @hashes.sort.map! { |path, hash| "#{path}: #{hash}\n" }.join
+    end
+
+    def read_hashes
+      @original_hashes = File.exist?(@path) ? File.read(@path) : ""
+      @hashes = @original_hashes.split("\n").to_h do |line|
+        path, hash = line.split(":", 2)
+        [path.strip, hash.to_i]
+      end
+    end
+  end
+end

data/lib/aardi/custom_renderer.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Aardi
+  class CustomRenderer < Redcarpet::Render::HTML
+    include Redcarpet::Render::SmartyPants
+
+    HEADER_SQUEEZE = /&#.*?;|&quot;|[^a-z0-9\-_]/
+
+    def header(text, header_level)
+      squeezed_text = text.squeeze(" ")
+      id = header_id(text)
+      "<h#{header_level} id=\"#{id}\">#{squeezed_text}</h#{header_level}>"
+    end
+
+    def link(link, title, content)
+      link_title = " title=\"#{title}\"" if title
+      "<a href=\"#{link}\"#{link_title}>#{content}</a>"
+    end
+
+    def reset
+      ids.clear
+    end
+
+    private
+
+    def header_id(text)
+      stub_id = header_stub_id(text)
+      count = ids[stub_id] += 1
+
+      return "#{stub_id}-#{count - 1}" if count > 1
+
+      stub_id
+    end
+
+    def header_stub_id(text)
+      text.downcase.strip.tr(" ", "-").gsub(HEADER_SQUEEZE, "").squeeze("-")
+    end
+
+    def ids
+      @ids ||= Hash.new(0)
+    end
+  end
+end

data/lib/aardi/day.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Aardi
+  # :reek:TooManyInstanceVariables
+  class Day < AbstractBlog
+    def initialize(year, month, key, archive_path)
+      @year = year
+      @month = month
+      @key = key
+      @archive_path = archive_path
+      @posts = []
+    end
+
+    def <<(post)
+      @posts << post
+    end
+
+    def content
+      @content ||= begin
+        sorted_posts = @posts.sort_by(&:creation)
+        posts_content = sorted_posts.reverse!.map!(&:content)
+        "# #{title}\n#{posts_content.join}"
+      end
+    end
+
+    def count = @posts.count
+
+    def target_path
+      "./#{@archive_path}/#{@year}/#{@month}/#{self}/index.html"
+    end
+
+    def title = date.strftime("%A, %-e %B %Y")
+
+    private
+
+    def children
+      @posts
+    end
+
+    def date = Date.new(@year.key, @month.key, @key)
+
+    def to_s = @key.to_s.rjust(2, "0")
+  end
+end

data/lib/aardi/file_target.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Aardi
+  class FileTarget
+    def initialize(src, target_path)
+      @src = src
+      @path = target_path
+      @content_hashes = Aardi.ledger[:content_hashes]
+    end
+
+    # :reek:TooManyStatements
+    def write
+      do_write = should_write?
+      update_hash
+      return unless do_write
+
+      FileUtils.mkdir_p(File.dirname(@path))
+      File.write(@path, "#{@src.output}\n")
+      puts("Wrote #{@path}")
+    end
+
+    private
+
+    def file_exists?
+      File.exist? @path
+    end
+
+    def output_hash_changed?
+      @src.output_hash != @content_hashes[@path]
+    end
+
+    def should_write?
+      return true unless file_exists?
+      return false unless output_hash_changed?
+
+      @src.output != File.read(@path).strip
+    end
+
+    def update_hash
+      @content_hashes[@path] = @src.output_hash
+    end
+  end
+end

data/lib/aardi/folder.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Aardi
+  class Folder
+    def initialize(path)
+      @path = path
+      @normalized_path = "#{path.sub(/^\./, "")}/"
+    end
+
+    def mtime = children.max_by(&:mtime).mtime
+
+    def render
+      children.each(&:render)
+
+      update_sitemap if Aardi.config[:sitemap_entries][@normalized_path]
+    end
+
+    private
+
+    def children
+      sources + folders
+    end
+
+    def folders
+      @folders ||= paths.filter_map { |path| Folder.new(path) if File.directory?(path) }
+    end
+
+    def paths
+      @paths ||= FileList["#{@path}/*"].exclude(Aardi.config[:files_to_exclude])
+    end
+
+    def sources
+      @sources ||= paths.filter_map { |path| Page.new(path) if path.end_with?(".md") }
+    end
+
+    def update_sitemap
+      # '.' is the top level so skip it since the homepage will register itself
+      Aardi.ledger[:sitemap].update_mtime(@normalized_path, mtime) unless @path == "."
+    end
+  end
+end

data/lib/aardi/home.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Aardi
+  class Home < AbstractBlog
+    def initialize(posts, archive_path)
+      @posts = posts
+      @archive_path = archive_path
+    end
+
+    def content
+      "# #{title}\n#{post_days_content}#{content_footer}"
+    end
+
+    def render
+      Aardi.ledger[:sitemap].update_mtime("/", mtime)
+      write_target
+    end
+
+    def target_path = "./index.html"
+
+    def title = Aardi.config[:blog_home_title]
+
+    private
+
+    def children
+      @posts
+    end
+
+    def content_footer
+      site_url = Aardi.config[:site_url]
+      more_archive = "[Archive](#{site_url}/#{@archive_path}/)"
+      more_rss = "[RSS](#{site_url}/index.xml)"
+      more_json = "[JSON](#{site_url}/index.json)"
+      "**More:** #{more_archive}, #{more_rss}, #{more_json}"
+    end
+
+    def days_hash
+      @days_hash ||= @posts.group_by { |post| post.creation.strftime("%Y-%m-%d") }
+    end
+
+    def post_day_content(post_day)
+      date_header = post_day.first.creation.strftime("%A, %e %B %Y")
+      posts_content = post_day.map(&:content).join
+      "## #{date_header}\n#{posts_content}"
+    end
+
+    def post_days_content
+      days_hash.values.map { |day| post_day_content(day) }.join
+    end
+  end
+end

data/lib/aardi/init_files/config.yml

@@ -0,0 +1,26 @@
+site_title: My Site
+site_url: http://localhost:8000
+site_author: Author Name
+files_to_exclude:
+  - ./blog
+  - ./posts
+ignore_orphans: []
+template_path: .template.html
+blog_archive_path: blog
+blog_posts_path: posts
+blog_feed_posts: 10
+blog_recent_posts: 10
+blog_archive_title: Blog Archive
+blog_home_title: My Site
+blog_home_posts: 10
+sitemap_entries:
+  /: daily
+markup_options:
+  autolink: false
+  fenced_code_blocks: true
+  footnotes: true
+  no_intra_emphasis: true
+  strikethrough: true
+  superscript: true
+  tables: true
+content_hashes_path: .content_hashes.txt

data/lib/aardi/json_feed.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Aardi
+  class JSONFeed < AbstractFeed
+    def content
+      aardi_config = Aardi.config
+      feed_content = {version: "https://jsonfeed.org/version/1.1", title: aardi_config[:site_title],
+                      home_page_url: aardi_config[:site_url], feed_url:}
+      feed_content[:items] = @posts.map { |post| post_details(post) }
+
+      JSON.pretty_generate(feed_content)
+    end
+
+    private
+
+    def feed_file
+      "index.json"
+    end
+
+    def post_details(post)
+      post_updated = post.updated
+      post_creation = post.creation
+
+      details = {id: post.name, url: post.url, title: post.title,
+                 date_published: post_creation.iso8601, content_html: post.feed_snippet}
+
+      details[:date_modified] = post_updated.iso8601 unless post_creation == post_updated
+
+      details.compact
+    end
+  end
+end

data/lib/aardi/ledger.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Aardi
+  class Ledger
+    def initialize
+      @data = {}
+    end
+
+    def [](key) = @data[key]
+
+    def []=(key, value)
+      @data[key] = value
+    end
+  end
+end

data/lib/aardi/month.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Aardi
+  class Month < AbstractBlog
+    def initialize(year, key, archive_path)
+      @year = year
+      @key = key
+      @archive_path = archive_path
+      @index = Hash.new { |hash, day| hash[day] = Day.new(year, self, day, archive_path) }
+    end
+
+    def <<(post)
+      @index[post.day] << post
+    end
+
+    def archive_cell(month_fmt)
+      cell = count.zero? ? "" : format(month_fmt, count:, archive_path: @archive_path, year: @year, month: self)
+      "#{cell} |"
+    end
+
+    def content
+      @content ||= begin
+        days_content = days.map { |day| "##{day.content}" }.join
+        "# #{title}\n#{days_content}"
+      end
+    end
+
+    def count = days.sum(&:count)
+
+    def target_path
+      "./#{@archive_path}/#{@year}/#{self}/index.html"
+    end
+
+    def title = Date.new(@year.key, @key).strftime("%B %Y")
+
+    def to_s = @key.to_s.rjust(2, "0")
+
+    private
+
+    def children
+      days
+    end
+
+    def days
+      @days ||= @index.values.sort_by { |value| -value.key }
+    end
+  end
+end

data/lib/aardi/orphanage.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Aardi
+  class Orphanage
+    def warn
+      Aardi.ledger[:html_files].each { |path| puts("Orphan: #{path}") unless ignored?(path) }
+    end
+
+    private
+
+    def ignored?(path)
+      Aardi.config[:ignore_orphans].any? { |prefix| path.start_with?(prefix) }
+    end
+  end
+end