dimples 4.3.2 → 5.0.0

data/lib/dimples/plugin.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Dimples
+  class Plugin
+    EVENTS = %i[
+      post_write
+      page_write
+    ].freeze
+
+    def self.inherited(subclass)
+      (@subclasses ||= []) << subclass
+    end
+
+    def self.plugins(site)
+      @plugins ||= @subclasses&.map { |subclass| subclass.new(site) }
+    end
+
+    def self.process(site, event, item, &block)
+      plugins(site)&.each do |plugin|
+        plugin.process(event, item, &block) if plugin.supports_event?(event)
+      end
+
+      yield if block_given?
+    end
+
+    def initialize(site)
+      @site = site
+    end
+
+    def process(event, item, &block); end
+
+    def supported_events
+      []
+    end
+
+    def supports_event?(event)
+      supported_events.include?(event)
+    end
+  end
+end

data/lib/dimples/post.rb

@@ -1,47 +1,31 @@
 # frozen_string_literal: true
 
 module Dimples
-  # A class that models a single site post.
   class Post < Page
-    attr_accessor :slug
-    attr_accessor :summary
-    attr_accessor :categories
-    attr_accessor :year
-    attr_accessor :month
-    attr_accessor :day
-    attr_accessor :previous_post
-    attr_accessor :next_post
-    attr_reader :date
-
-    FILENAME_DATE = /(\d{4})-(\d{2})-(\d{2})-(.+)/
+    POST_FILENAME = /(\d{4})-(\d{2})-(\d{2})-(.+)/
 
     def initialize(site, path)
-      super(site, path)
+      super
 
-      parts = File.basename(path, File.extname(path)).match(FILENAME_DATE)
+      parts = File.basename(path, File.extname(path)).match(POST_FILENAME)
 
-      @filename = 'index'
-      @slug = parts[4]
-      @layout = @site.config[:layouts][:post]
+      @metadata[:layout] ||= @site.config.layouts.post
 
-      self.date = Date.new(parts[1].to_i, parts[2].to_i, parts[3].to_i)
-
-      @output_directory = File.join(
-        @date.strftime(@site.output_paths[:posts]),
-        @slug.to_s
-      )
+      @metadata[:date] = Date.new(parts[1].to_i, parts[2].to_i, parts[3].to_i)
+      @metadata[:slug] = parts[4]
+      @metadata[:categories] ||= []
     end
 
-    def date=(date)
-      @date = date
+    def year
+      @year ||= @metadata[:date].strftime('%Y')
+    end
 
-      @year = @date.strftime('%Y')
-      @month = @date.strftime('%m')
-      @day = @date.strftime('%d')
+    def month
+      @month ||= @metadata[:date].strftime('%m')
     end
 
-    def inspect
-      "#<#{self.class} @slug=#{@slug} @output_path=#{output_path}>"
+    def day
+      @day ||= @metadata[:date].strftime('%d')
     end
   end
 end

data/lib/dimples/renderer.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Dimples
+  class Renderer
+    def initialize(site, source)
+      @site = site
+      @source = source
+    end
+
+    def render(context = {}, body = nil)
+      context[:site] ||= @site
+      context[:pagination] ||= nil
+
+      output = engine.render(scope, context) { body }.strip
+      @source.metadata[:rendered_contents] = output
+
+      template = @site.templates[@source.metadata[:layout]]
+      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

data/lib/dimples/site.rb

@@ -1,283 +1,262 @@
 # frozen_string_literal: true
 
 module Dimples
-  # A class that models a single site.
   class Site
-    include Pagination
-
-    attr_accessor :source_paths
-    attr_accessor :output_paths
-    attr_accessor :config
-    attr_accessor :templates
-    attr_accessor :categories
-    attr_accessor :archives
-    attr_accessor :pages
-    attr_accessor :posts
-    attr_accessor :latest_post
-    attr_accessor :errors
+    attr_reader :config
+    attr_reader :categories
+    attr_reader :errors
+    attr_reader :paths
+    attr_reader :posts
+    attr_reader :pages
+    attr_reader :templates
+    attr_reader :latest_post
 
     def initialize(config = {})
-      @config = Dimples::Configuration.new(config)
-
-      @templates = {}
-      @categories = {}
-      @pages = []
-      @posts = []
-      @errors = []
-
-      @archives = { year: {}, month: {}, day: {} }
-      @latest_post = false
-
-      @source_paths = { root: File.expand_path(@config[:source_path]) }
-      @output_paths = { site: File.expand_path(@config[:destination_path]) }
-
-      %w[pages posts public templates].each do |path|
-        @source_paths[path.to_sym] = File.join(@source_paths[:root], path)
+      @config = Hashie::Mash.new(Configuration.defaults).deep_merge(config)
+
+      @paths = {}.tap do |paths|
+        paths[:base] = Dir.pwd
+        paths[:output] = File.join(paths[:base], @config.paths.output)
+        paths[:sources] = {}.tap do |sources|
+          %w[pages posts public templates].each do |type|
+            sources[type.to_sym] = File.join(paths[:base], type)
+          end
+        end
       end
 
-      %w[archives posts categories].each do |path|
-        @output_paths[path.to_sym] = File.join(
-          @output_paths[:site], @config[:paths][path.to_sym]
-        )
-      end
+      prepare
     end
 
     def generate
-      scan_files
-      prepare_output_directory
-
-      publish_pages unless @pages.count.zero?
+      prepare
 
-      unless @posts.count.zero?
-        publish_posts
-        publish_archives
-        publish_categories if @config[:generation][:categories]
-      end
+      read_templates
+      read_posts
+      read_pages
 
+      create_output_directory
       copy_assets
-    rescue Errors::RenderingError,
-           Errors::PublishingError,
-           Errors::GenerationError => e
-      @errors << e.message
+
+      publish_posts
+      publish_pages
+      publish_archives
+      publish_categories if @config.generation.categories
+    rescue PublishingError, RenderingError, GenerationError => error
+      @errors << error
     end
 
-    def generated?
-      @errors.count.zero?
+    def inspect
+      "#<#{self.class} @paths=#{paths}>"
     end
 
-    def scan_files
-      Dimples.logger.debug('Scanning files...') if @config[:verbose_logging]
+    private
 
-      scan_templates
-      scan_pages
-      scan_posts
-    end
+    def prepare
+      @archives = { year: {}, month: {}, day: {} }
 
-    def scan_templates
-      Dir.glob(File.join(@source_paths[:templates], '**', '*.*')).each do |path|
-        template = Dimples::Template.new(self, path)
+      @categories = {}
+      @templates = {}
 
-        parent_path = File.dirname(path)
-        if parent_path == @source_paths[:templates]
-          slug = template.slug
-        else
-          relative_path = parent_path.sub(@source_paths[:templates], '')[1..-1]
-          slug = relative_path.sub(File::SEPARATOR, '.') + ".#{template.slug}"
-        end
+      @pages = []
+      @posts = []
+      @errors = []
 
-        @templates[slug] = template
-      end
+      @latest_post = nil
     end
 
-    def scan_pages
-      Dir.glob(File.join(@source_paths[:pages], '**', '*.*')).each do |path|
-        @pages << scan_page(path)
-      end
-    end
+    def read_templates
+      @templates = {}
 
-    def scan_page(path)
-      Dimples::Page.new(self, path)
-    end
+      globbed_files(@paths[:sources][:templates]).each do |path|
+        basename = File.basename(path, File.extname(path))
+        dir_name = File.dirname(path)
 
-    def scan_posts
-      paths = Dir.glob(File.join(@source_paths[:posts], '*.*')).sort
+        unless dir_name == @paths[:sources][:templates]
+          basename = dir_name.split(File::SEPARATOR)[-1] + '.' + basename
+        end
 
-      paths.reverse_each do |path|
-        @posts << scan_post(path)
+        @templates[basename] = Template.new(self, path)
       end
+    end
 
-      @posts.each_index do |index|
-        if (index - 1) >= 0
-          @posts[index].next_post = @posts.fetch(index - 1, nil)
+    def read_posts
+      @posts = globbed_files(@paths[:sources][:posts]).sort.map do |path|
+        Post.new(self, path).tap do |post|
+          add_archive_post(post)
+          categorise_post(post)
         end
+      end.reverse
 
-        if (index + 1) < @posts.count
-          @posts[index].previous_post = @posts.fetch(index + 1, nil)
-        end
+      @latest_post = @posts[0]
+    end
+
+    def read_pages
+      @pages = globbed_files(@paths[:sources][:pages]).sort.map do |path|
+        Page.new(self, path)
       end
+    end
 
-      @latest_post = @posts.first
+    def add_archive_post(post)
+      archive_year(post.year) << post
+      archive_month(post.year, post.month) << post
+      archive_day(post.year, post.month, post.day) << post
     end
 
-    def scan_post(path)
-      post_class.new(self, path).tap do |post|
-        post.categories&.each do |slug|
-          @categories[slug] ||= Dimples::Category.new(self, slug)
-          @categories[slug].posts << post
-        end
+    def categorise_post(post)
+      post.categories.each do |slug|
+        slug_sym = slug.to_sym
 
-        archive_year(post.year) << post
-        archive_month(post.year, post.month) << post
-        archive_day(post.year, post.month, post.day) << post
+        @categories[slug_sym] ||= Category.new(self, slug)
+        @categories[slug_sym].posts << post
       end
     end
 
-    def prepare_output_directory
-      if Dir.exist?(@output_paths[:site])
-        FileUtils.remove_dir(@output_paths[:site])
-      end
+    def create_output_directory
+      FileUtils.remove_dir(@paths[:output]) if Dir.exist?(@paths[:output])
+      Dir.mkdir(@paths[:output])
+    rescue StandardError => e
+      message = "Couldn't prepare the output directory (#{e.message})"
+      raise GenerationError, message
+    end
 
-      Dir.mkdir(@output_paths[:site])
+    def copy_assets
+      return unless Dir.exist?(@paths[:sources][:public])
+      FileUtils.cp_r(File.join(@paths[:sources][:public], '.'), @paths[:output])
     rescue StandardError => e
-      error_message = "Couldn't prepare the output directory (#{e.message})"
-      raise Errors::GenerationError, error_message
+      raise GenerationError, "Failed to copy site assets (#{e.message})"
     end
 
     def publish_posts
-      if @config[:verbose_logging]
-        Dimples.logger.debug_generation('posts', @posts.length)
+      @posts.each do |post|
+        Plugin.process(self, :post_write, post) do
+          path = File.join(
+            @paths[:output],
+            post.date.strftime(@config.paths.posts),
+            post.slug
+          )
+
+          post.write(path)
+        end
       end
 
-      @posts.each(&:write)
-
-      paginate(
-        self,
-        @posts,
-        @output_paths[:archives],
-        @config[:layouts][:posts]
-      )
-
-      publish_posts_feeds if @config[:generation][:feeds]
+      publish_feeds(@posts, @paths[:output]) if @config.generation.main_feed
     end
 
     def publish_pages
-      if @config[:verbose_logging]
-        Dimples.logger.debug_generation('pages', @pages.length)
+      @pages.each do |page|
+        Plugin.process(self, :page_write, page) do
+          path = if page.path
+                   File.dirname(page.path).sub(
+                     @paths[:sources][:pages],
+                     @paths[:output]
+                   )
+                 else
+                   @paths[:output]
+                 end
+
+          page.write(path)
+        end
       end
-
-      @pages.each(&:write)
     end
 
-    def publish_categories
-      if @config[:verbose_logging]
-        Dimples.logger.debug_generation('category pages', @categories.length)
+    def publish_archives
+      if @config.generation.archives
+        paginate_posts(
+          @posts,
+          File.join(@paths[:output], @config.paths.archives),
+          @config.layouts.archive
+        )
       end
 
-      @categories.each_value do |category|
-        path = File.join(@output_paths[:categories], category.slug)
+      %w[year month day].each do |date_type|
+        next unless @config.generation["#{date_type}_archives"]
+        publish_date_archive(date_type.to_sym)
+      end
+    end
 
-        options = {
-          context: { category: category.slug },
-          title: category.name
-        }
+    def publish_date_archive(date_type)
+      @archives[date_type].each do |date, posts|
+        date_parts = date.split('-')
+        path = File.join(@paths[:output], @config.paths.archives, date_parts)
 
-        paginate(
-          self,
-          category.posts,
+        paginate_posts(
+          posts.reverse,
           path,
-          @config[:layouts][:category],
-          options
+          @config.layouts.date_archive,
+          page: {
+            title: posts[0].date.strftime(@config.date_formats[date_type]),
+            archive_date: posts[0].date,
+            archive_type: date_type
+          }
         )
       end
-
-      publish_category_feeds if @config[:generation][:category_feeds]
     end
 
-    def publish_archives
-      %w[year month day].each do |date_type|
-        date_archives_sym = "#{date_type}_archives".to_sym
-        next unless @config[:generation][date_archives_sym]
-
-        @archives[date_type.to_sym].each do |date, posts|
-          year, month, day = date.split('-')
-
-          dates = { year: year }
-          dates[:month] = month if month
-          dates[:day] = day if day
-
-          path = File.join(@output_paths[:archives], dates.values)
+    def publish_categories
+      @categories.each_value do |category|
+        path = File.join(
+          @paths[:output],
+          @config.paths.categories,
+          category.slug
+        )
 
-          layout = @config[:layouts][date_archives_sym]
-          date_format = @config[:date_formats][date_type.to_sym]
+        category_posts = category.posts.reverse
+        context = { page: { title: category.name, category: category } }
 
-          options = {
-            context: { archive_date: posts[0].date, archive_type: date_type },
-            title: posts[0].date.strftime(date_format)
-          }
+        paginate_posts(
+          category_posts,
+          path,
+          @config.layouts.category,
+          context
+        )
 
-          paginate(self, posts, path, layout, options)
-        end
+        publish_feeds(category_posts, path, context)
       end
     end
 
-    def publish_feeds(path, context)
-      feed_templates.each do |format|
-        next unless @templates[format]
+    def paginate_posts(posts, path, layout, context = {})
+      pager = Pager.new(
+        path.sub(@paths[:output], '') + '/',
+        posts,
+        @config.pagination
+      )
 
-        feed = Dimples::Page.new(self)
+      pager.each do |index|
+        page = Page.new(self)
+        page.layout = layout
 
-        feed.output_directory = path
-        feed.filename = 'feed'
-        feed.extension = @templates[format].slug
-        feed.layout = format
+        page_prefix = @config.pagination.page_prefix
+        page_path = if index == 1
+                      path
+                    else
+                      File.join(path, "#{page_prefix}#{index}")
+                    end
 
-        feed.write(context)
+        page.write(
+          page_path,
+          context.merge(pagination: pager.to_context)
+        )
       end
     end
 
-    def publish_posts_feeds
-      posts = @posts[0..@config[:pagination][:per_page] - 1]
-      publish_feeds(@output_paths[:site], posts: posts)
-    end
+    def publish_feeds(posts, path, context = {})
+      @config.feed_formats.each do |feed_format|
+        feed_layout = "feeds.#{feed_format}"
+        next unless @templates.key?(feed_layout)
 
-    def publish_category_feeds
-      @categories.each_value do |category|
-        path = File.join(@output_paths[:categories], category.slug)
-        posts = category.posts[0..@config[:pagination][:per_page] - 1]
+        page = Page.new(self)
 
-        publish_feeds(path, posts: posts, category: category.slug)
-      end
-    end
+        page.layout = feed_layout
+        page.feed_posts = posts.slice(0, @config.pagination.per_page)
+        page.filename = 'feed'
+        page.extension = feed_format
 
-    def feed_templates
-      @feed_templates ||= @templates.keys.select { |k| k =~ /^feeds\./ }
-    end
-
-    def copy_assets
-      if Dir.exist?(@source_paths[:public])
-        Dimples.logger.debug('Copying assets...') if @config[:verbose_logging]
-
-        path = File.join(@source_paths[:public], '.')
-        FileUtils.cp_r(path, @output_paths[:site])
+        page.write(path, context)
       end
-    rescue StandardError => e
-      raise Errors::GenerationError, "Site assets failed to copy (#{e.message})"
     end
 
-    def inspect
-      "#<#{self.class} " \
-      "@source_paths=#{@source_paths} " \
-      "@output_paths=#{@output_paths}>"
-    end
-
-    private
-
-    def post_class
-      @post_class ||= if @config[:class_overrides][:post]
-                        Object.const_get(config[:class_overrides][:post])
-                      else
-                        Dimples::Post
-                      end
+    def globbed_files(path)
+      Dir.glob(File.join(path, '**', '*.*'))
     end
 
     def archive_year(year)