dimples 4.3.2 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6bdfb2eae683d3ef78e118e1096319d376db8434
-  data.tar.gz: 402257f0a0610c45baef474482acbe5dc8bf7d94
+SHA256:
+  metadata.gz: d7a2db6d510cc724696cd9255569144515c7ad9afd10b4a6da596f50f492d4f9
+  data.tar.gz: f55f43d79d5137c22ccea11e27c50be6de043ee794f3d3ae3ea212508da6bebb
 SHA512:
-  metadata.gz: 81064093be0ee7d0c8dc535d99a49e2be396fc5d00132b83c6b869161d5fed9afddd7fdda1616feb496f1d86e235865230ab0fe7de07525e123a188b75954882
-  data.tar.gz: fb65a564e482f7210beb4fa62c1e881847bbe1e0005ddaa1ce97661f4aae72a70a5ef77e0508f7b1e4ba4167c38aafdf999e9e0e03a7337effc565c476347333
+  metadata.gz: c86532b5690b9bc411d18357101799fe3e6e9c0a2c33ef9fabc2f3975b3fa9551cb45ae97768dcd96a6b0ec7388ceaba4bcdf0dc5a40b3a800ce10b3878c3085
+  data.tar.gz: 815be09d293fba723038a6fb0bbc6123434e03b34bdd7aa52438f276b234ea9e52cf661c2efa0c1120d72533c2149a81b2e5f8a87381ba1f666108b9166ed566

data/bin/dimples

@@ -18,7 +18,7 @@ valid_commands = %w[build]
 options = Trollop.options do
   version "dimples v#{Dimples::VERSION}"
   banner <<-BANNER
-A very, very simple static site generator.
+A simple static site generator.
 
 Usage:
 dimples <#{valid_commands.join('|')}> [options]
@@ -26,7 +26,6 @@ dimples <#{valid_commands.join('|')}> [options]
 Options:
 BANNER
   opt :config, 'Config file path', type: :string
-  opt :lib, 'Library file path', default: 'lib'
   opt :verbose, 'Verbose mode', default: false
 end
 
@@ -37,7 +36,7 @@ unless valid_commands.include?(command)
   Trollop.die "Command must be '#{valid_commands.join('\', \'')}'"
 end
 
-lib_path = File.join(Dir.pwd, options[:lib])
+plugins_path = File.join(Dir.pwd, 'plugins')
 config_path = options[:config] || File.join(Dir.pwd, 'config.json')
 
 if File.exist?(config_path)
@@ -53,43 +52,24 @@ else
   Trollop.die "Unable to find config file (#{config_path})"
 end
 
-config[:verbose_logging] = options[:verbose] if options[:verbose]
-
-if Dir.exist?(lib_path)
-  Dir.glob(File.join(lib_path, '**', '*.rb')) do |path|
+if Dir.exist?(plugins_path)
+  Dir.glob(File.join(plugins_path, '**', '*.rb')) do |path|
     require path
   end
 end
 
-site_klass_name = config.dig(:class_overrides, :site)
-
-site_klass = if site_klass_name
-               Object.const_get(site_klass_name)
-             else
-               Dimples::Site
-             end
-
-site = site_klass.new(config)
+site = Dimples::Site.new(config)
 
 case command.to_sym
 when :build
-  Dimples.logger.info("Building site at #{site.output_paths[:site]}...")
-
-  result = Benchmark.measure do
-    site.generate
-  end
-
-  if site.generated?
-    generation_time = result.real.round(2)
+  puts 'Building site...'
 
-    message = "\033[92mDone!\033[0m Site built in #{generation_time} second"
-    message += 's' if generation_time != 1
-    message += '.'
+  site.generate
 
-    Dimples.logger.info(message)
+  if site.errors.empty?
+    puts 'Done! Your site has been built.'
   else
-    site.errors.each do |error|
-      Dimples.logger.error(error)
-    end
+    puts 'Generation failed:'
+    site.errors.each { |error| puts error }
   end
 end

data/lib/dimples.rb

@@ -2,30 +2,19 @@
 
 $LOAD_PATH.unshift(__dir__)
 
-require 'benchmark'
-require 'fileutils'
-require 'logger'
+require 'hashie'
 require 'tilt'
 require 'yaml'
 
 require 'dimples/frontable'
-require 'dimples/renderable'
 
 require 'dimples/category'
 require 'dimples/configuration'
 require 'dimples/errors'
-require 'dimples/logger'
 require 'dimples/page'
-require 'dimples/pagination'
+require 'dimples/pager'
+require 'dimples/plugin'
 require 'dimples/post'
+require 'dimples/renderer'
 require 'dimples/site'
 require 'dimples/template'
-
-# A static site generator.
-module Dimples
-  class << self
-    def logger
-      @logger ||= Dimples::Logger.new(STDOUT)
-    end
-  end
-end

data/lib/dimples/category.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 module Dimples
-  # A class that models a single interview category.
   class Category
     attr_accessor :name
     attr_accessor :slug
@@ -10,12 +9,13 @@ module Dimples
     def initialize(site, slug)
       @site = site
       @slug = slug
-      @name = @site.config[:category_names][slug.to_sym] || slug.capitalize
+      @name = @site.config.category_names[slug.to_sym] || slug.capitalize
+
       @posts = []
     end
 
     def inspect
-      "#<#{self.class} @slug=#{@slug} @name=#{@name}>"
+      "#<#{self.class} @slug=#{slug} @name=#{name}>"
     end
   end
 end

data/lib/dimples/configuration.rb

@@ -1,74 +1,47 @@
 # frozen_string_literal: true
 
 module Dimples
-  # A class that models a site's configuration.
-  class Configuration
-    def initialize(config = {})
-      @settings = Dimples::Configuration.default_settings
-
-      config.each_key do |key|
-        case @settings[key]
-        when Hash
-          @settings[key].merge!(config[key])
-        else
-          @settings[key] = config[key]
-        end
-      end
-    end
-
-    def [](key)
-      @settings[key]
-    end
-
-    def self.default_settings
+  module Configuration
+    def self.defaults
       {
-        source_path: Dir.pwd,
-        destination_path: File.join(Dir.pwd, 'site'),
-        verbose_logging: false,
-        class_overrides: { site: nil, post: nil },
-        rendering: {},
-        category_names: {},
         paths: default_paths,
+        generation: default_generation,
         layouts: default_layouts,
         pagination: default_pagination,
-        generation: default_generation,
-        date_formats: default_date_formats
-      }
-    end
-
-    def self.default_layouts
-      {
-        posts: 'posts',
-        post: 'post',
-        category: 'category',
-        year_archives: 'year_archives',
-        month_archives: 'month_archives',
-        day_archives: 'day_archives'
+        date_formats: default_date_formats,
+        feed_formats: default_feed_formats,
+        category_names: {},
+        rendering: {},
       }
     end
 
     def self.default_paths
       {
+        output: 'site',
         archives: 'archives',
         posts: 'archives/%Y/%m/%d',
         categories: 'archives/categories'
       }
     end
 
-    def self.default_pagination
-      {
-        per_page: 10
-      }
-    end
-
     def self.default_generation
       {
-        categories: true,
+        archives: true,
         year_archives: true,
         month_archives: true,
         day_archives: true,
-        feeds: true,
-        category_feeds: true
+        categories: true,
+        main_feed: true,
+        category_feeds: true,
+      }
+    end
+
+    def self.default_layouts
+      {
+        post: 'post',
+        category: 'category',
+        archive: 'archive',
+        date_archive: 'archive'
       }
     end
 
@@ -79,5 +52,16 @@ module Dimples
         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,14 +1,12 @@
 # frozen_string_literal: true
 
 module Dimples
-  module Errors
-    class PublishingError < StandardError
-    end
+  class PublishingError < StandardError
+  end
 
-    class RenderingError < StandardError
-    end
+  class RenderingError < StandardError
+  end
 
-    class GenerationError < StandardError
-    end
+  class GenerationError < StandardError
   end
 end

data/lib/dimples/frontable.rb

@@ -1,23 +1,18 @@
 # frozen_string_literal: true
 
 module Dimples
-  # A mixin class that handles reading and parsing front matter from a file.
   module Frontable
-    SKIPPED_METADATA_KEYS = %w[site path contents].freeze
+    def read_with_front_matter(path)
+      contents = File.read(path)
 
-    def read_with_front_matter
-      @contents = File.read(@path)
-
-      matches = @contents.match(/^(-{3}\n.*?\n?)^(-{3}*$\n?)/m)
-      return if matches.nil?
-
-      YAML.safe_load(matches[1]).each_pair do |key, value|
-        if !SKIPPED_METADATA_KEYS.include?(key) && respond_to?("#{key}=")
-          send("#{key}=", value)
-        end
+      if (matches = contents.match(/^(-{3}\n.*?\n?)^(-{3}*$\n?)/m))
+        metadata = Hashie.symbolize_keys(YAML.safe_load(matches[1]))
+        contents = matches.post_match.strip
+      else
+        metadata = {}
       end
 
-      @contents = matches.post_match.strip
+      [contents, metadata]
     end
   end
 end

data/lib/dimples/page.rb

@@ -1,67 +1,73 @@
 # frozen_string_literal: true
 
 module Dimples
-  # A class that models a single site page.
   class Page
     include Frontable
-    include Renderable
 
-    attr_accessor :path
-    attr_accessor :title
-    attr_accessor :filename
-    attr_accessor :extension
-    attr_accessor :layout
     attr_accessor :contents
-    attr_accessor :output_directory
+    attr_accessor :metadata
+    attr_accessor :path
 
     def initialize(site, path = nil)
       @site = site
-      @extension = 'html'
       @path = path
 
       if @path
-        @filename = File.basename(@path, File.extname(@path))
-        @output_directory = File.dirname(@path).sub(
-          @site.source_paths[:pages],
-          @site.output_paths[:site]
-        )
-
-        read_with_front_matter
+        @contents, @metadata = read_with_front_matter(@path)
       else
-        @filename = 'index'
         @contents = ''
-        @output_directory = @site.output_paths[:site]
+        @metadata = {}
       end
     end
 
-    def output_path
-      File.join(@output_directory, output_filename)
+    def filename
+      @metadata[:filename] || 'index'
     end
 
-    def output_filename
-      "#{@filename}.#{@extension}"
+    def extension
+      @metadata[:extension] || 'html'
     end
 
-    def url
-      absolute_output_directory = File.absolute_path(@output_directory)
+    def render(context = {})
+      metadata = @metadata.dup
+      metadata.merge!(context[:page]) if context[:page]
 
-      absolute_output_directory.sub(@site.output_paths[:site], '').tap do |url|
-        url[0] = '/' unless url[0] == '/'
-        url.concat('/') unless url[-1] == '/'
-        url.concat(output_filename) if filename != 'index'
-      end
+      context[:page] = Hashie::Mash.new(metadata)
+
+      renderer.render(context)
     end
 
-    def write(context = {})
-      FileUtils.mkdir_p(@output_directory) unless Dir.exist?(@output_directory)
+    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
-      error_message = "Failed to write #{path} (#{e.message})"
-      raise Errors::PublishingError, error_message
+      raise PublishingError, "Failed to publish file at #{output_path} (#{e})"
     end
 
     def inspect
-      "#<#{self.class} @output_path=#{output_path}>"
+      "#<#{self.class} @path=#{path}>"
+    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
   end
 end

data/lib/dimples/pager.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Dimples
+  class Pager
+    include Enumerable
+
+    attr_reader :current_page
+    attr_reader :previous_page
+    attr_reader :next_page
+    attr_reader :page_count
+    attr_reader :item_count
+
+    def initialize(url, posts, options = {})
+      @url = url
+      @posts = posts
+      @per_page = options[:per_page] || 10
+      @page_prefix = options[:page_prefix] || 'page'
+      @page_count = (posts.length.to_f / @per_page.to_i).ceil
+
+      step_to(1)
+    end
+
+    def each(&block)
+      (1..@page_count).each do |index|
+        block.yield step_to(index)
+      end
+    end
+
+    def step_to(page)
+      @current_page = (1..@page_count).cover?(page) ? page : 1
+      @previous_page = (@current_page - 1).positive? ? @current_page - 1 : nil
+      @next_page = @current_page + 1 <= @page_count ? @current_page + 1 : nil
+
+      @current_page
+    end
+
+    def posts_at(page)
+      @posts.slice((page - 1) * @per_page, @per_page)
+    end
+
+    def current_page_url
+      @current_page != 1 ? "#{@url}#{@page_prefix}#{@current_page}" : @url
+    end
+
+    def first_page_url
+      @url
+    end
+
+    def last_page_url
+      @page_count != 1 ? "#{@url}#{@page_prefix}#{@page_count}" : @url
+    end
+
+    def previous_page_url
+      return unless @previous_page
+      @previous_page != 1 ? "#{@url}#{@page_prefix}#{@previous_page}" : @url
+    end
+
+    def next_page_url
+      "#{@url}#{@page_prefix}#{@next_page}" if @next_page
+    end
+
+    def to_context
+      Hashie::Mash.new(
+        posts: posts_at(current_page),
+        current_page: @current_page,
+        page_count: @page_count,
+        post_count: @posts.count,
+        previous_page: @previous_page,
+        next_page: @next_page,
+        urls: {
+          current_page: current_page_url,
+          first_page: first_page_url,
+          last_page: last_page_url,
+          previous_page: previous_page_url,
+          next_page: next_page_url
+        }
+      )
+    end
+  end
+end