dimples 6.6.0 → 7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8a5a0e150bc568f6593260d6af73dfcdfc2979ff7e39866d3cc798c706955ff
-  data.tar.gz: 7c5521a81ac0325d431c1027287bf216e4669b341bcf5e6f6fabfa9f05beb0a5
+  metadata.gz: 882aeff0d91ba61d58f331bedabeba0c865dbb7ef355c1fdafde7e1605113d2e
+  data.tar.gz: 8ddfc8ea5bcbce38a35c8d0153f96adc4866f5529a074884e966b92a65dce642
 SHA512:
-  metadata.gz: 73b0502dcdd803eef073c4d075d7f3d2eaa9f6a9b8897f1c5d21d0c49b7c3682c91aba70b7b89c4140c65a14df7e6a0ed83fdaa42b6925327521929cdd37f58b
-  data.tar.gz: 3750f6c5e82b6d4f84a659bb8f15a36c969cd4698eaa736946f4fd81d7a5a28ec49e3d3529820d6a0b1cd3b3ac6f2e786b83431b0de40bf21a16d60fbd505de3
+  metadata.gz: cc9caa2de2a10ac6a30f84876ad3a3e9bd070b2e3e9783f38763035d286ec46d55343fa6fbf5cb44c6b72fe3c67d773af7918cbcb714cdb10f2c4b4a6b52b1e4
+  data.tar.gz: 04510c31f0ee4de0d1e035ddf56003f12e4553bdaaf1b4a8f82d24c0344bae443443b8d4f73c58e6ae7c3a5447e73f734f315964c30dcb400f85b28fa9066042

data/bin/dimples

@@ -4,79 +4,11 @@
 $LOAD_PATH.unshift(File.join(__dir__, '..', 'lib'))
 
 require 'dimples'
-require 'dimples/version'
-require 'optimist'
-require 'json'
 
-trap('SIGINT') do
-  puts 'Generation cancelled!'
-  exit!
-end
+path = if ARGV[0]
+         File.expand_path(ARGV[0])
+       else
+         File.join(Dir.pwd(), 'site')
+       end
 
-valid_commands = %w[build]
-
-options = Optimist.options do
-  version "dimples v#{Dimples::VERSION}"
-  banner <<-BANNER
-A simple static site generator.
-
-Usage:
-dimples <#{valid_commands.join('|')}> [options]
-
-Options:
-  BANNER
-
-  opt :config, 'Config file path', type: :string
-  opt :source, 'Source directory', type: :string
-  opt :destination, 'Destination directory', type: :string
-end
-
-Optimist.educate if ARGV.empty?
-command = ARGV[0]
-
-unless valid_commands.include?(command)
-  Optimist.die "Command must be '#{valid_commands.join('\', \'')}'"
-end
-
-source_path = if options[:source]
-                File.expand_path(options[:source])
-              else
-                Dir.pwd
-              end
-
-config_path = options[:config] || File.join(source_path, 'config.json')
-
-unless File.exist?(config_path)
-  Optimist.die "Unable to find config file (#{config_path})"
-end
-
-begin
-  file_contents = File.read(config_path)
-  Optimist.die "Config file is empty (#{config_path})" if file_contents.empty?
-
-  config = JSON.parse(file_contents, symbolize_names: true)
-rescue JSON::ParserError
-  Optimist.die "Invalid or malformed config file (#{config_path})"
-end
-
-config[:source] = source_path
-
-if options[:destination]
-  config[:destination] = File.expand_path(options[:destination])
-end
-
-site = Dimples::Site.new(config)
-
-case command.to_sym
-when :build
-  puts 'Building site...'
-
-  site.generate
-
-  if site.errors.empty?
-    puts "Done! Your site has been built in #{site.paths[:destination]}."
-  else
-    puts 'Generation failed:'
-    site.errors.each { |error| puts error }
-  end
-end
+Dimples::Site.generate(path)

data/lib/dimples/document.rb

@@ -0,0 +1,70 @@
+require 'yaml'
+
+module Dimples
+  class Document
+    FRONT_MATTER_PATTERN = /^(-{3}\n.*?\n?)^(-{3}*$\n?)/m.freeze
+
+    attr_accessor :metadata, :contents, :path, :rendered_contents
+
+    def initialize(path = nil)
+      @path = path
+      @metadata = {}
+
+      if @path
+        @contents = File.read(path)
+
+        if matches = contents.match(FRONT_MATTER_PATTERN)
+          @metadata = YAML.load(matches[1], symbolize_names: true)
+          @contents = matches.post_match.strip
+        end
+      end
+    end
+
+    def filename
+      "#{basename}.#{extension}"
+    end
+
+    def basename
+      @metadata.fetch(:filename, 'index')
+    end
+
+    def extension
+      @metadata.fetch(:extension, 'html')
+    end
+
+    def layout
+      @metadata.fetch(:layout, nil)
+    end
+
+    def render(context = {}, content = '')
+      context_obj = Object.new
+      context.each do |key, value|
+        context_obj.instance_variable_set("@#{key}", value)
+      end
+
+      @rendered_contents = renderer.render(context_obj) { content }
+    end
+
+    private
+
+    def renderer
+      @renderer ||= begin
+                      callback = proc { contents }
+
+                      if @path
+                        Tilt.new(@path, {}, &callback)
+                      else
+                        Tilt::StringTemplate.new(&callback)
+                      end
+                    end
+    end
+
+    def method_missing(method_name, *args, &block)
+      if @metadata.key?(method_name)
+        @metadata[method_name]
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/dimples/page.rb

@@ -1,69 +1,6 @@
-# frozen_string_literal: true
+require_relative 'document'
 
 module Dimples
-  # A single page on a site.
-  class Page
-    attr_accessor :contents
-    attr_accessor :metadata
-    attr_accessor :path
-
-    def initialize(site, path = nil)
-      @site = site
-      @path = path
-
-      if @path
-        data = File.read(@path)
-        @contents, @metadata = FrontMatter.parse(data)
-      else
-        @contents = ''
-        @metadata = {}
-      end
-    end
-
-    def filename
-      @metadata[:filename] || 'index'
-    end
-
-    def extension
-      @metadata[:extension] || 'html'
-    end
-
-    def render(context = {})
-      metadata = @metadata.dup
-      metadata.merge!(context[:page]) if context[:page]
-
-      context[:page] = Hashie::Mash.new(metadata)
-
-      renderer.render(context)
-    end
-
-    def write(output_directory, context = {})
-      FileUtils.mkdir_p(output_directory) unless Dir.exist?(output_directory)
-      output_path = File.join(output_directory, "#{filename}.#{extension}")
-
-      File.write(output_path, render(context))
-    rescue SystemCallError => e
-      raise PublishingError, "Failed to publish file at #{output_path} (#{e})"
-    end
-
-    private
-
-    def renderer
-      @renderer ||= Renderer.new(@site, self)
-    end
-
-    def method_missing(method_name, *args, &block)
-      if @metadata.key?(method_name)
-        @metadata[method_name]
-      elsif (matches = method_name.match(/([a-z_]+)=/))
-        @metadata[matches[1].to_sym] = args[0]
-      else
-        super
-      end
-    end
-
-    def respond_to_missing?(method_name, include_private = false)
-      @metadata.key?(method_name) || method_name.match?(/([a-z_]+)=/) || super
-    end
+  class Page < Document
   end
 end

data/lib/dimples/pager.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
 module Dimples
-  # A paginated collection of posts that can be walked forward or backwards.
   class Pager
-    PER_PAGE_DEFAULT = 10
+    PER_PAGE = 5
 
     include Enumerable
 
@@ -11,37 +10,12 @@ module Dimples
     attr_reader :previous_page
     attr_reader :next_page
     attr_reader :page_count
-    attr_reader :item_count
-
-    def self.paginate(site, posts, path, layout, context = {})
-      pager = Pager.new(
-        path.sub(site.paths[:destination], '') + '/',
-        posts,
-        site.config.pagination
-      )
-
-      pager.each do |index|
-        page = Page.new(site)
-        page.layout = layout
-
-        page_path = if index == 1
-                      path
-                    else
-                      File.join(path, "page_#{index}")
-                    end
-
-        page.write(
-          page_path,
-          context.merge(pagination: pager.to_context)
-        )
-      end
-    end
 
-    def initialize(url, posts, options = {})
+    def initialize(url, posts)
       @url = url
       @posts = posts
-      @per_page = options[:per_page] || PER_PAGE_DEFAULT
-      @page_prefix = options[:page_prefix] || 'page_'
+      @per_page = PER_PAGE
+      @page_prefix = 'page_'
       @page_count = (posts.length.to_f / @per_page.to_i).ceil
 
       step_to(1)
@@ -94,7 +68,7 @@ module Dimples
     end
 
     def to_context
-      Hashie::Mash.new(
+      {
         posts: posts_at(current_page),
         current_page: @current_page,
         page_count: @page_count,
@@ -108,7 +82,7 @@ module Dimples
           previous_page: previous_page_url,
           next_page: next_page_url
         }
-      )
+      }
     end
   end
 end

data/lib/dimples/post.rb

@@ -1,38 +1,19 @@
-# frozen_string_literal: true
+require_relative 'document'
 
-module Dimples
-  # A single dated post on a site.
-  class Post < Page
-    POST_FILENAME = /(\d{4})-(\d{2})-(\d{2})-(.+)/.freeze
-
-    def initialize(site, path)
-      super
-
-      parts = File.basename(path, File.extname(path)).match(POST_FILENAME)
+require 'date'
 
-      @metadata[:layout] ||= @site.config.layouts.post
-
-      @metadata[:date] = Date.new(parts[1].to_i, parts[2].to_i, parts[3].to_i)
-      @metadata[:slug] = parts[4]
-      @metadata[:categories] ||= []
-      @metadata[:draft] ||= false
-    end
-
-    def url
-      path = date.strftime(draft ? @site.config.paths.drafts : @site.config.paths.posts)
-      "/#{path}/#{slug}/"
-    end
-
-    def year
-      @year ||= @metadata[:date].strftime('%Y')
+module Dimples
+  class Post < Document
+    def date
+      @metadata.fetch(:date, DateTime.now)
     end
 
-    def month
-      @month ||= @metadata[:date].strftime('%m')
+    def layout
+      @metadata.fetch(:layout, 'post')
     end
 
-    def day
-      @day ||= @metadata[:date].strftime('%d')
+    def slug
+      File.basename(@path, '.markdown')
     end
   end
 end

data/lib/dimples/site.rb

@@ -1,159 +1,125 @@
 # frozen_string_literal: true
 
+require_relative 'pager'
+
+require 'fileutils'
+require 'tilt'
+
 module Dimples
-  # A collection of pages, posts and templates that can generate a website.
   class Site
-    attr_reader :config
-    attr_reader :categories
-    attr_reader :errors
-    attr_reader :paths
-    attr_reader :posts
-    attr_reader :pages
-    attr_reader :archive
-    attr_reader :templates
-    attr_reader :latest_post
-
-    def initialize(config = {})
-      @config = Configuration.prepare(config)
-
-      @paths = {}.tap do |paths|
-        paths[:source] = File.expand_path(@config.source)
-        paths[:destination] = File.expand_path(Time.now.strftime(@config.destination))
-
-        %w[pages posts static templates].each do |type|
-          paths[type.to_sym] = File.join(paths[:source], type)
-        end
+    def self.generate(output_path)
+      new(output_path).generate
+    end
+
+    attr_accessor :posts, :categories
+
+    def initialize(output_path)
+      @paths = {
+        source: File.expand_path(Dir.pwd),
+        destination: File.expand_path(output_path)
+      }
+
+      %w[pages posts static templates].each do |type|
+        @paths[type.to_sym] = File.join(@paths[:source], type)
       end
 
-      prepare
+      scan_posts
+      scan_pages
+      scan_templates
     end
 
     def generate
-      prepare
+      if Dir.exist?(@paths[:destination])
+        puts "Error: The output directory (#{@paths[:destination]}) already exists."
+        return
+      end
 
-      read_templates
-      read_posts
-      read_pages
+      Dir.mkdir(@paths[:destination])
 
-      create_output_directory
-      copy_static_assets
+      generate_posts
+      generate_pages
+      generate_categories
 
-      publish_posts
-      publish_pages
-      publish_archives if @config.generation.year_archives
-      publish_categories if @config.generation.categories
-    rescue PublishingError, RenderingError, GenerationError => e
-      @errors << e
+      copy_assets
     end
 
-    def data
-      @config.data || {}
-    end
+    private
 
-    def inspect
-      "#<#{self.class} @paths=#{paths}>"
+    def read_files(path)
+      Dir[File.join(path, '**', '*.*')].sort
     end
 
-    private
+    def scan_posts
+      @posts = read_files(@paths[:posts]).map do |path|
+        Dimples::Post.new(path)
+      end
 
-    def prepare
-      @archive = Dimples::Archive.new
+      @posts.sort_by! { |post| post.date }.reverse!
 
       @categories = {}
-      @templates = {}
-
-      @pages = []
-      @posts = []
-      @errors = []
 
-      @latest_post = nil
+      @posts.each do |post|
+        post.categories.each do |category|
+          @categories[category] ||= []
+          @categories[category] << post
+        end
+      end
     end
 
-    def read_files(path)
-      Dir[File.join(path, '**', '*.*')].sort
+    def scan_pages
+      @pages = read_files(@paths[:pages]).map do |path|
+        Dimples::Page.new(path)
+      end
     end
 
-    def read_templates
-      @templates = {}
-
-      read_files(@paths[:templates]).each do |path|
-        basename = File.basename(path, File.extname(path))
-        dir_name = File.dirname(path)
-
-        unless dir_name == @paths[:templates]
-          basename = dir_name.split(File::SEPARATOR)[-1] + '.' + basename
+    def scan_templates
+      @templates = {}.tap do |templates|
+        read_files(@paths[:templates]).each do |path|
+          key = File.basename(path, '.erb')
+          templates[key] = Dimples::Template.new(path)
         end
-
-        @templates[basename] = Template.new(self, path)
       end
     end
 
-    def read_posts
-      @posts = read_files(@paths[:posts]).map do |path|
-        Post.new(self, path).tap do |post|
-          @archive.add_post(post)
-          categorise_post(post)
-        end
-      end.reverse
+    def write_file(path, content)
+      directory_path = File.dirname(path)
 
-      @latest_post = @posts[0]
+      Dir.mkdir(directory_path) unless Dir.exist?(directory_path)
+      File.write(path, content)
     end
 
-    def read_pages
-      @pages = read_files(@paths[:pages]).map { |path| Page.new(self, path) }
-    end
+    def generate_paginated_posts(posts, path, context = {})
+      pager = Dimples::Pager.new(path.sub(@paths[:destination], '') + '/', posts)
 
-    def categorise_post(post)
-      post.categories.each do |slug|
-        slug_sym = slug.to_sym
+      pager.each do |index|
+        page = Dimples::Page.new()
+        page.metadata[:layout] = 'posts'
 
-        @categories[slug_sym] ||= Category.new(self, slug)
-        @categories[slug_sym].posts << post
-      end
-    end
+        page_path = if index == 1
+                      path
+                    else
+                      File.join(path, "page_#{index}")
+                    end
 
-    def create_output_directory
-      if Dir.exist?(@paths[:destination])
-        FileUtils.rm_r(@paths[:destination], secure: true)
-      else
-        FileUtils.mkdir_p(@paths[:destination])
+        context.merge!(pagination: pager.to_context)
+        write_file(File.join(page_path, page.filename), render(page, context))
       end
-    rescue StandardError => e
-      message = "Couldn't prepare the output directory (#{e.message})"
-      raise GenerationError, message
     end
 
-    def copy_static_assets
-      return unless Dir.exist?(@paths[:static])
-
-      FileUtils.cp_r(File.join(@paths[:static], '.'), @paths[:destination])
-    rescue StandardError => e
-      raise GenerationError, "Failed to copy site assets (#{e.message})"
-    end
+    def generate_posts
+      directory_path = File.join(@paths[:destination], 'posts')
+      Dir.mkdir(directory_path)
 
-    def publish_posts
       @posts.each do |post|
-        path = File.join(@paths[:destination], post.url.split('/'))
-        post.write(path)
+        path = File.join(directory_path, post.slug, post.filename)
+        write_file(path, render(post, post: post))
       end
 
-      published_posts = @posts.select { |post| !post.draft }
-
-      if @config.generation.main_feed
-        publish_feeds(published_posts, @paths[:destination])
-      end
-
-      return unless @config.generation.paginated_posts
-
-      Dimples::Pager.paginate(
-        self,
-        published_posts,
-        File.join(@paths[:destination], @config.paths.paginated_posts),
-        @config.layouts.paginated_post
-      )
+      generate_paginated_posts(@posts, directory_path)
+      generate_feed(@posts.slice(0, 10), @paths[:destination])
     end
 
-    def publish_pages
+    def generate_pages
       @pages.each do |page|
         path = if page.path
                  File.dirname(page.path).sub(
@@ -164,82 +130,41 @@ module Dimples
                  @paths[:destination]
                end
 
-        page.write(path)
+        write_file(File.join(path, page.filename), render(page, page: page))
       end
     end
 
-    def publish_archives
-      @archive.years.each do |year|
-        publish_archive(year)
-        next unless @config.generation.month_archives
-
-        @archive.months(year).each do |month|
-          publish_archive(year, month)
-          next unless @config.generation.day_archives
+    def generate_categories
+      @categories.each do |category, posts|
+        category_path = File.join(@paths[:destination], 'categories', category)
 
-          @archive.days(year, month).each do |day|
-            publish_archive(year, month, day)
-          end
-        end
+        generate_paginated_posts(posts, category_path, category: category)
+        generate_feed(posts.slice(0, 10), category_path)
       end
     end
 
-    def publish_archive(year, month = nil, day = nil)
-      date_type = if day
-                    'day'
-                  elsif month
-                    'month'
-                  else
-                    'year'
-                  end
-
-      posts = @archive.posts_for_date(year, month, day)
-
-      date_parts = [year, month, day].compact
-      path = File.join(@paths[:destination], @config.paths.archives, date_parts)
-      layout = @config.layouts.date_archive
-
-      data = {
-        page: {
-          title: posts[0].date.strftime(@config.date_formats[date_type]),
-          archive_date: posts[0].date,
-          archive_type: date_type
-        }
-      }
+    def generate_feed(posts, path)
+      page = Dimples::Page.new()
+      page.metadata[:layout] = 'feed'
 
-      Dimples::Pager.paginate(self, posts.reverse, path, layout, data)
+      write_file(File.join(path, 'feed.atom'), render(page, posts: posts))
     end
 
-    def publish_categories
-      @categories.each_value do |category|
-        path = File.join(
-          @paths[:destination],
-          @config.paths.categories,
-          category.slug
-        )
-
-        category_posts = category.posts.reverse
-        context = { page: { title: category.name, category: category } }
-
-        Dimples::Pager.paginate(
-          self,
-          category_posts,
-          path,
-          @config.layouts.category,
-          context
-        )
-
-        publish_feeds(category_posts, path, context)
-      end
+    def copy_assets
+      return unless Dir.exist?(@paths[:static])
+      FileUtils.cp_r(File.join(@paths[:static], '.'), @paths[:destination])
     end
 
-    def publish_feeds(posts, path, context = {})
-      @config.feed_formats.each do |format|
-        feed = Feed.new(self, format)
+    def render(object, context = {}, content = nil)
+      context[:site] ||= self
+
+      output = object.render(context, content)
 
-        feed.feed_posts = posts.slice(0, @config.pagination.per_page)
-        feed.write(path, context)
+      if object.layout && @templates[object.layout]
+        output = render(@templates[object.layout], context, output)
       end
+
+      output
     end
   end
 end

data/lib/dimples/template.rb

@@ -1,29 +1,6 @@
-# frozen_string_literal: true
+require_relative 'document'
 
 module Dimples
-  # A single template used when rendering pages, posts and other templates.
-  class Template
-    attr_accessor :path
-    attr_accessor :contents
-    attr_accessor :metadata
-
-    def initialize(site, path)
-      @site = site
-      @path = path
-
-      data = File.read(path)
-      @contents, @metadata = FrontMatter.parse(data)
-    end
-
-    def render(context = {}, body = nil)
-      context[:template] ||= Hashie::Mash.new(@metadata)
-      renderer.render(context, body)
-    end
-
-    private
-
-    def renderer
-      @renderer ||= Renderer.new(@site, self)
-    end
+  class Template < Document
   end
 end

data/lib/dimples/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dimples
-  VERSION = '6.6.0'
+  VERSION = '7.0'
 end

data/lib/dimples.rb

@@ -2,22 +2,7 @@
 
 $LOAD_PATH.unshift(__dir__)
 
-require 'fileutils'
-require 'hashie'
-require 'tilt'
-require 'yaml'
-
-require 'dimples/archive'
-require 'dimples/category'
-require 'dimples/configuration'
-require 'dimples/errors'
-require 'dimples/frontmatter'
-require 'dimples/pager'
-require 'dimples/renderer'
-
 require 'dimples/page'
-require 'dimples/feed'
 require 'dimples/post'
 require 'dimples/template'
-
 require 'dimples/site'

metadata

@@ -1,43 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: dimples
 version: !ruby/object:Gem::Version
-  version: 6.6.0
+  version: '7.0'
 platform: ruby
 authors:
 - Daniel Bogan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-20 00:00:00.000000000 Z
+date: 2022-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: hashie
+  name: erubi
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '1.10'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.1'
-- !ruby/object:Gem::Dependency
-  name: optimist
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '1.10'
 - !ruby/object:Gem::Dependency
   name: tilt
   requirement: !ruby/object:Gem::Requirement
@@ -53,33 +39,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: codeclimate-test-reporter
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: erubis
+  name: redcarpet
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.7'
-  type: :development
+        version: '3.5'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: '3.5'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -94,20 +66,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 12.3.3
-- !ruby/object:Gem::Dependency
-  name: redcarpet
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.5'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.5'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -122,20 +80,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.10'
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.21'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.21'
 description: A simple tool for building static websites.
 email:
 - d+dimples@waferbaby.com
@@ -146,16 +90,10 @@ extra_rdoc_files: []
 files:
 - bin/dimples
 - lib/dimples.rb
-- lib/dimples/archive.rb
-- lib/dimples/category.rb
-- lib/dimples/configuration.rb
-- lib/dimples/errors.rb
-- lib/dimples/feed.rb
-- lib/dimples/frontmatter.rb
+- lib/dimples/document.rb
 - lib/dimples/page.rb
 - lib/dimples/pager.rb
 - lib/dimples/post.rb
-- lib/dimples/renderer.rb
 - lib/dimples/site.rb
 - lib/dimples/template.rb
 - lib/dimples/version.rb
@@ -178,7 +116,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: A basic static site generator

data/lib/dimples/archive.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module Dimples
-  # A collection of posts, organised by date.
-  class Archive
-    def initialize
-      @years = {}
-    end
-
-    def add_post(post)
-      year(post.year)[:posts] << post
-      month(post.year, post.month)[:posts] << post
-      day(post.year, post.month, post.day)[:posts] << post
-    end
-
-    def years
-      @years.keys
-    end
-
-    def months(year)
-      year(year)[:months].keys
-    end
-
-    def days(year, month)
-      month(year, month)[:days].keys
-    end
-
-    def posts_for_date(year, month = nil, day = nil)
-      if day
-        day_posts(year, month, day)
-      elsif month
-        month_posts(year, month)
-      else
-        year_posts(year)
-      end
-    end
-
-    def year_posts(year)
-      year(year)[:posts]
-    end
-
-    def month_posts(year, month)
-      month(year, month)[:posts]
-    end
-
-    def day_posts(year, month, day)
-      day(year, month, day)[:posts]
-    end
-
-    private
-
-    def year(year)
-      @years[year.to_s] ||= { months: {}, posts: [] }
-    end
-
-    def month(year, month)
-      year(year)[:months][month.to_s] ||= { days: {}, posts: [] }
-    end
-
-    def day(year, month, day)
-      month(year, month)[:days][day.to_s] ||= { posts: [] }
-    end
-  end
-end

data/lib/dimples/category.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Dimples
-  # A single post category for a site.
-  class Category
-    attr_reader :name
-    attr_reader :slug
-    attr_accessor :posts
-
-    def initialize(site, slug)
-      @site = site
-      @slug = slug
-      @name = @site.config.category_names[slug.to_sym] || slug.capitalize
-
-      @posts = []
-    end
-  end
-end

data/lib/dimples/configuration.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-module Dimples
-  # Default configuration options for a site.
-  module Configuration
-    def self.prepare(config)
-      Hashie::Mash.new(defaults).deep_merge(config)
-    end
-
-    def self.defaults
-      {
-        source: Dir.pwd,
-        destination: File.join(Dir.pwd, 'public'),
-        paths: default_paths,
-        generation: default_generation,
-        layouts: default_layouts,
-        pagination: default_pagination,
-        date_formats: default_date_formats,
-        feed_formats: default_feed_formats,
-        category_names: {},
-        rendering: {}
-      }
-    end
-
-    def self.default_paths
-      {
-        archives: 'archives',
-        paginated_posts: 'posts',
-        posts: 'archives/%Y/%m/%d',
-        drafts: 'archives/drafts/%Y/%m/%d',
-        categories: 'archives/categories'
-      }
-    end
-
-    def self.default_generation
-      {
-        paginated_posts: true,
-        year_archives: true,
-        month_archives: true,
-        day_archives: true,
-        categories: true,
-        main_feed: true,
-        category_feeds: true
-      }
-    end
-
-    def self.default_layouts
-      {
-        post: 'post',
-        category: 'category',
-        paginated_post: 'paginated_post',
-        archive: 'archive',
-        date_archive: 'archive'
-      }
-    end
-
-    def self.default_date_formats
-      {
-        year: '%Y',
-        month: '%Y-%m',
-        day: '%Y-%m-%d'
-      }
-    end
-
-    def self.default_feed_formats
-      ['atom']
-    end
-
-    def self.default_pagination
-      {
-        page_prefix: 'page_',
-        per_page: 10
-      }
-    end
-  end
-end

data/lib/dimples/errors.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Dimples
-  class PublishingError < StandardError
-  end
-
-  class RenderingError < StandardError
-  end
-
-  class GenerationError < StandardError
-  end
-end

data/lib/dimples/feed.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Dimples
-  # A single feed.
-  class Feed < Page
-    def initialize(site, format)
-      super(site)
-
-      self.filename = 'feed'
-      self.extension = format
-      self.layout = "feeds.#{format}"
-    end
-  end
-end

data/lib/dimples/frontmatter.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Dimples
-  # Adds the ability to parse front matter from a file.
-  class FrontMatter
-    FRONT_MATTER_PATTERN = /^(-{3}\n.*?\n?)^(-{3}*$\n?)/m.freeze
-
-    def self.parse(contents)
-      if (matches = contents.match(FRONT_MATTER_PATTERN))
-        metadata = Hashie.symbolize_keys(YAML.safe_load(matches[1]))
-        contents = matches.post_match.strip
-      else
-        metadata = {}
-      end
-
-      [contents, metadata]
-    end
-  end
-end

data/lib/dimples/renderer.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module Dimples
-  # A wrapper around Tilt, tied to a single post, page or template.
-  class Renderer
-    def initialize(site, source)
-      @site = site
-      @source = source
-    end
-
-    def render(context = {}, body = nil)
-      context[:site] ||= @site
-      context[:pagination] ||= nil
-
-      begin
-        output = engine.render(scope, context) { body }.strip
-      rescue StandardError => e
-        raise RenderingError,
-              "Unable to render #{@source.path || 'dynamic file'} (#{e})"
-      end
-
-      @source.metadata[:rendered_contents] = output
-
-      if @source.metadata[:layout]
-        template = @site.templates[@source.metadata[:layout]]
-      end
-
-      return output if template.nil?
-
-      template.render(context, output)
-    end
-
-    def engine
-      @engine ||= begin
-        callback = proc { @source.contents }
-
-        if @source.path
-          extension = File.extname(@source.path)
-          options = @site.config.rendering[extension.to_sym] || {}
-
-          Tilt.new(@source.path, options, &callback)
-        else
-          Tilt::StringTemplate.new(&callback)
-        end
-      end
-    end
-
-    def scope
-      @scope ||= Object.new.tap do |scope|
-        scope.instance_variable_set(:@site, @site)
-
-        scope.class.send(:define_method, :render) do |layout, locals = {}|
-          @site.templates[layout]&.render(locals)
-        end
-      end
-    end
-  end
-end