plate 0.5.0

data/lib/plate/post.rb

@@ -0,0 +1,134 @@
+module Plate
+  # A model for each blog post
+  class Post < Page
+    # Returns the category for this blog post. If no category is given in the meta
+    # information, then the value for config[:default_category] is used.
+    #
+    # If no default category has been given, this will default to "Posts"
+    def category
+      default = self.meta[:category] || self.site.default_category
+    end
+    
+    # Category for this post, formatted to be URL-friendly
+    def category_for_url
+      self.category.to_s.dasherize.parameterize
+    end
+    
+    # Returns the date for this post, either from the filename or meta hash.
+    # If both are provided, the meta information takes precedence.
+    def date
+      result = nil
+      
+      if self.meta[:date]
+        result = self.meta[:date].to_s
+      elsif self.basename =~ /^(\d{4}-\d{2}-\d{2})-/
+        result = $1.to_s
+      end
+      
+      begin
+        return Time.parse(result)
+      rescue Exception => e
+        self.site.log("  ** Problem reading date for file #{relative_file} (#{e.message}). Post skipped.")        
+      end
+      
+      raise NoPostDateProvided
+    end
+    
+    def day
+      date.strftime('%d')
+    end
+    
+    # The full file path of where this file will be written to. (Relative to site root)
+    def file_path
+      "#{permalink}/index.html"
+    end
+    
+    def inspect
+      "#<#{self.class}:0x#{object_id.to_s(16)} name=#{name.to_s.inspect} date=#{date.to_s}>"
+    end
+    
+    def month
+      date.strftime('%m')  
+    end
+    
+    # Return the [relative] path for this post. Uses the +permalink_template+
+    # variable as the method for converting post data into a URL.
+    #
+    # The permalink_template can be set in the global config named 'permalink'.
+    #
+    # Available options are:
+    # 
+    # * `date` - The date of this post, formatted as YYYY-MM-DD
+    # * `title` - The title of this post, formatted for URL
+    # * `slug` - The filename slug
+    # * `year` - The 4-digit year of this post
+    # * `month` - The 2-digit month for this post
+    # * `day` - The 2-digit day of month for this post
+    # * `category` - The category for this post
+    #
+    # All values are formatted to be URL-safe. (No spaces, underscores or weird characters.)
+    def permalink(cache_buster = false)
+      return @permalink if @permalink and !cache_buster
+      
+      date = self.date
+  
+      # All of these variables can be put into a URL
+      permalink_attributes = { 
+        "date" => date.strftime('%Y-%m-%d'),
+        "slug" => slug,
+        "title" => title_for_url,
+        "year" => year,
+        "month" => month,
+        "day" => day,
+        "category" => category_for_url
+      }
+      
+      # Copy the permalink template as a starting point
+      result = permalink_template.clone
+      
+      # Replace all variables from the attributes into the template
+      permalink_attributes.each { |key, value| result.gsub!(/:#{Regexp.escape(key)}/, value) }
+       
+      # Remove any double slashes
+      result.gsub!(/\/\//, '/')
+      
+      # Remove file extensions, and cleanup URL
+      result = result.split('/').reject{ |segment| segment =~ /^\.+$/ }.join('/')
+      
+      @permalink = result
+    end
+    
+    # The template to use when generating the permalink.
+    def permalink_template
+      self.site.options[:permalink] || '/:category/:year/:month/:slug'
+    end
+
+    # Returns the URL slug to use for this blog post. 
+    #
+    # This will convert the file name from a format like:
+    #
+    #     2012-01-01-post-name.md
+    #
+    # To simply:
+    # 
+    #     post-name
+    def slug
+      name = self.basename.to_s.downcase.gsub(/^(\d{4}-\d{2}-\d{2})-/, '').split('.')[0]
+      name.dasherize.parameterize
+    end
+    
+    # Utility method to sanitize tags output. Tags are returned as an array.
+    def tags
+      @tags ||= (Array === self.meta[:tags] ? self.meta[:tags] : self.meta[:tags].to_s.strip.split(',')).collect(&:strip).sort
+    end
+    
+    def year
+      date.strftime('%Y')
+    end
+    
+    # Compare two posts, by date.
+    def <=>(other)
+      self.date <=> other.date
+    end
+  end
+end

data/lib/plate/post_collection.rb

@@ -0,0 +1,116 @@
+module Plate
+  # Post collection is an enumerable wrapper for the posts in a site.
+  class PostCollection
+    include Enumerable
+    
+    attr_accessor :categories, :tags, :archives
+    
+    def initialize
+      @posts = []
+      @categories = {}
+      @tags = {}
+      @archives = {}
+    end
+    
+    # Add a post to the collection
+    def <<(post)
+      add(post)
+    end
+    
+    # Add a post to the collection, then add its meta data to the summary.
+    def add(post)
+      return nil unless Post === post      
+      @posts << post      
+      process_post_meta(post)
+    end
+    
+    # A hash of all categories in this collection with the number of posts using each.
+    def category_counts
+      return @category_counts if @category_counts
+      
+      result = {}
+      
+      categories.keys.each do |key|
+        result[key] = categories[key].size
+      end
+      
+      @category_counts = result
+    end
+    
+    # A sorted array of all categories in this collection.
+    def category_list
+      @category_list ||= categories.keys.sort
+    end
+    
+    # Loop through each Post
+    def each
+      @posts.each { |post| yield post }
+    end
+    
+    # Returns the last post in the collection.
+    #
+    # Or, pass in a number to return in descending order that number of posts
+    def last(*args)
+      result = @posts.last(*args)
+      
+      if Array === result
+        result.reverse!
+      end
+      
+      result
+    end
+    
+    # Any methods called on the collection can be passed through to the Array
+    def method_missing(method, *args, &block)      
+      @posts.send(method, *args, &block)
+    end
+    
+    # Size of the posts collection
+    def size
+      @posts.size
+    end
+    
+    # A hash of all tags in this collection with the number of posts using that tag.
+    def tag_counts
+      return @tag_counts if @tag_counts
+      
+      result = {}
+      
+      tags.keys.each do |key|
+        result[key] = tags[key].size
+      end
+      
+      @tag_counts = result
+    end
+    
+    # A sorted array of all tag names in this collection.
+    def tag_list
+      @tag_list ||= tags.keys.sort
+    end
+    
+    def years
+      @years ||= archives.keys.sort
+    end
+    
+    protected
+      def process_post_meta(post)
+        # load up tags
+        post.tags.each do |tag|
+          @tags[tag] ||= []
+          @tags[tag] << post
+        end
+        
+        # load up category
+        @categories[post.category] ||= []
+        @categories[post.category] << post
+        
+        # load up yearly, monthly, and daily archives
+        @archives[post.year] ||= {}
+        @archives[post.year][post.month] ||= {}
+        @archives[post.year][post.month][post.day] ||= []
+        @archives[post.year][post.month][post.day] << post
+        
+        post
+      end
+  end
+end

data/lib/plate/sass_template.rb

@@ -0,0 +1,40 @@
+module Plate
+  # Mostly lifted from the default SassTemplate class at 
+  # https://github.com/rtomayko/tilt/blob/master/lib/tilt/css.rb
+  #
+  # Modifications have been made to use the site caching folder 
+  class SassTemplate < Tilt::Template
+    self.default_mime_type = 'text/css'
+
+    def self.engine_initialized?
+      defined? ::Sass::Engine
+    end
+
+    def initialize_engine
+      require_template_library 'sass'
+    end
+
+    def prepare      
+    end
+    
+    def syntax
+      :sass
+    end
+  
+    def evaluate(scope, locals, &block)
+      options = {
+        :filename => eval_file, 
+        :line => line, 
+        :syntax => syntax
+      }
+      
+      locals ||= {}
+      
+      if locals[:site] and locals[:site].cache_location
+        options[:cache_location] = File.join(locals[:site].cache_location, 'sass-cache')
+      end
+      
+      ::Sass::Engine.new(data, options).render
+    end
+  end
+end

data/lib/plate/scss_template.rb

@@ -0,0 +1,9 @@
+module Plate
+  class ScssTemplate < SassTemplate
+    self.default_mime_type = 'text/css'
+    
+    def syntax
+      :scss
+    end
+  end
+end

data/lib/plate/site.rb

@@ -0,0 +1,249 @@
+module Plate
+  require 'tilt'
+  
+  # This class contains everything you'll want to know about a site. It contains all data
+  # about the site, including blog posts, content pages, static files, assets and anything else.
+  class Site
+    include Callbacks
+    
+    attr_accessor :assets, :build_destination, :cache_location, :destination, 
+                  :layouts, :logger, :options, :pages, :posts, :source
+    
+    def initialize(source, destination, options = {})
+      # Setup source and destination for the site files
+      self.source = source
+      self.destination = destination
+      
+      # By default, the build goes into the destination folder.
+      # Override this to output to a different folder by default
+      self.build_destination = destination
+      
+      # Sanitize options
+      self.options = Hash === options ? options.clone : {}
+      self.options.symbolize_keys!
+            
+      clear
+    end
+    
+    %w( assets layouts pages posts ).each do |group|
+      class_eval "def #{group}; load!; @#{group}; end"
+    end
+    
+    def all_files
+      @all_files ||= self.assets + self.layouts + self.pages + self.posts
+    end
+    
+    # All extensions that are registered, as strings.
+    def asset_engine_extensions
+      @asset_engine_extensions ||= self.registered_asset_engines.keys.collect { |e| ".#{e}" }
+    end
+    
+    # Alphabetical list of all blog post categories used.
+    def categories
+      @categories ||= self.posts.collect(&:category).uniq.sort
+    end
+    
+    # Clear out all data related to this site. Prepare for a reload, or first time load.
+    def clear
+      @loaded = false
+      @tags_counts = nil
+      @default_layout = nil
+      
+      self.assets = []
+      self.layouts = []
+      self.pages = []
+      self.posts = PostCollection.new
+    end
+    
+    # The default blog post category
+    def default_category
+      options[:default_category] || 'Posts'
+    end
+    
+    # The default layout for all pages that do not specifically name their own
+    def default_layout
+      return nil if self.layouts.size == 0
+      return @default_layout if @default_layout
+      
+      layout ||= self.layouts.reject { |l| !l.default?  }
+      layout = self.layouts if layout.size == 0
+      
+      if Array === layout and layout.size > 0
+        layout = layout[0]
+      end
+      
+      @default_layout = layout
+    end
+    
+    # Find a page, asset or layout by source relative file path
+    def find(search_path)
+      self.all_files.find { |file| file == search_path }
+    end
+    
+    # Find all pages and posts with this layout
+    def find_by_layout(layout_name)
+      result = []
+      
+      result += self.pages.find_all { |page| page.layout == layout_name }
+      result += self.posts.find_all { |post| post.layout == layout_name }
+      
+      result
+    end
+    
+    # Find a specific layout by its file name. Any extensions are removed. 
+    def find_layout(layout_name)
+      search_name = layout_name.to_s.downcase.strip.split('.')[0]
+      matches = self.layouts.reject { |l| l.name != search_name }
+      matches.empty? ? self.default_layout : matches[0]
+    end
+    
+    def inspect
+      "#<#{self.class}:0x#{object_id.to_s(16)} source=#{source.to_s.inspect}>"
+    end
+    
+    # Load all data from the various source directories.
+    def load!
+      return if @loaded
+      
+      log("Loading site from source [#{source}]")
+      
+      run_callback :before_load
+      
+      self.load_pages!
+      self.load_layouts!
+      self.load_posts!
+      
+      run_callback :after_load
+      
+      @loaded = true
+    end
+    
+    # Returns true if the site has been loaded from the source directories.
+    def loaded?
+      !!@loaded
+    end
+    
+    # Write to the log if enable_logging is enabled
+    def log(message, style = :indent)
+      logger.send(:log, message, style) if logger and logger.respond_to?(:log)
+    end
+    
+    def page_engine_extensions
+      @page_engine_extensions ||= self.registered_page_engines.keys.collect { |e| ".#{e}" }
+    end
+    
+    def relative_path(file_or_directory)
+      file_or_directory.to_s.gsub(/^#{Regexp.quote(source)}(.*)$/, '\1')
+    end
+    
+    def reload!
+      clear
+      load!
+    end
+    
+    # Returns the asset engines that are available for use.
+    def registered_asset_engines
+      Plate.asset_engines
+    end
+    
+    # Returns the engines available for use in page and layout formatting.
+    def registered_page_engines
+      Plate.template_engines     
+    end
+    
+    # All tags used on this site
+    def tags
+      @tags ||= self.posts.tag_list
+    end
+    
+    def to_url(str)
+      result = str.to_s.strip.downcase
+      result = result.gsub(/[^-a-z0-9~\s\.:;+=_]/, '')
+      result = result.gsub(/[\.:;=+-]+/, '')
+      result = result.gsub(/[\s]/, '-')
+      result
+    end
+    alias_method :sanitize_slug, :to_url
+    
+    # The base URL for this site. The url can be set using the config option named `:base_url`.
+    #
+    # The base URL will not have any trailing slashes.
+    def url
+      return '' unless self.options[:base_url]
+      @url ||= self.options[:base_url].to_s.gsub(/(.*?)\/?$/, '\1')
+    end
+    
+    protected
+      # Load all layouts from layouts/
+      def load_layouts!(log = true)
+        @layouts = []
+        
+        Dir.glob(File.join(source, "layouts/**/*")).each do |file|
+          # If this 'file' is a directory, just skip it. We only care about files.
+          unless File.directory?(file)          
+            @layouts << Layout.new(self, file)
+          end
+        end
+
+        log("#{@layouts.size} layouts loaded") if log
+        
+        @layouts
+      end
+      
+      def load_pages!(log = true)
+        @assets = []
+        @pages = []
+        
+        # Load all pages, static pages and assets from content/
+        Dir.glob(File.join(source, "content/**/*")).each do |file|
+          # If this 'file' is a directory, just skip it. We only care about files.
+          unless File.directory?(file)
+            # Check for assets that need to be compiled. Currently only looks to see if the file
+            # ends in .coffee, .scss or .sass.
+            if asset_engine_extensions.include?(File.extname(file))
+              @assets << Asset.new(self, file)                                                
+            else
+              # Check for YAML meta header. If it starts with ---, then process it as a page
+              intro = File.open(file) { |f| f.read(3) }
+
+              # If file contents start with ---, then it is something we should process as a page.
+              if intro == "---"
+                @pages << Page.new(self, file)
+              else
+                @pages << StaticPage.new(self, file)
+              end
+            end
+          end
+        end
+
+        log("#{@assets.size} assets loaded") if log
+        log("#{@pages.size} pages and other files loaded") if log
+        
+        @pages
+      end
+      
+      # Load blog posts from posts/
+      def load_posts!(log = true)
+        @posts = PostCollection.new
+        
+        Dir.glob(File.join(source, "posts/**/*")).each do |file|
+          # If this 'file' is a directory, just skip it. We only care about files.
+          unless File.directory?(file)
+            # Check for YAML meta header. If it starts with ---, then process it as a page
+            intro = File.open(file) { |f| f.read(3) }
+
+            # If file contents start with ---, then it is something we should process as a page.
+            if intro == "---"
+              @posts.add(Post.new(self, file))
+            end
+          end          
+        end
+        
+        @posts.sort
+        
+        log("#{@posts.size} posts loaded") if log     
+        
+        @posts
+      end
+  end
+end