ottogen 0.1.0 → 1.0.0

data/lib/ottogen/ottogen.rb

@@ -1,51 +1,191 @@
+# frozen_string_literal: true
+
 require 'asciidoctor'
+require 'date'
 require 'fileutils'
 require 'listen'
+require 'webrick'
+
+require_relative 'collection_item'
+require_relative 'config'
+require_relative 'layout'
+require_relative 'page'
+require_relative 'permalink'
+require_relative 'post'
+require_relative 'scaffold'
 
 module Ottogen
   class Ottogen
-    BUILD_DIR = '_build'.freeze
-    WELCOME = <<~ADOC
-= Welcome to Otto!
-
-Otto is a static site generator that uses AsciiDoc as a markup language.
-ADOC
-
-    def self.init
-      puts "✨ ..."
-      File.write("index.adoc", WELCOME)
-      puts "✅"
-    end
-
-    def self.build
-      puts "🔨 ..."
-      Dir.mkdir(BUILD_DIR) unless Dir.exist?(BUILD_DIR)
-      Dir.glob('**/*.adoc').map do |name|
-        name.split('.').first
-      end.each do |doc|
-        Asciidoctor.convert_file "#{doc}.adoc",
+    BUILD_DIR = '_build'
+
+    def self.init(dir)
+      puts '✨ Initializing static site...'
+      if !dir.nil? && Dir.exist?(dir)
+        puts '❌ Error: Directory already exists'
+        exit(1)
+      end
+
+      if dir.nil?
+        files_in_current_dir = Dir.glob('**/*')
+        unless files_in_current_dir.empty?
+          puts '❌ Error: Directory must be empty'
+          exit(1)
+        end
+        init_in_current_dir
+      else
+        init_with_dir(dir)
+      end
+
+      puts '✅'
+    end
+
+    def self.build(drafts: false)
+      puts '🔨 Building static site...'
+      error_if_not_otto_project
+      config = load_config(drafts: drafts)
+      FileUtils.mkdir_p(BUILD_DIR)
+      FileUtils.cp_r 'assets/', "#{BUILD_DIR}/assets"
+      documents_for(config).each { |doc| convert_document(doc, config) }
+      puts '✅'
+    end
+
+    def self.documents_for(config)
+      collection_items = config.collections.values.flat_map { |c| c.output? ? c.items : [] }
+      load_pages + config.posts + collection_items
+    end
+
+    def self.load_pages
+      Dir.glob('pages/**/*.adoc').map { |path| Page.read(path) }
+    rescue Page::Error => e
+      puts "❌ Error: #{e.message}"
+      exit(1)
+    end
+
+    def self.convert_document(doc, config)
+      apply_permalink(doc, config)
+      html = render_document(doc, config)
+      write_output(doc.output_path(BUILD_DIR), html)
+    rescue Layout::Error => e
+      puts "❌ Error in #{doc.path}: #{e.message}"
+      exit(1)
+    end
+
+    def self.apply_permalink(doc, config)
+      template = doc.front_matter['permalink']
+      template ||= config['permalink'] if doc.is_a?(Post)
+      return if template.nil?
+
+      doc.permalink = Permalink.expand(template, doc)
+    end
+
+    def self.render_document(doc, config)
+      layout_name = doc.front_matter['layout']
+      attributes = config.asciidoctor_attributes.merge(doc.asciidoctor_attributes)
+      body = Asciidoctor.convert(doc.body,
                                  safe: :safe,
-                                 mkdirs: true,
-                                 to_file: "#{BUILD_DIR}/#{doc}.html"
+                                 standalone: layout_name.nil?,
+                                 attributes: attributes)
+      return body unless layout_name
+
+      Layout.find(layout_name).render(content: body, site: config, page: doc)
+    end
+
+    def self.write_output(path, html)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, html)
+    end
+
+    def self.generate(page)
+      puts '📝 Generating a new page...'
+      error_if_not_otto_project
+      page_title = page.split('-').map(&:capitalize).join(' ')
+      File.write("pages/#{page}.adoc", "= #{page_title}\n")
+    end
+
+    def self.new_post(title)
+      error_if_not_otto_project
+      FileUtils.mkdir_p('_posts')
+      slug = Permalink.slugify(title)
+      date = Date.today
+      path = "_posts/#{date.iso8601}-#{slug}.adoc"
+      File.write(path, "---\ntitle: #{title}\ndate: #{date.iso8601}\n---\n\n")
+      puts "📝 Created #{path}"
+    end
+
+    def self.doctor
+      problems = collect_problems
+      if problems.empty?
+        puts '✅ All checks passed'
+      else
+        puts '❌ Problems:'
+        problems.each { |p| puts "  - #{p}" }
+        exit(1)
       end
-      puts "✅"
+    end
+
+    def self.collect_problems
+      problems = []
+      problems << '.otto marker missing (run `otto init` first)' unless File.exist?('.otto')
+      problems << 'config.yml missing' unless File.exist?('config.yml')
+      problems << 'pages/ directory missing' unless Dir.exist?('pages')
+      problems
     end
 
     def self.clean
-      puts "🧽 ..."
+      puts '🧽 Cleaning build directory...'
+      error_if_not_otto_project
       return unless Dir.exist?(BUILD_DIR)
+
       FileUtils.rmtree(BUILD_DIR)
-      puts "✅"
+      puts '✅'
+    end
+
+    def self.serve
+      puts '🤖 Starting server...'
+      error_if_not_otto_project
+      root = File.expand_path("#{Dir.pwd}/#{Ottogen::BUILD_DIR}")
+      server = WEBrick::HTTPServer.new Port: 8778, DocumentRoot: root
+      trap 'INT' do
+        server.shutdown
+      end
+      server.start
+    rescue Errno::EADDRINUSE
+      puts '❌ Server port already in use'
+      exit(1)
     end
 
-    def self.watch
-      puts "👀 Watching files..."
+    def self.watch(drafts: false)
+      puts '👀 Watching files...'
+      error_if_not_otto_project
       listener = Listen.to(Dir.pwd, ignore: [/_build/]) do |modified, added, removed|
         puts(modified: modified, added: added, removed: removed)
-        build
+        build(drafts: drafts)
       end
       listener.start
       sleep
     end
+
+    def self.init_with_dir(dir)
+      Dir.mkdir(dir)
+      Scaffold.write(dir)
+    end
+
+    def self.init_in_current_dir
+      Scaffold.write('.')
+    end
+
+    def self.error_if_not_otto_project
+      return if File.exist?('.otto')
+
+      puts '❌ Error: Current directory is not an otto project'
+      exit(1)
+    end
+
+    def self.load_config(drafts: false)
+      Config.load(drafts: drafts)
+    rescue Config::Error => e
+      puts "❌ Error: #{e.message}"
+      exit(1)
+    end
   end
 end

data/lib/ottogen/page.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative 'front_matter'
+
+module Ottogen
+  class Page
+    class Error < StandardError; end
+
+    def self.read(path)
+      raw = File.read(path)
+      front_matter, body = FrontMatter.split(raw, path)
+      new(path: path, front_matter: front_matter, body: body)
+    rescue FrontMatter::Error => e
+      raise Error, e.message
+    end
+
+    attr_reader :path, :front_matter, :body
+    attr_accessor :permalink
+
+    def initialize(front_matter:, body:, path: nil)
+      @path = path
+      @front_matter = front_matter
+      @body = body
+    end
+
+    def url
+      return @permalink.url if @permalink
+      return nil unless @path
+
+      "/#{@path.sub(%r{^pages/}, '').sub(/\.adoc\z/, '.html')}"
+    end
+
+    def output_path(build_dir)
+      return @permalink.output_path(build_dir) if @permalink
+
+      relative = @path.sub(%r{^pages/}, '').sub(/\.adoc\z/, '.html')
+      File.join(build_dir, relative)
+    end
+
+    def asciidoctor_attributes
+      attrs = @front_matter.transform_keys { |key| "page_#{key}" }
+      page_url = url
+      attrs['page_url'] = page_url if page_url
+      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/permalink.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Ottogen
+  class Permalink
+    TOKEN_PATTERN = /:(year|month|day|slug|title)/
+
+    TOKEN_RESOLVERS = {
+      ':year' => ->(doc) { doc.respond_to?(:date) && doc.date ? doc.date.strftime('%Y') : '' },
+      ':month' => ->(doc) { doc.respond_to?(:date) && doc.date ? doc.date.strftime('%m') : '' },
+      ':day' => ->(doc) { doc.respond_to?(:date) && doc.date ? doc.date.strftime('%d') : '' },
+      ':slug' => ->(doc) { doc.respond_to?(:slug) ? doc.slug.to_s : '' },
+      ':title' => ->(doc) { doc.respond_to?(:title) ? slugify(doc.title) : '' }
+    }.freeze
+
+    def self.expand(template, doc)
+      expanded = template.gsub(TOKEN_PATTERN) { |token| TOKEN_RESOLVERS.fetch(token).call(doc) }
+      new(expanded)
+    end
+
+    def self.slugify(str)
+      str.to_s.downcase.gsub(/[^a-z0-9]+/, '-').sub(/\A-/, '').sub(/-\z/, '')
+    end
+
+    attr_reader :path
+    alias url path
+
+    def initialize(path)
+      @path = path
+    end
+
+    def output_path(build_dir)
+      File.join(build_dir, @path.end_with?('/') ? "#{@path}index.html" : @path)
+    end
+  end
+end

data/lib/ottogen/post.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'date'
+
+require_relative 'front_matter'
+
+module Ottogen
+  class Post
+    class Error < StandardError; end
+
+    POSTS_DIR = '_posts'
+    DRAFTS_DIR = '_drafts'
+    FILENAME_PATTERN = /\A(\d{4})-(\d{2})-(\d{2})-(.+)\.adoc\z/
+
+    def self.read(path)
+      date, slug = parse_filename(path)
+      front_matter, body = FrontMatter.split(File.read(path), path)
+      new(path: path, date: date, slug: slug, front_matter: front_matter, body: body)
+    rescue FrontMatter::Error => e
+      raise Error, e.message
+    end
+
+    def self.read_draft(path)
+      slug = File.basename(path, '.adoc')
+      front_matter, body = FrontMatter.split(File.read(path), path)
+      new(path: path, date: Date.today, slug: slug, front_matter: front_matter, body: body)
+    rescue FrontMatter::Error => e
+      raise Error, e.message
+    end
+
+    def self.parse_filename(path)
+      match = FILENAME_PATTERN.match(File.basename(path))
+      raise Error, "post filename must match YYYY-MM-DD-slug.adoc: #{path}" unless match
+
+      year, month, day, slug = match.captures
+      [Date.new(year.to_i, month.to_i, day.to_i), slug]
+    end
+    private_class_method :parse_filename
+
+    def self.discover(dir = POSTS_DIR)
+      return [] unless Dir.exist?(dir)
+
+      Dir.glob(File.join(dir, '*.adoc')).map { |path| read(path) }
+    end
+
+    def self.discover_drafts(dir = DRAFTS_DIR)
+      return [] unless Dir.exist?(dir)
+
+      Dir.glob(File.join(dir, '*.adoc')).map { |path| read_draft(path) }
+    end
+
+    attr_reader :path, :date, :slug, :front_matter, :body
+    attr_accessor :permalink
+
+    def initialize(path:, date:, slug:, front_matter:, body:)
+      @path = path
+      @date = date
+      @slug = slug
+      @front_matter = front_matter
+      @body = body
+    end
+
+    def title
+      @front_matter['title'] || slug.split('-').map(&:capitalize).join(' ')
+    end
+
+    def tags
+      Array(@front_matter['tags'])
+    end
+
+    def categories
+      Array(@front_matter['categories'])
+    end
+
+    def url
+      return @permalink.url if @permalink
+
+      "/#{slug}.html"
+    end
+
+    def output_path(build_dir)
+      return @permalink.output_path(build_dir) if @permalink
+
+      File.join(build_dir, "#{slug}.html")
+    end
+
+    def asciidoctor_attributes
+      attrs = @front_matter.transform_keys { |key| "page_#{key}" }
+      attrs['page_title'] ||= title
+      attrs['page_date'] = date.iso8601
+      attrs['page_slug'] = slug
+      attrs['page_url'] = url
+      attrs.delete('page_permalink')
+      attrs
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      name == :title || name == :url || @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/scaffold.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Ottogen
+  module Scaffold
+    CONFIG = <<~YAML
+      title: "Otto site"
+      description: ""
+      url: ""
+      baseurl: ""
+    YAML
+
+    WELCOME = <<~ADOC
+      ---
+      layout: default
+      title: Welcome
+      ---
+      = Welcome to Otto!
+
+      Otto is a static site generator that uses AsciiDoc as a markup language.
+    ADOC
+
+    DEFAULT_LAYOUT = <<~ERB
+      <!DOCTYPE html>
+      <html lang="en">
+        <head>
+          <meta charset="utf-8">
+          <title><%= page.respond_to?(:title) ? page.title : site.title %></title>
+        </head>
+        <body>
+          <%= content %>
+        </body>
+      </html>
+    ERB
+
+    DIRS = %w[assets pages _layouts _includes _data _posts _drafts].freeze
+    FILES = {
+      'config.yml' => CONFIG,
+      'pages/index.adoc' => WELCOME,
+      '_layouts/default.html.erb' => DEFAULT_LAYOUT
+    }.freeze
+
+    def self.write(root)
+      FileUtils.touch(File.join(root, '.otto'))
+      DIRS.each { |dir| FileUtils.mkdir_p(File.join(root, dir)) }
+      FILES.each { |path, content| File.write(File.join(root, path), content) }
+    end
+  end
+end

data/spec/ottogen/collection_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+RSpec.describe Ottogen::Collection do
+  describe '#items' do
+    it 'reads items from _<name>/' do
+      in_tmp_dir do
+        FileUtils.mkdir_p('_recipes')
+        File.write('_recipes/pizza.adoc', "= Pizza\n")
+        File.write('_recipes/bread.adoc', "= Bread\n")
+
+        collection = described_class.from_config('recipes', 'output' => true)
+
+        expect(collection.items.map(&:slug)).to contain_exactly('pizza', 'bread')
+      end
+    end
+
+    it 'returns an empty items list when the directory is missing' do
+      in_tmp_dir do
+        collection = described_class.from_config('recipes', 'output' => true)
+
+        expect(collection.items).to eq([])
+      end
+    end
+  end
+
+  describe '#output?' do
+    it 'reflects the output: setting' do
+      expect(described_class.from_config('a', 'output' => true).output?).to be true
+      expect(described_class.from_config('b', 'output' => false).output?).to be false
+      expect(described_class.from_config('c', {}).output?).to be false
+    end
+  end
+end
+
+RSpec.describe Ottogen::CollectionItem do
+  describe '#url' do
+    it 'is /<collection>/<slug>.html' do
+      in_tmp_dir do
+        FileUtils.mkdir_p('_recipes')
+        File.write('_recipes/pizza.adoc', "= Pizza\n")
+
+        item = described_class.read('_recipes/pizza.adoc', 'recipes')
+
+        expect(item.url).to eq('/recipes/pizza.html')
+      end
+    end
+  end
+
+  describe '#output_path' do
+    it 'is <build_dir>/<collection>/<slug>.html' do
+      in_tmp_dir do
+        FileUtils.mkdir_p('_recipes')
+        File.write('_recipes/pizza.adoc', "= Pizza\n")
+
+        item = described_class.read('_recipes/pizza.adoc', 'recipes')
+
+        expect(item.output_path('_build')).to eq('_build/recipes/pizza.html')
+      end
+    end
+  end
+end