archival 0.0.5 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c29406fcec39c52b6876b805dba5509d6f43da5805944a344b2c771214cd8ed
-  data.tar.gz: 7319f9d6dace6b20c57e318d4df1c4dc80c1bd67673cee1b37d9a17ba35f823b
+  metadata.gz: dd9c755847bfaabb7c6dee0882426534c44c7130a8cbfe84a45b755bca91088a
+  data.tar.gz: 3bbd4cb0b322db5eff11b85d9afc9f76e4cdbe1bc166c530f015583369c7f141
 SHA512:
-  metadata.gz: e05e6573f3e580d3a364826b7fd604559f2513e609a5436ba4170d606112d913e91d3cc0ec5498f4e0c418212b85068d7d859829030ee8b113a8909b04020e64
-  data.tar.gz: 8c227320c6d961595b5ce545559df4cdddf42e1d27819c1e5013b1e8189932bb50b4047e47bc5f85c8af1b0109a9b582063e487fb926132248d766b19fc98498
+  metadata.gz: db20449d88ba3394580bd5efebd259a7479bd423fea6983a4790e21d124d831490f4e9f4bea3fe97411cc2b72898e93534be2b34d122e6c93e47290381cd74b3
+  data.tar.gz: f25b29c4fdb0b676dcee6156ab571877764ead475cac70944c6e81a1f5c445b3ebaf07b7266087b3163209184cf2c9dc50f33797105b8abb3a8e2564a19861c2

data/.rubocop.yml

@@ -30,7 +30,7 @@ Metrics/BlockLength:
   Max: 150
 
 Metrics/ClassLength:
-  Max: 150
+  Max: 250
 
 Metrics/CyclomaticComplexity:
   Max: 10

data/Gemfile

@@ -7,4 +7,4 @@ gemspec
 
 gem 'rake', '~> 13.0'
 gem 'rspec', '~> 3.0'
-gem 'rubocop', '~> 1.22', require: false
+gem 'rubocop', '~> 1.23', require: false

data/archival.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = 'archival'
-  s.version     = '0.0.5'
+  s.version     = '0.0.9'
   s.summary     = 'An incredibly simple CMS for durable websites'
   s.description = 'https://jesseditson.com/the-simplest-cms-part-1'
   s.authors     = ['Jesse Ditson']
@@ -26,4 +26,8 @@ Gem::Specification.new do |s|
   s.add_dependency 'listen', '~> 3.7.0'
   s.add_dependency 'redcarpet', '~> 3.5.1'
   s.add_dependency 'tomlrb', '~> 2.0.1'
+
+  s.metadata = {
+    'rubygems_mfa_required' => 'true'
+  }
 end

data/bin/bundle

@@ -73,7 +73,7 @@ m = Module.new do
 
     requirement = bundler_gem_version.approximate_recommendation
 
-    return requirement unless Gem::Version.new(Gem::VERSION) < Gem::Version.new("2.7.0")
+    return requirement unless Gem.rubygems_version < Gem::Version.new("2.7.0")
 
     requirement += ".a" if bundler_gem_version.prerelease?
 

data/lib/archival/builder.rb

@@ -2,49 +2,51 @@
 
 require 'liquid'
 require 'tomlrb'
-require 'tags/layout'
 require 'redcarpet'
-
-Liquid::Template.error_mode = :strict
-Liquid::Template.register_tag('layout', Layout)
+require 'fileutils'
+require 'tags/asset'
 
 module Archival
+  class DuplicateKeyError < StandardError
+  end
+
+  class DuplicateStaticFileError < StandardError
+  end
+
   class Builder
     attr_reader :page_templates
 
     def initialize(config, *_args)
       @config = config
-      @markdown = Redcarpet::Markdown.new(
-        Redcarpet::Render::HTML.new(prettify: true,
-                                    hard_wrap: true), no_intra_emphasis: true,
-                                                      fenced_code_blocks: true,
-                                                      autolink: true,
-                                                      strikethrough: true,
-                                                      underline: true
-      )
       refresh_config
+      Asset.helper_port = @config.helper_port
+    end
+
+    def pages_dir
+      File.join(@config.root, @config.pages_dir)
+    end
+
+    def objects_dir
+      File.join(@config.root, @config.objects_dir)
     end
 
     def refresh_config
       @file_system = Liquid::LocalFileSystem.new(
-        File.join(@config.root, @config.pages_dir), '%s.liquid'
+        pages_dir, '%s.liquid'
       )
-      @variables = {}
       @object_types = {}
       @page_templates = {}
+      @dynamic_types = Set.new
+      @dynamic_templates = {}
+      @parser = Archival::Parser.new(pages_dir)
 
       Liquid::Template.file_system = Liquid::LocalFileSystem.new(
-        File.join(@config.root, @config.pages_dir), '_%s.liquid'
+        pages_dir, '_%s.liquid'
       )
 
-      objects_definition_file = File.join(@config.root,
-                                          'objects.toml')
-      if File.file? objects_definition_file
-        @object_types = Tomlrb.load_file(objects_definition_file)
-      end
+      @objects_definition_file = File.join(@config.root, 'objects.toml')
 
       update_pages
-      update_objects
     end
 
     def full_rebuild
@@ -52,8 +54,46 @@ module Archival
       refresh_config
     end
 
-    def update_pages
-      do_update_pages(File.join(@config.root, @config.pages_dir))
+    def update_objects(_updated_objects = nil)
+      @object_types = {}
+      if File.file? @objects_definition_file
+        @object_types = Tomlrb.load_file(@objects_definition_file)
+      end
+      @dynamic_types = Set.new
+      @object_types.each do |_name, definition|
+        is_template = definition.key? 'template'
+        @dynamic_types << definition['template'] if is_template
+      end
+      # TODO: remove deleted dynamic pages
+    end
+
+    def update_pages(_updated_pages = nil, _updated_objects = nil)
+      update_objects
+      # TODO: remove deleted pages
+      do_update_pages(pages_dir)
+    end
+
+    def update_assets(changes)
+      changes.each do |change|
+        asset_path = File.join(@config.build_dir, change.path)
+        case change.type
+        when :removed
+          FileUtils.rm_rf asset_path
+        else
+          puts change.path
+          FileUtils.copy_entry File.join(@config.root, change.path), asset_path
+        end
+      end
+    end
+
+    def dynamic?(file)
+      @dynamic_types.include? File.basename(file, '.liquid')
+    end
+
+    def template_for_page(template_file)
+      content = @file_system.read_template_file(template_file)
+      content += dev_mode_content if @config.dev_mode
+      Liquid::Template.parse(content)
     end
 
     def do_update_pages(dir, prefix = nil)
@@ -69,77 +109,96 @@ module Archival
                          add_prefix(entry))
           end
         elsif File.file? File.join(dir, entry)
-          if entry.end_with?('.liquid') && !(entry.start_with? '_')
-            page_name = File.basename(entry,
-                                      '.liquid')
-            template_file = add_prefix.call(page_name)
-            content = @file_system.read_template_file(template_file)
-            content += dev_mode_content if @config.dev_mode
-            @page_templates[add_prefix.call(page_name)] =
-              Liquid::Template.parse(content)
+          page_name = File.basename(entry, '.liquid')
+          template_file = add_prefix.call(page_name)
+          if dynamic? entry
+            @dynamic_templates[template_file] = template_for_page(template_file)
+          elsif entry.end_with?('.liquid') && !(entry.start_with? '_')
+            @page_templates[template_file] =
+              template_for_page(template_file)
           end
         end
       end
     end
 
-    def update_objects
-      do_update_objects(File.join(@config.root,
-                                  @config.objects_dir))
+    def read_objects(type)
+      obj_dir = File.join(objects_dir, type)
+      return unless File.directory? obj_dir
+
+      Dir.foreach(obj_dir) do |file|
+        if file.end_with? '.toml'
+          object = Tomlrb.load_file(File.join(
+                                      obj_dir, file
+                                    ))
+          object[:name] =
+            File.basename(file, '.toml')
+          yield object[:name], object
+        end
+      end
+    end
+
+    def path_for_template(name, type)
+      Pathname.new(File.join(pages_dir, type, "#{name}.html"))
     end
 
-    def do_update_objects(dir)
+    def objects_for_template(template_path)
       objects = {}
-      @object_types.each do |name, definition|
-        objects[name] = {}
-        obj_dir = File.join(dir, name)
-        if File.directory? obj_dir
-          Dir.foreach(obj_dir) do |file|
-            if file.end_with? '.toml'
-              object = Tomlrb.load_file(File.join(
-                                          obj_dir, file
-                                        ))
-              object[:name] =
-                File.basename(file, '.toml')
-              objects[name][object[:name]] = parse_object(object, definition)
-            end
+      @object_types.each do |type, definition|
+        objects[type] = {}
+        is_dynamic = @dynamic_types.include? type
+        read_objects type do |name, object|
+          objects[type][name] = @parser.parse_object(
+            object, definition, template_path
+          )
+          if is_dynamic
+            path = path_for_template(name, type)
+            objects[type][name]['path'] =
+              path.relative_path_from(File.dirname(template_path)).to_s
           end
         end
-        objects[name] = sort_objects(objects[name])
+        objects[type] = sort_objects(objects[type])
       end
-      @variables['objects'] = objects
+      objects
     end
 
     def sort_objects(objects)
-      # Since objects are hashes but we'd like them to be iterable based on
-      # arbitrary "order" keys, and in ruby hashes enumerate in insert order,
-      # we just need to re-insert in the correct order.
-      sorted_keys = objects.sort_by do |name, obj|
-        obj['order'].to_s || name
+      # Sort by either 'order' key or object name, depending on what is
+      # available.
+      sorted_by_keys = objects.sort_by do |name, obj|
+        obj.key?('order') ? obj['order'].to_s : name
       end
-      sorted_objects = {}
-      sorted_keys.each do |d|
+      sorted_objects = Archival::TemplateArray.new
+      sorted_by_keys.each do |d|
+        raise DuplicateKeyError if sorted_objects.key?(d[0])
+
+        sorted_objects.push(d[1])
         sorted_objects[d[0]] = d[1]
       end
       sorted_objects
     end
 
-    def parse_object(object, definition)
-      definition.each do |name, type|
-        case type
-        when 'markdown'
-          object[name] = @markdown.render(object[name]) if object[name]
-        end
-      end
-      object
-    end
-
-    def set_var(name, value)
-      @variables[name] = value
-    end
-
     def render(page)
+      dir = File.join(pages_dir, File.dirname(page))
       template = @page_templates[page]
-      template.render(@variables)
+      template_path = File.join(dir, page)
+      parsed_objects = objects_for_template(template_path)
+      template.render('objects' => parsed_objects,
+                      'template_path' => template_path)
+    end
+
+    def render_dynamic(type, name)
+      dir = File.join(pages_dir, type)
+      template = @dynamic_templates[type]
+      template_path = File.join(dir, name)
+      parsed_objects = objects_for_template(template_path)
+      obj = parsed_objects[type][name]
+      vars = {}
+             .merge(
+               'objects' => parsed_objects,
+               'template_path' => template_path
+             )
+             .merge({ type => obj })
+      template.render(vars)
     end
 
     def write_all
@@ -148,23 +207,60 @@ module Archival
         out_dir = File.join(@config.build_dir,
                             File.dirname(template))
         Dir.mkdir(out_dir) unless File.exist? out_dir
-        out_path = File.join(@config.build_dir,
-                             "#{template}.html")
+        out_path = File.join(out_dir, "#{template}.html")
         File.open(out_path, 'w+') do |file|
           file.write(render(template))
         end
       end
-      return if @config.dev_mode
+      @dynamic_types.each do |type|
+        out_dir = File.join(@config.build_dir, type)
+        Dir.mkdir(out_dir) unless File.exist? out_dir
+        read_objects(type) do |name|
+          out_path = File.join(out_dir, "#{name}.html")
+          File.open(out_path, 'w+') do |file|
+            file.write(render_dynamic(type, name))
+          end
+        end
+      end
 
-      # in production, also copy all assets to the dist folder.
+      # in production (or init), also copy all assets to the dist folder.
+      # in dev, they will be copied as they change.
       @config.assets_dirs.each do |asset_dir|
-        FileUtils.copy_entry File.join(@config.root, asset_dir),
-                             File.join(@config.build_dir, asset_dir)
+        asset_path = File.join(@config.build_dir, asset_dir)
+        next if @config.dev_mode && File.exist?(asset_path)
+
+        source_path = File.join(@config.root, asset_dir)
+        next unless File.exist?(source_path)
+
+        FileUtils.copy_entry source_path, asset_path
       end
+
+      copy_static
     end
 
     private
 
+    def copy_static
+      static_dir = File.join(@config.root, @config.static_dir)
+
+      # same for the static dir, but just the content.
+      return unless File.exist?(static_dir)
+
+      copied_static_files = Set[Dir.children(@config.build_dir)]
+      Dir.children(static_dir).each do |child|
+        raise DuplicateStaticFileError if copied_static_files.include?(child)
+
+        copied_static_files << child
+        asset_path = File.join(@config.build_dir, child)
+        next if @config.dev_mode && File.exist?(asset_path)
+
+        source_path = File.join(static_dir, child)
+        next unless File.exist?(source_path)
+
+        FileUtils.copy_entry source_path, asset_path
+      end
+    end
+
     def dev_mode_content
       "<script src=\"http://localhost:#{@config.helper_port}/js/archival-helper.js\" type=\"application/javascript\"></script>" # rubocop:disable Layout/LineLength
     end

data/lib/archival/config.rb

@@ -4,8 +4,8 @@ require 'tomlrb'
 
 module Archival
   class Config
-    attr_reader :pages_dir, :objects_dir, :assets_dirs, :root, :build_dir,
-                :helper_port, :dev_mode
+    attr_reader :pages_dir, :objects_dir, :static_dir, :assets_dirs, :root,
+                :build_dir, :helper_port, :dev_mode
 
     def initialize(config = {})
       @root = config['root'] || Dir.pwd
@@ -17,6 +17,7 @@ module Archival
       )
       @helper_port = config['helper_port'] || manifest['helper_port'] || 2701
       @assets_dirs = config['assets_dirs'] || manifest['assets'] || []
+      @static_dir = config['static_dir'] || manifest['static'] || 'static'
       @dev_mode = config[:dev_mode] || false
     end
 

data/lib/archival/helper_server.rb

@@ -44,16 +44,23 @@ module Archival
     MAGIC_GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
 
     def handle_request(client, req, method, path)
-      if method == 'GET' && path.start_with?('/js/')
-        # For static paths, just serve the files they refer to.
+      if method == 'GET' && path.start_with?('/js/archival-helper.js')
+        # For this special file, serve it from the helper dir
         http_response(client, type: 'application/javascript') do
-          serve_static(client, path)
+          serve_static(client, path, @helper_dir)
         end
         client.close
       elsif (matches = req.match(/^Sec-WebSocket-Key: (\S+)/))
         websocket_key = matches[1]
         # puts "Websocket handshake detected with key: #{websocket_key}"
         connect_socket(client, websocket_key)
+      elsif method == 'GET'
+        # For static paths, just serve the files they refer to.
+        # TODO: mime type should be inferred from file type
+        http_response(client, type: 'application/javascript') do
+          serve_static(client, path)
+        end
+        client.close
       else
         client.close
       end
@@ -99,8 +106,9 @@ module Archival
 
       # Our server only supports single-frame, text messages.
       # Raise an exception if the client tries to send anything else.
-      raise "We don't support continuations" unless fin
-      raise 'We only support opcode 1' unless opcode == 1
+      raise 'Archival dev server does not support continuations' unless fin
+      # Some browsers send this regardless, so ignore it to keep the noise down.
+      return unless opcode == 1
 
       second_byte = @socket.getbyte
       is_masked = second_byte & 0b10000000
@@ -139,8 +147,8 @@ module Archival
       @socket.write output.pack("CCA#{message.size}")
     end
 
-    def serve_static(client, path)
-      buffer = File.open(File.join(@helper_dir, path)).read
+    def serve_static(client, path, base = @build_dir)
+      buffer = File.open(File.join(base, path)).read
       buffer.sub! '$PORT', @port.to_s
       client.print buffer
     end
@@ -150,6 +158,7 @@ module Archival
       type = config[:type] ||= 'text/html'
       client.print "HTTP/1.1 #{status}\r\n"
       client.print "Content-Type: #{type}\r\n"
+      client.print "Access-Control-Allow-Origin: *\r\n"
       client.print "\r\n"
       yield
     end

data/lib/archival/listen.rb

@@ -4,6 +4,8 @@ require 'listen'
 require 'pathname'
 
 module Archival
+  Change = Struct.new(:path, :type)
+
   def listen(config = {})
     @config = Config.new(config.merge(dev_mode: true))
     builder = Builder.new(@config)
@@ -13,21 +15,27 @@ module Archival
     ignore = %r{/dist/}
     listener = Listen.to(@config.root,
                          ignore: ignore) do |modified, added, removed|
-      updated_pages = []
-      updated_objects = []
-      updated_assets = []
-      (modified + added + removed).each do |file|
-        case change_type(file)
-        when :pages
-          updated_pages << file
-        when :objects
-          updated_objects << file
-        when :assets
-          updated_assets << file
-        end
+      changes = {
+        pages: [],
+        objects: [],
+        assets: [],
+        layout: [],
+        config: []
+      }
+      add_change = lambda { |file, type|
+        c_type = change_type(file)
+        changes[c_type] << change(file, type) unless c_type == :none
+      }
+      added.each do |file|
+        add_change.call(file, :added)
+      end
+      modified.each do |file|
+        add_change.call(file, :modified)
       end
-      @server.refresh_client if rebuild?(builder, updated_objects,
-                                         updated_pages, updated_assets)
+      removed.each do |file|
+        add_change.call(file, :removed)
+      end
+      @server.refresh_client if rebuild?(builder, changes)
     end
     listener.start
     serve_helpers
@@ -45,6 +53,13 @@ module Archival
       false
     end
 
+    def change(file, type)
+      c = Change.new
+      c.path = Pathname.new(file).relative_path_from(@config.root)
+      c.type = type
+      c
+    end
+
     def change_type(file)
       # a page was modified, rebuild the pages.
       return :pages if child?(File.join(@config.root, @config.pages_dir),
@@ -53,26 +68,36 @@ module Archival
       return :objects if child?(File.join(@config.root, @config.objects_dir),
                                 file)
 
-      # layout and other assets. For now, this is everything.
+      # an asset was changed, which just means to copy or delete it
       @config.assets_dirs.each do |dir|
         return :assets if child?(File.join(@config.root, dir), file)
       end
-      return :assets if child?(File.join(@config.root, 'layout'), file)
-      return :assets if ['manifest.toml',
+
+      # a static file was changed - copy or delete those too.
+      return :assets if child?(File.join(@config.root, @config.static_dir),
+                               file)
+
+      # other special files
+      return :layout if child?(File.join(@config.root, 'layout'), file)
+      return :config if ['manifest.toml',
                          'objects.toml'].include? File.basename(file)
 
       :none
     end
 
-    def rebuild?(builder, updated_objects, updated_pages, updated_assets)
-      if updated_pages.empty? && updated_objects.empty? && updated_assets.empty?
-        return false
-      end
+    def rebuild?(builder, changes)
+      return false if changes.values.all?(&:empty?)
 
       Logger.benchmark('rebuilt') do
-        builder.update_objects if updated_objects.length
-        builder.update_pages if updated_pages.length
-        builder.full_rebuild if updated_assets.length
+        if changes[:pages].length || changes[:objects].length
+          builder.update_pages(changes[:pages], changes[:objects])
+        end
+        builder.update_assets(changes[:assets]) if changes[:assets].length
+        if changes[:assets].length || changes[:layouts] || changes[:config]
+          # TODO: optimization: this could operate on the known subset of
+          # changes instead...
+          builder.full_rebuild
+        end
         builder.write_all
       end
       true

data/lib/archival/markdown_renderer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'redcarpet'
+
+module Archival
+  class MarkdownRenderer < Redcarpet::Render::HTML
+    def autolink(link, _link_type, _opts)
+      # TODO: handle link_type?
+      "<a href=\"#{rewrite_link(link)}\">#{rewrite_link(link)}</a>"
+    end
+
+    def link(link, title, content)
+      "<a href=\"#{rewrite_link(link)}\" title=\"#{title}\">#{content}</a>"
+    end
+
+    def image(link, title, alt_text)
+      "<img src=\"#{rewrite_link(link)}\" \
+title=\"#{title}\" alt=\"#{alt_text}\"/>"
+    end
+
+    private
+
+    def rewrite_link(link)
+      if link.start_with?('http') || link.start_with?('mailto') ||
+         link.start_with?('www') || link.start_with?('/')
+        link
+      end
+      template_dir = File.dirname(@options[:template_file])
+      resolved_link = Pathname.new(File.join(@options[:pages_root], link))
+      resolved_link.relative_path_from(template_dir)
+    end
+  end
+end

data/lib/archival/parser.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'liquid'
+require 'redcarpet'
+
+module Archival
+  class Parser
+    def initialize(pages_root)
+      @pages_root = pages_root
+    end
+
+    def parse_object(object, definition, template_file)
+      markdown = Redcarpet::Markdown.new(
+        Archival::MarkdownRenderer.new(prettify: true,
+                                       hard_wrap: true),
+        no_intra_emphasis: true,
+        fenced_code_blocks: true,
+        autolink: true,
+        strikethrough: true,
+        underline: true,
+        template_file: template_file,
+        pages_root: @pages_root
+      )
+      definition.each do |name, type|
+        case type
+        when 'markdown'
+          object[name] = markdown.render(object[name]) if object.key? name
+        end
+      end
+      object
+    end
+  end
+end

data/lib/archival/template_array.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Archival
+  class TemplateArray < Array
+    alias subscript_access []
+    alias subscript_write []=
+
+    def initialize(*args)
+      super(*args)
+      @data = {}
+    end
+
+    def [](*args)
+      key = args[0]
+      return @data[key] if key.is_a? String
+      return @data[key] if key.is_a? Symbol
+
+      subscript_access(*args)
+    end
+
+    def []=(*args)
+      key = args[0]
+      if key.is_a?(String) || key.is_a?(Symbol)
+        @data[key] = args[1]
+        return
+      end
+      subscript_write(*args)
+    end
+
+    def key?(key)
+      @data.key?(key)
+    end
+  end
+end

data/lib/archival/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Archival
-  VERSION = '0.0.5'
+  VERSION = '0.0.9'
 end

data/lib/archival.rb

@@ -1,12 +1,23 @@
 # frozen_string_literal: true
 
+require 'liquid'
+require 'tags/layout'
+require 'tags/asset'
+
 module Archival
   # Main Archival module. See https://archival.dev for docs.
 end
 
+Liquid::Template.error_mode = :strict
+Liquid::Template.register_tag('layout', Layout)
+Liquid::Template.register_tag('asset', Asset)
+
 require 'archival/version'
+require 'archival/template_array'
 require 'archival/logger'
 require 'archival/config'
+require 'archival/markdown_renderer'
 require 'archival/helper_server'
+require 'archival/parser'
 require 'archival/builder'
 require 'archival/listen'

data/lib/tags/asset.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'liquid'
+
+class Asset < Liquid::Tag
+  # Adds an `asset` tag to liquid. Usage:
+  #
+  # {% asset "path/to/asset.png" %}
+  #
+  # This will replace the tag with a relative path to the asset from the
+  # current template. Using normal tags will work from the root, but when
+  # building dynamic pages or reusing layouts, asset paths are dynamic and
+  # will need to be rewritten.
+
+  prepend Liquid::Tag::Disableable
+
+  SYNTAX = /(#{Liquid::QuotedFragment}+)/o.freeze
+
+  def initialize(tag_name, markup, tokens)
+    super
+    raise AssetError, 'Invalid layout syntax' unless markup =~ SYNTAX
+
+    @path = parse_expression(Regexp.last_match(1))
+    # This is defaulted to the pages dir, because it represents the structure
+    # of our website. Asset directories are copied as siblings at runtime.
+    @@root_dir ||= File.join(Dir.pwd, 'pages')
+
+    @attributes = {}
+
+    markup.scan(Liquid::TagAttributes) do |key, value|
+      @attributes[key] = parse_expression(value)
+    end
+  end
+
+  def self.root_dir=(dir)
+    @@root_dir = dir
+  end
+
+  def self.helper_port=(port)
+    @@helper_port = port
+  end
+
+  def render_to_output_buffer(context, output)
+    unless @@root_dir
+      raise AssetError,
+            'root_dir must be set on Archival::Asset'
+    end
+
+    unless context.key? 'template_path'
+      raise AssetError,
+            'template_path must be provided to parse when using assets'
+    end
+    template_path = File.dirname(context['template_path'])
+    abs_asset_path = Pathname.new(File.join(@@root_dir, @path))
+    asset_path = abs_asset_path.relative_path_from(template_path).cleanpath.to_s
+    output << if @attributes['serve'] == true
+                "http://localhost:#{@@helper_port}/#{asset_path}"
+              else
+                asset_path
+              end
+    output
+  end
+end
+
+class AssetError < Liquid::Error
+end

data/lib/tags/layout.rb

@@ -25,7 +25,7 @@ class Layout < Liquid::Tag
     super
 
     @page_content = []
-    raise 'Invalid layout syntax' unless markup =~ SYNTAX
+    raise LayoutError, 'Invalid layout syntax' unless markup =~ SYNTAX
 
     layout_name = Regexp.last_match(1)
     @layout_name_expr = parse_expression(layout_name)
@@ -40,7 +40,9 @@ class Layout < Liquid::Tag
     base_path = Dir.pwd
     layout_dir = 'layout'
     layout_path = File.join(base_path, layout_dir)
-    raise "Layout dir #{layout_path} not found" unless File.exist? layout_path
+    unless File.exist? layout_path
+      raise LayoutError, "Layout dir #{layout_path} not found"
+    end
 
     layout_path
   end
@@ -55,11 +57,15 @@ class Layout < Liquid::Tag
       )
 
       next unless File.basename(f, '.*') == layout_name
-      raise "More than one layout named #{layout_name} found." if found_layout
+      if found_layout
+        raise LayoutError, "More than one layout named #{layout_name} found."
+      end
 
       found_layout = File.join(layout_path, f)
     end
-    raise "No layouts named #{layout_name} found." if found_layout.nil?
+    if found_layout.nil?
+      raise LayoutError, "No layouts named #{layout_name} found."
+    end
 
     layout = File.read(found_layout)
     @@layout_cache[layout_name] =
@@ -77,7 +83,7 @@ class Layout < Liquid::Tag
 
   def render_to_output_buffer(context, output)
     layout_name = context.evaluate(@layout_name_expr)
-    raise 'Bad layout name argument' unless layout_name
+    raise LayoutError, 'Bad layout name argument' unless layout_name
 
     layout = load_layout(layout_name)
 
@@ -104,3 +110,6 @@ class Layout < Liquid::Tag
     output
   end
 end
+
+class LayoutError < Liquid::Error
+end

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archival",
-  "version": "0.0.5",
+  "version": "0.0.9",
   "description": "An incredibly simple CMS for durable websites",
   "bin": "build.rb",
   "directories": {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: archival
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.9
 platform: ruby
 authors:
 - Jesse Ditson
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-11-07 00:00:00.000000000 Z
+date: 2022-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: liquid
@@ -104,14 +104,19 @@ files:
 - lib/archival/helper_server.rb
 - lib/archival/listen.rb
 - lib/archival/logger.rb
+- lib/archival/markdown_renderer.rb
+- lib/archival/parser.rb
 - lib/archival/rake_tasks.rb
+- lib/archival/template_array.rb
 - lib/archival/version.rb
+- lib/tags/asset.rb
 - lib/tags/layout.rb
 - package.json
 homepage: https://archival.dev
 licenses:
 - Unlicense
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -127,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: An incredibly simple CMS for durable websites