archival 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7403410bc5164f3be23c22494a716fe7af6d6e805fc38ddb12c920bed918dba7
-  data.tar.gz: ebb064928f3295b914609a9751c11cf663ae54af6671b655def56f5d03dab93e
+  metadata.gz: 6d3848687ae065595e19f5b75bb50927318e81df6d6b878541b2ef44138f9d31
+  data.tar.gz: 7a48ab3c689dcbb886f2441216750729ec892e40d6dc0a39197fba17eb9c4ab2
 SHA512:
-  metadata.gz: 866d33fea5f99757f5a5a01254769ba4a1527341f0f68df03c0daeda38fc642a5177c011d18a902937b72027c2061f92efb0eddea765eae295b520c562188f74
-  data.tar.gz: 802638fe184d75b2596bfbb378e02fe8de985bfdda46463dcba009937493faef442c65280307a7d3d25fd3ecbc762584846d305f3e7ceb2cf4bf4949cfe5d057
+  metadata.gz: '039d5ae09373d249e90fd850e7bd68970ae5ad3c394ed452016e4acaca4df5063d1aab818a09f9a365af9e3277b777257c27d2c4cc365b7d8daafcb33842e8a3'
+  data.tar.gz: 6246274ed1209a20819616480c7a1ffde1422b1a68bf5e728a3b637e61ac8675e2bc8fafa8a003cedac455e11ca21e5f22ef9039de96d95f1fc5dcab0f93111b

data/.rubocop.yml

@@ -30,7 +30,7 @@ Metrics/BlockLength:
   Max: 150
 
 Metrics/ClassLength:
-  Max: 150
+  Max: 200
 
 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.7'
+  s.version     = '0.0.8'
   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/lib/archival/builder.rb

@@ -2,12 +2,8 @@
 
 require 'liquid'
 require 'tomlrb'
-require 'tags/layout'
 require 'redcarpet'
 
-Liquid::Template.error_mode = :strict
-Liquid::Template.register_tag('layout', Layout)
-
 module Archival
   class DuplicateKeyError < StandardError
   end
@@ -17,38 +13,33 @@ module Archival
 
     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
     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_pages = Set.new
+      @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_objects
       update_pages
     end
 
@@ -57,12 +48,40 @@ 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_pages.include? File.basename(file, '.liquid')
+      @dynamic_types.include? File.basename(file, '.liquid')
     end
 
     def template_for_page(template_file)
@@ -96,34 +115,44 @@ module Archival
       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)
-              if definition.key? 'template'
-                @dynamic_pages << definition['template']
-              end
-            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)
@@ -142,28 +171,28 @@ module Archival
       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)
-    end
-
-    def render_dynamic(page, obj)
-      template = @dynamic_templates[page]
-      template.render(@variables.merge({ page => obj }))
+      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
@@ -172,30 +201,29 @@ 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(out_dir,
-                             "#{template}.html")
+        out_path = File.join(out_dir, "#{template}.html")
         File.open(out_path, 'w+') do |file|
           file.write(render(template))
         end
       end
-      @dynamic_pages.each do |page|
-        out_dir = File.join(@config.build_dir, page)
+      @dynamic_types.each do |type|
+        out_dir = File.join(@config.build_dir, type)
         Dir.mkdir(out_dir) unless File.exist? out_dir
-        objects = @variables['objects'][page]
-        objects.each do |obj|
-          out_path = File.join(out_dir, "#{obj[:name]}.html")
-          obj['path'] = out_path
+        read_objects(type) do |name|
+          out_path = File.join(out_dir, "#{name}.html")
           File.open(out_path, 'w+') do |file|
-            file.write(render_dynamic(page, obj))
+            file.write(render_dynamic(type, name))
           end
         end
       end
-      return if @config.dev_mode
 
-      # 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)
+
+        FileUtils.copy_entry File.join(@config.root, asset_dir), asset_path
       end
     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,29 @@ 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',
+      # 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]
+          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/version.rb

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

data/lib/archival.rb

@@ -1,13 +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,51 @@
+# 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')
+  end
+
+  def self.root_dir=(dir)
+    @@root_dir = dir
+  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))
+    output << abs_asset_path.relative_path_from(template_path).to_s
+    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.7",
+  "version": "0.0.8",
   "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.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Jesse Ditson
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-11-14 00:00:00.000000000 Z
+date: 2021-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: liquid
@@ -104,15 +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: