ottogen 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b34377b90101dd7d052eebf2846afb77637ddfbd4e6e21015a93237d0ef4a20
-  data.tar.gz: 311b1d378b4bcaa1a6b220f01a1fe17fdcc05628a4bac5f76a0e368d076b81cc
+  metadata.gz: 6f607f53a4e24feac72ea03754c6b81917fcbe0301afb76d5dcf95f46d5d1d01
+  data.tar.gz: b87bc716dc2b0810c0de784aef321c1e774c3fbc0071e919b2cf3f78990c3f75
 SHA512:
-  metadata.gz: 0a3f16584748a1670aa78f3f0303a4332003ffd3f25891d3e433471a07b671113e705b53b5a073b249d1c817510942331e5ba005728762c0e7d873997859f86e
-  data.tar.gz: 86cbc9e917ec3d3f4a9d8c82148c7dddebc1d4f06043a085a9d2395e8c986cd09f134351a01dde64fd16a455cc241ba926b3941b88924d062a1941f5b2b4c8d5
+  metadata.gz: bb1148fac045000ea0e7d62fb11782162a6109fd14ae79c5ea4b36e687acd58f5f28f0954a76cdd79adae9b95c779f5e9f5c19e16fedd46530359817840bf030
+  data.tar.gz: a22313f2c238d677d10b4f43e778dc432ff3e4966f0455c0949933fece794d53e7830fb0a3f968e84edfcc02e6c0dfccbe4d2fb5041c04a330dab29cebafcc14

data/README.md

@@ -1,74 +1,90 @@
 # Otto
 
-AsciiDoc static site generator.
+AsciiDoc-powered static site generator with Jekyll-style conventions: layouts, includes, data files, posts, drafts, permalinks, and custom collections.
 
-# Quickstart
+## Install
 
-**Install Otto**
-
-``` sh
+```sh
 gem install ottogen
 ```
 
-**Initialize a new site**
+Requires Ruby 3.0 or newer.
+
+## Quickstart
 
-``` sh
+```sh
 mkdir mysite && cd mysite
 otto init
-```
-
-**Build the site**
-
-``` sh
 otto build
-```
-
-**Serve the site**
-
-``` sh
 otto serve
-```
-
-**View the site**
-
-``` sh
 open http://127.0.0.1:8778/
 ```
 
-# AsciiDoc Crash Course
-
-TODO
-
-**Paragraphs**
+For a longer walkthrough including AsciiDoc syntax, see [GUIDE.md](GUIDE.md).
 
-**Text formatting**
+## Commands
 
-**Links**
+| Command | Description |
+|---|---|
+| `otto init [DIR]` | Scaffold a new site (current dir if omitted) |
+| `otto build` | Render the site to `_build/` |
+| `otto build --drafts` | Include posts from `_drafts/` |
+| `otto watch` | Rebuild on file change |
+| `otto serve` | Serve `_build/` on port 8778 |
+| `otto generate PAGE` | Create a new page in `pages/` |
+| `otto post "Title"` | Create a new dated post in `_posts/` |
+| `otto clean` | Delete `_build/` |
+| `otto doctor` | Sanity-check project layout |
 
-**Document header**
+## Project layout
 
-**Section titles**
+```
+my-site/
+├── .otto                 # marker
+├── config.yml            # site config
+├── assets/               # copied verbatim into _build/
+├── pages/                # AsciiDoc pages, output mirrors path
+├── _layouts/             # ERB layouts (.html.erb)
+├── _includes/            # ERB partials
+├── _data/                # YAML/JSON files exposed as site.data.*
+├── _posts/               # YYYY-MM-DD-slug.adoc
+└── _drafts/              # undated drafts (excluded by default)
+```
 
-**Automatic TOC**
+## Configuration (`config.yml`)
 
-**Includes**
+```yaml
+title: My Otto Site
+description: Things I write
+url: https://example.com
+baseurl: ""
 
-**Lists**
+permalink: /:year/:month/:day/:slug/
 
-**Images**
+collections:
+  recipes:
+    output: true
+```
 
-**Audio**
+`permalink` accepts these tokens: `:year`, `:month`, `:day`, `:slug`, `:title`. Templates ending in `/` produce pretty URLs (`<path>/index.html`).
 
-**Videos**
+## Pages and posts
 
-**Keyboard, button, and menu macros**
+Both support YAML front matter:
 
-**Literals and source code**
+```adoc
+---
+layout: default
+title: Hello
+tags: [ruby, cli]
+---
+= Hello
 
-**Admonitions**
+Welcome to {site_title}. This page is at {page_url}.
+```
 
-**More delimited blocks**
+Pages live under `pages/`; posts under `_posts/` with `YYYY-MM-DD-slug.adoc` names. Layouts wrap rendered AsciiDoc; partials in `_includes/` are pulled in via `<%= partial 'header.html' %>`.
 
-**Tables**
+## License
 
-**IDs, roles, and options**
+MIT

data/bin/otto

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require_relative '../lib/ottogen/otto'
 

data/lib/ottogen/collection.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'collection_item'
+
+module Ottogen
+  class Collection
+    DIR_PREFIX = '_'
+
+    def self.from_config(name, settings)
+      output = settings.is_a?(Hash) && settings['output'] == true
+      new(name: name, output: output)
+    end
+
+    attr_reader :name, :items
+
+    def initialize(name:, output:)
+      @name = name
+      @output = output
+      @items = discover_items
+    end
+
+    def output?
+      @output
+    end
+
+    private
+
+    def discover_items
+      dir = "#{DIR_PREFIX}#{@name}"
+      return [] unless Dir.exist?(dir)
+
+      Dir.glob(File.join(dir, '*.adoc')).map { |path| CollectionItem.read(path, @name) }
+    end
+  end
+end

data/lib/ottogen/collection_item.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative 'front_matter'
+
+module Ottogen
+  class CollectionItem
+    class Error < StandardError; end
+
+    def self.read(path, collection_name)
+      raw = File.read(path)
+      front_matter, body = FrontMatter.split(raw, path)
+      new(path: path, collection_name: collection_name, front_matter: front_matter, body: body)
+    rescue FrontMatter::Error => e
+      raise Error, e.message
+    end
+
+    attr_reader :path, :collection_name, :front_matter, :body
+    attr_accessor :permalink
+
+    def initialize(path:, collection_name:, front_matter:, body:)
+      @path = path
+      @collection_name = collection_name
+      @front_matter = front_matter
+      @body = body
+    end
+
+    def slug
+      File.basename(@path, '.adoc')
+    end
+
+    def url
+      return @permalink.url if @permalink
+
+      "/#{@collection_name}/#{slug}.html"
+    end
+
+    def output_path(build_dir)
+      return @permalink.output_path(build_dir) if @permalink
+
+      File.join(build_dir, @collection_name, "#{slug}.html")
+    end
+
+    def asciidoctor_attributes
+      attrs = @front_matter.transform_keys { |key| "page_#{key}" }
+      attrs['page_url'] = url
+      attrs['page_slug'] = slug
+      attrs
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @front_matter.key?(name.to_s) || super
+    end
+
+    def method_missing(name, *args)
+      key = name.to_s
+      return @front_matter[key] if @front_matter.key?(key)
+
+      super
+    end
+  end
+end

data/lib/ottogen/config.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'yaml'
+
+require_relative 'collection'
+require_relative 'post'
+
+module Ottogen
+  class Config
+    class Error < StandardError; end
+
+    DEFAULT_PATH = 'config.yml'
+    DATA_DIR = '_data'
+    DATA_EXTENSIONS = %w[.yml .yaml .json].freeze
+
+    def self.load(path = DEFAULT_PATH, drafts: false)
+      raise Error, "config.yml not found at #{path}" unless File.exist?(path)
+
+      values = YAML.safe_load_file(path) || {}
+      new(values, load_data_files, load_posts(drafts: drafts), load_collections(values['collections']))
+    rescue Psych::SyntaxError => e
+      raise Error, "malformed YAML in #{path}: #{e.message}"
+    end
+
+    def self.load_collections(config)
+      return {} unless config.is_a?(Hash)
+
+      config.to_h { |name, settings| [name, Collection.from_config(name, settings || {})] }
+    end
+    private_class_method :load_collections
+
+    def self.load_posts(drafts: false)
+      posts = Post.discover
+      posts += Post.discover_drafts if drafts
+      posts.sort_by(&:date).reverse
+    rescue Post::Error => e
+      raise Error, e.message
+    end
+    private_class_method :load_posts
+
+    def self.load_data_files
+      return {} unless Dir.exist?(DATA_DIR)
+
+      Dir.glob(File.join(DATA_DIR, '*.{yml,yaml,json}')).to_h do |file|
+        [File.basename(file, '.*'), parse_data_file(file)]
+      end
+    end
+
+    def self.parse_data_file(file)
+      if file.end_with?('.json')
+        JSON.parse(File.read(file))
+      else
+        YAML.safe_load_file(file)
+      end
+    rescue Psych::SyntaxError, JSON::ParserError => e
+      raise Error, "malformed data file at #{file}: #{e.message}"
+    end
+    private_class_method :load_data_files, :parse_data_file
+
+    def initialize(values, data_files = {}, posts = [], collections = {})
+      @values = values
+      @data = Data.new(data_files)
+      @posts = posts
+      @collections = collections
+    end
+
+    attr_reader :data, :posts, :collections
+
+    def tags
+      group_posts_by(&:tags)
+    end
+
+    def categories
+      group_posts_by(&:categories)
+    end
+
+    def group_posts_by(&block)
+      @posts.each_with_object({}) do |post, acc|
+        block.call(post).each { |key| (acc[key] ||= []) << post }
+      end
+    end
+    private :group_posts_by
+
+    def [](key)
+      @values[key.to_s]
+    end
+
+    def asciidoctor_attributes
+      @values.transform_keys { |key| "site_#{key}" }
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      key = name.to_s
+      @values.key?(key) || @collections.key?(key) || super
+    end
+
+    def method_missing(name, *args)
+      key = name.to_s
+      return @collections[key].items if @collections.key?(key)
+      return @values[key] if @values.key?(key)
+
+      super
+    end
+
+    class Data
+      def initialize(files)
+        @files = files
+      end
+
+      def [](key)
+        @files[key.to_s]
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @files.key?(name.to_s) || super
+      end
+
+      def method_missing(name, *args)
+        return @files[name.to_s] if @files.key?(name.to_s)
+
+        super
+      end
+    end
+  end
+end

data/lib/ottogen/front_matter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Ottogen
+  module FrontMatter
+    class Error < StandardError; end
+
+    OPENERS = ["---\n", "---\r\n"].freeze
+
+    def self.split(raw, path)
+      return [{}, raw] unless OPENERS.any? { |opener| raw.start_with?(opener) }
+
+      lines = raw.lines
+      closing = lines[1..].index { |line| line.chomp == '---' }
+      raise Error, "unclosed front matter in #{path}" if closing.nil?
+
+      yaml_text = lines[1..closing].join
+      body = (lines[(closing + 2)..] || []).join
+      [parse_yaml(yaml_text, path), body]
+    end
+
+    def self.parse_yaml(text, path)
+      YAML.safe_load(text) || {}
+    rescue Psych::SyntaxError => e
+      raise Error, "malformed YAML front matter in #{path}: #{e.message}"
+    end
+    private_class_method :parse_yaml
+  end
+end

data/lib/ottogen/layout.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+require_relative 'front_matter'
+
+module Ottogen
+  class Layout
+    class Error < StandardError; end
+
+    LAYOUTS_DIR = '_layouts'
+    EXTENSION = '.html.erb'
+
+    def self.find(name)
+      path = File.join(LAYOUTS_DIR, "#{name}#{EXTENSION}")
+      raise Error, "layout '#{name}' not found at #{path}" unless File.exist?(path)
+
+      raw = File.read(path)
+      front_matter, body = FrontMatter.split(raw, path)
+      new(name: name, front_matter: front_matter, body: body)
+    rescue FrontMatter::Error => e
+      raise Error, e.message
+    end
+
+    attr_reader :name, :front_matter, :body
+
+    def initialize(name:, front_matter:, body:)
+      @name = name
+      @front_matter = front_matter
+      @body = body
+    end
+
+    def render(content:, site:, page:)
+      context = Context.new(content: content, site: site, page: page)
+      result = ERB.new(@body, trim_mode: '-').result(context.binding_for_erb)
+      parent_name = @front_matter['layout']
+      return result unless parent_name
+
+      Layout.find(parent_name).render(content: result, site: site, page: page)
+    end
+
+    class Context
+      INCLUDES_DIR = '_includes'
+
+      attr_reader :content, :site, :page
+
+      def initialize(content:, site:, page:)
+        @content = content
+        @site = site
+        @page = page
+      end
+
+      def binding_for_erb
+        binding
+      end
+
+      def partial(name)
+        path = File.join(INCLUDES_DIR, name)
+        raise Error, "include '#{name}' not found at #{path}" unless File.exist?(path)
+
+        ERB.new(File.read(path), trim_mode: '-').result(binding_for_erb)
+      end
+    end
+  end
+end

data/lib/ottogen/otto.rb

@@ -1,42 +1,56 @@
+# frozen_string_literal: true
+
 require 'thor'
-require_relative './ottogen'
+require_relative 'ottogen'
 
 module Ottogen
   class Otto < Thor
-    desc "init [DIR]", "Initialize a new otto static site in DIR (defaults to the current directory)"
-    def init(dir=nil)
+    desc 'init [DIR]', 'Initialize a new otto static site in DIR (defaults to the current directory)'
+    def init(dir = nil)
       Ottogen.init(dir)
     end
 
-    desc "build", "Build the static site"
+    desc 'build', 'Build the static site'
+    option :drafts, type: :boolean, default: false, desc: 'Include drafts from _drafts/'
     def build
-      Ottogen.build
+      Ottogen.build(drafts: options[:drafts])
     end
 
-    map "b" => :build
+    map 'b' => :build
 
-    desc "generate PAGE", "Generate a new page"
+    desc 'generate PAGE', 'Generate a new page'
     def generate(page)
       Ottogen.generate(page)
     end
 
-    map "g" => :generate
+    map 'g' => :generate
 
-    desc "clean", "Clean the static site"
+    desc 'clean', 'Clean the static site'
     def clean
       Ottogen.clean
     end
 
-    desc "watch", "Watch changes to static site"
+    desc 'watch', 'Watch changes to static site'
+    option :drafts, type: :boolean, default: false, desc: 'Include drafts from _drafts/'
     def watch
-      Ottogen.watch
+      Ottogen.watch(drafts: options[:drafts])
     end
 
-    desc "serve", "Serve the static site"
+    desc 'serve', 'Serve the static site'
     def serve
       Ottogen.serve
     end
 
-    map "s" => :serve
+    map 's' => :serve
+
+    desc 'post TITLE', "Generate a new post in _posts/ with today's date"
+    def post(title)
+      Ottogen.new_post(title)
+    end
+
+    desc 'doctor', 'Check the project for common configuration problems'
+    def doctor
+      Ottogen.doctor
+    end
   end
 end