aardi 0.9.0

data/lib/aardi/page.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Aardi
+  class Page
+    include AbstractPageSupport
+
+    def initialize(path)
+      @path = path
+      parse_source path
+    end
+
+    def content
+      @src_content
+    end
+
+    def render
+      page_content = PageContent.new(content, title, metadata)
+      PageTarget.new(page_content, target_path).write
+    end
+
+    def target_path
+      @path.pathmap("%X.html")
+    end
+  end
+end

data/lib/aardi/page_content.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Aardi
+  class PageContent < Content
+    attr_reader :title, :metadata
+
+    def initialize(src_content, title, metadata = {})
+      super(src_content)
+      @title = title
+      @metadata = metadata
+    end
+
+    def content
+      @src_content
+    end
+
+    def output
+      @output ||= Aardi.ledger[:template].render(self)
+    end
+  end
+end

data/lib/aardi/page_target.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Aardi
+  class PageTarget < FileTarget
+    def write
+      super
+      Aardi.ledger[:html_files].delete(@path)
+    end
+
+    private
+
+    def file_exists?
+      Aardi.ledger[:html_files].include? @path
+    end
+  end
+end

data/lib/aardi/path_servlet.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "webrick"
+
+module Aardi
+  class PathServlet < WEBrick::HTTPServlet::AbstractServlet
+    def service(req, res)
+      # use index if folder
+      path = "./#{req.path}".sub(%r{/$}, "/index.html")
+
+      file = path if File.exist?(path)
+      file ||= "#{path}.html" if File.exist?("#{path}.html")
+      raise(WEBrick::HTTPStatus::NotFound, "#{path} not found.") unless file
+
+      res.body = File.read(file)
+    end
+  end
+end

data/lib/aardi/post.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Aardi
+  class Post < AbstractBlog
+    include AbstractPageSupport
+
+    def initialize(path)
+      @path = path
+      parse_source path
+    end
+
+    def content
+      "#{@src_content}\n<div><span class=\"bookmark\">[<a href=\"#{url}\">bookmark</a>]</span></div>\n"
+    end
+
+    def creation = metadata["Creation"]
+
+    def day = creation.day
+
+    def feed_snippet
+      clean_content = @src_content.sub(/\A(### .*\n)?\n+/, "")
+      render_markup(clean_content).strip
+    end
+
+    def month = creation.month
+
+    def name = File.basename(@path, ".*")
+
+    def report_field_summary
+      creation_header = creation.strftime("%e %b %Y")
+      puts "#{creation_header} | #{@path} | #{title}"
+    end
+
+    def target_path
+      "./#{short_target}.html"
+    end
+
+    def updated = metadata["Updated"] || creation
+
+    def url = "#{Aardi.config[:site_url]}/#{short_target}"
+
+    def year = creation.year
+
+    private
+
+    def render_markup(content)
+      ledger = Aardi.ledger
+      ledger[:custom_renderer].reset
+      ledger[:markdown_renderer].render(content)
+    end
+
+    def short_target
+      "#{Aardi.config[:blog_archive_path]}/#{creation.strftime("%Y/%m/%d")}/#{name}"
+    end
+  end
+end

data/lib/aardi/site.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Aardi
+  class Site < AbstractBlog
+    def initialize
+      initialize_ledger
+    end
+
+    # :reek:FeatureEnvy
+    def blog
+      aardi_config = Aardi.config
+      @blog ||= Blog.new(aardi_config[:blog_posts_path], aardi_config[:blog_archive_path])
+    end
+
+    def render
+      super
+      content_hashes.write
+      warn_about_orphans
+    end
+
+    private
+
+    def children
+      [Folder.new("."), blog, sitemap]
+    end
+
+    def content_hashes
+      @content_hashes ||= ContentHashes.new(Aardi.config[:content_hashes_path])
+    end
+
+    def custom_renderer
+      @custom_renderer ||= CustomRenderer.new
+    end
+
+    def html_files
+      @html_files ||= Dir.glob("./**/*.html").to_set
+    end
+
+    def initialize_ledger
+      ledger = Aardi.ledger
+      # set up content hashes so they're in place while building out the rest
+      ledger[:content_hashes] = content_hashes
+
+      {custom_renderer:, markdown_renderer:, html_files:, sitemap:, template:}.each do |message, value|
+        ledger[message] = value
+      end
+    end
+
+    def markdown_renderer
+      Redcarpet::Markdown.new(custom_renderer, Aardi.config[:markup_options])
+    end
+
+    def sitemap
+      @sitemap ||= Sitemap.new
+    end
+
+    def template
+      Template.new Aardi.config[:template_path]
+    end
+
+    def warn_about_orphans
+      Orphanage.new.warn
+    end
+
+    def write_target
+    end
+  end
+end

data/lib/aardi/sitemap.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Aardi
+  class Sitemap
+    # :reek:NestedIterators
+    def content
+      sitemap = Nokogiri::XML::Builder.new(encoding: "UTF-8") do
+        urlset(xmlns: "http://www.sitemaps.org/schemas/sitemap/0.9") do |urlset|
+          urls.each do |path, details|
+            url_details(path, details, urlset)
+          end
+        end
+      end
+
+      sitemap.to_xml
+    end
+
+    def render
+      source = Content.new(content)
+      FileTarget.new(source, target_path).write
+    end
+
+    def target_path = "./sitemap.xml"
+
+    def update_mtime(path, path_mtime)
+      urls[path][:lastmod] = path_mtime.iso8601
+    end
+
+    # Methods called inside builder blocks must be public.
+    # :reek:FeatureEnvy
+    def url_details(path, details, urlset)
+      missing_path(path) unless File.exist?("./#{path}")
+
+      urlset.url do
+        details.slice(:loc, :lastmod, :changefreq).each do |node, value|
+          urlset.public_send node, value
+        end
+      end
+    end
+
+    def urls
+      @urls ||= Aardi.config[:sitemap_entries].to_h { |path, cf| [path, url_values(path, cf)] }
+    end
+
+    private
+
+    def missing_path(path)
+      puts("FATAL: #{path} missing")
+      exit
+    end
+
+    def url_values(path, changefreq)
+      {loc: "#{Aardi.config[:site_url]}#{path}", changefreq:}
+    end
+  end
+end

data/lib/aardi/tasks/fixtimes.rake

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+desc("Fix file timestamps")
+task(:fixtimes) do
+  require "aardi/timekeeper"
+
+  Aardi::Timekeeper.new.run
+end

data/lib/aardi/tasks/homepage.rake

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+desc("Visit home page")
+task homepage: [:load_config] do
+  system("open #{Aardi.config[:site_url]}")
+end

data/lib/aardi/tasks/init.rake

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+INIT_FILES_DIR = File.expand_path("../init_files", __dir__)
+
+desc("Scaffold a new Aardi site")
+task :init do
+  Dir.glob("#{INIT_FILES_DIR}/**/*", File::FNM_DOTMATCH).each do |src|
+    next if File.directory?(src)
+
+    dest = File.basename(src)
+
+    unless File.exist?(dest)
+      FileUtils.cp(src, dest)
+      puts "Created #{dest}"
+      next
+    end
+
+    loop do
+      print "#{dest} already exists. Overwrite? [y]es / [n]o: "
+      answer = $stdin.gets&.strip&.downcase
+      case answer
+      when "y"
+        FileUtils.cp(src, dest)
+        puts "Overwrote #{dest}"
+        break
+      when "n"
+        puts "Skipped #{dest}"
+        break
+      end
+    end
+  end
+
+  puts "Site scaffolding installed."
+end

data/lib/aardi/tasks/load_config.rake

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# rubocop:disable Rake/Desc
+task :load_config do
+  Aardi.config.load "./config.yml"
+end
+# rubocop:enable Rake/Desc

data/lib/aardi/tasks/new.rake

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+def create_new_post
+  now = Time.now.utc
+  new_post_file = "#{now.to_i}.md"
+  new_post_path = "#{Aardi.config[:blog_posts_path]}/#{new_post_file.hash.modulo(36).to_s(36)}/#{new_post_file}"
+  new_post_content = "Creation: #{now.iso8601}\n\n----\n### title\n\n[source](url): \"excerpt\"\n"
+  FileUtils.mkdir_p(File.dirname(new_post_path))
+  File.write(new_post_path, new_post_content)
+  puts(new_post_path)
+end
+
+desc("Create a new blog post and reveal it in Finder")
+task new: [:load_config] do
+  create_new_post
+end

data/lib/aardi/tasks/now.rake

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+desc("Produce an Updated header with current timestamp")
+task :now do
+  puts "Updated: #{Time.now.utc.iso8601}"
+end

data/lib/aardi/tasks/recent.rake

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+desc("View recent posts")
+task recent: [:load_config] do
+  Aardi::Site.new.blog.report_recent
+end

data/lib/aardi/tasks/render.rake

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+desc("Render new or updated files [DEFAULT]")
+task render: [:load_config] do
+  Aardi::Site.new.render
+end

data/lib/aardi/tasks/server.rake

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+desc("Run a server")
+task :server do
+  require "aardi/path_servlet"
+
+  port = 8000
+  url = "http://localhost:#{port}/"
+  root = "."
+  puts(url)
+
+  server = WEBrick::HTTPServer.new(Port: port, DocumentRoot: root)
+  server.mount("/", Aardi::PathServlet)
+
+  trap("INT") { server.shutdown }
+  system("(open '#{url}')&")
+  server.start
+end

data/lib/aardi/tasks.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "aardi"
+
+Dir[File.join(__dir__, "tasks", "*.rake")].each { |f| load f }

data/lib/aardi/template.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Aardi
+  # :reek:DataClump
+  class Template
+    def initialize(path)
+      @path = path
+      @content = File.read(path).strip
+      @dom = Nokogiri::HTML5.parse(@content)
+    end
+
+    # :reek:TooManyStatements
+    def render(src)
+      Aardi.ledger[:custom_renderer].reset
+      dom = @dom.clone
+
+      add_main(dom, src)
+      add_title(dom, src)
+      add_description(dom, src)
+
+      dom.to_html.strip
+    end
+
+    private
+
+    def add_description(dom, src)
+      description = src.metadata["Description"]
+      return unless description
+
+      dom.at_css('meta[name="description"]')["content"] = description
+    end
+
+    def add_main(dom, src)
+      dom.at_css("main").add_child(Aardi.ledger[:markdown_renderer].render(src.content))
+    end
+
+    def add_title(dom, src)
+      dom.at_css("title").content += " #{src.title}"
+    end
+  end
+end

data/lib/aardi/timekeeper.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "git"
+
+module Aardi
+  # :reek:TooManyInstanceVariables
+  class Timekeeper
+    def initialize
+      @repo = Git.open(Dir.pwd)
+      @commit_log = @repo.log(:all).all
+      @files = tracked_files_by_mtime
+      @files_count = @files.count
+      @updated = 0
+      @prior_summary_length = 0
+    end
+
+    def run
+      @files.each.with_index do |path, index|
+        @prior_summary_length = print_progress(index, path)
+
+        commit_date = author_date(path)
+        next unless commit_date
+
+        @updated += 1 if fix_mtime?(path, commit_date)
+      end
+    end
+
+    private
+
+    def author_date(path)
+      @commit_log.object(path).execute.first&.author_date
+    end
+
+    def fix_mtime?(path, author_date)
+      mtime = File.mtime(path)
+      return false if author_date == mtime
+
+      FileUtils.touch(path, mtime: author_date)
+      puts "\n  #{mtime} -> #{author_date}"
+      true
+    end
+
+    def print_progress(index, path)
+      summary = "(#{index} / #{@files_count}) #{@updated}: #{path}"
+      print format("\r%-#{@prior_summary_length}s", summary)
+      summary.length
+    end
+
+    def tracked_files_by_mtime
+      @repo.ls_files.keys.sort_by { |file| File.mtime(file) }.reverse!
+    end
+  end
+end

data/lib/aardi/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Aardi
+  VERSION = "0.9.0"
+end

data/lib/aardi/year.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Aardi
+  class Year < AbstractBlog
+    def initialize(key, archive_path)
+      @key = key
+      @archive_path = archive_path
+      @index = Hash.new { |hash, month| hash[month] = Month.new(self, month, archive_path) }
+    end
+
+    def <<(post)
+      @index[post.month] << post
+    end
+
+    def archive_row(year_fmt, month_fmt)
+      months_map = (1..12).map { |month| @index[month].archive_cell(month_fmt) }.join
+      format(year_fmt, year: to_s, months: months_map)
+    end
+
+    def content
+      "# #{title}\n#{months.map { |month| month_link(month) }.join("\n")}"
+    end
+
+    def target_path
+      "./#{@archive_path}/#{self}/index.html"
+    end
+
+    def title = to_s
+
+    private
+
+    def children
+      months
+    end
+
+    def month_link(month)
+      "- [#{Date::MONTHNAMES[month.key]}](#{Aardi.config[:site_url]}/#{@archive_path}/#{self}/#{month}/)"
+    end
+
+    def months
+      @months ||= @index.values.sort_by { |value| -value.key }
+    end
+
+    def to_s = key.to_s
+  end
+end

data/lib/aardi.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "date"
+require "fileutils"
+require "json"
+require "yaml"
+require "zlib"
+
+require "nokogiri"
+require "rake"
+require "redcarpet"
+
+require_relative "aardi/version"
+require_relative "aardi/config"
+require_relative "aardi/ledger"
+require_relative "aardi/content"
+require_relative "aardi/content_hashes"
+require_relative "aardi/custom_renderer"
+require_relative "aardi/abstract_blog"
+require_relative "aardi/abstract_page_support"
+require_relative "aardi/abstract_feed"
+require_relative "aardi/file_target"
+require_relative "aardi/page_target"
+require_relative "aardi/page_content"
+require_relative "aardi/template"
+require_relative "aardi/page"
+require_relative "aardi/post"
+require_relative "aardi/day"
+require_relative "aardi/month"
+require_relative "aardi/year"
+require_relative "aardi/archive"
+require_relative "aardi/home"
+require_relative "aardi/atom_feed"
+require_relative "aardi/json_feed"
+require_relative "aardi/blog"
+require_relative "aardi/folder"
+require_relative "aardi/sitemap"
+require_relative "aardi/orphanage"
+require_relative "aardi/site"
+
+RubyVM::YJIT.enable if RUBY_ENGINE == "ruby" && RUBY_VERSION.to_f >= 3.1
+
+module Aardi
+  class << self
+    def config = @config ||= Config.new
+
+    def ledger = @ledger ||= Ledger.new
+
+    def reset!
+      @config = Config.new
+      @ledger = Ledger.new
+    end
+  end
+end