plate 0.5.0

data/lib/plate/helpers/url_helper.rb

@@ -0,0 +1,11 @@
+module Plate
+  # Includes basic helpers for managing URLs within your site.
+  module URLHelper  
+    # Cleans up a string to make it URl-friendly, removing all special 
+    # characters, spaces, and sanitizing to a dashed, lowercase string.
+    def sanitize_slug(str)
+      self.site.sanitize_slug(str)
+    end
+    alias_method :s, :sanitize_slug
+  end
+end

data/lib/plate/layout.rb

@@ -0,0 +1,169 @@
+module Plate
+  class Layout
+    attr_accessor :site, :file, :meta, :content
+    
+    def initialize(site, file = nil, load_on_initialize = true)
+      self.site = site
+      self.file = file
+      self.meta = {}
+      self.content = ""
+      
+      load! if load_on_initialize and file?
+    end
+    
+    # The name of the layound, without any path data
+    def basename
+      File.basename(self.file)
+    end
+    
+    # Is this layout the default layout, by name.
+    def default?
+      self.name.downcase.strip.start_with? "default"
+    end
+    
+    # The layout engine to use. Based off of the last file extension for this layout.
+    def engine
+      @engine ||= self.site.registered_page_engines[self.extension.gsub(/\./, '').to_sym]
+    end
+    
+    # The last file extension of this layout.
+    def extension
+      File.extname(self.file)
+    end
+    
+    # Does the file exist or not. 
+    def file?
+      return false if self.file.nil?
+      File.exists?(self.file)
+    end
+    
+    # A unique ID for this layout.
+    def id      
+      @id ||= Digest::MD5.hexdigest(relative_file)
+    end
+    
+    def inspect
+      "#<#{self.class}:0x#{object_id.to_s(16)} name=#{name.to_s.inspect}>"
+    end
+    
+    def load!
+      return if @loaded      
+      raise FileNotFound unless file?
+      
+      read_file!
+      read_metadata!
+      
+      @loaded = true
+    end
+    
+    # The name for a layout is just the lowercase, first part of the file name.
+    def name
+      return "" unless file?      
+      @name ||= self.basename.to_s.downcase.strip.split('.')[0]
+    end
+    
+    # A parent layout for this current layout file. If no layout is specified for this
+    # layout's parent, then nil is returned. If there is a parent layout for this layout,
+    # any pages using it will be rendered using this layout first, then sent to the parent
+    # for further rendering.
+    def parent
+      return @parent if @parent
+      
+      if self.meta[:layout]
+        @parent = self.site.find_layout(self.meta[:layout])
+      else
+        @parent = nil
+      end
+      
+      @parent
+    end
+    
+    def relative_file
+      @relative_file ||= self.site.relative_path(self.file)
+    end
+    
+    def reload!
+      @template = nil
+      @loaded = false
+      @name = nil
+      @engine = nil
+    end
+    
+    # Render the given content against the current layout template.
+    def render(content, page = nil, view = nil)
+      if self.template
+        view ||= View.new(self.site, page)
+        result = self.template.render(view) { content }
+        
+        if self.parent
+          result = self.parent.render(result, page, view)
+        end
+        
+        view = nil
+        
+        result
+      else
+        content.respond_to?(:rendered_content) ? content.rendered_content : content.to_s
+      end
+    end
+    
+    # The render template to use for this layout. A template is only used if the 
+    # file extension for the layout is a valid layout extension from the current
+    # site.
+    def template
+      return @template if @template
+            
+      if template?
+        @template = self.engine.new() { self.content }
+      else
+        nil
+      end
+    end
+    
+    # Does this file have the ability to be used as a template?
+    #
+    # This currently only works if the layout is a .erb file. Otherwise anything that
+    # calls this layout just returns the text it is given.
+    def template?
+      self.site.page_engine_extensions.include?(self.extension)
+    end
+    
+    # Is this layout equal to another page being sent?
+    def ==(other)
+      other = other.relative_file if other.respond_to?(:relative_file)
+      self.id == other or self.relative_file == other
+    end
+    
+    protected
+      # Read the file and store it in @content
+      def read_file!
+        self.content = file? ? File.read(self.file) : nil
+      end
+    
+      # Reads all content from a layouts's meta data. At this time, the layout only supports
+      # loading a parent layout. All other meta data is unused.
+      #
+      # Meta data is stored in YAML format within the head of a page after the -- declaration like so:
+      # 
+      #     ---
+      #     layout: default
+      #
+      #     # Start of layout content
+      def read_metadata!
+        return unless self.content
+        
+        begin
+          if matches = /^(---\n)(.*?)^\s*?$/m.match(self.content)
+            if matches.size == 3
+              self.content = matches.post_match.strip
+              self.meta = YAML.load(matches[2])
+              self.meta.symbolize_keys!
+            end
+          end        
+        rescue Exception => e
+          self.meta = {}
+          self.site.log("  ** Problem reading YAML for file #{relative_file} (#{e.message}). Meta data skipped")
+        end
+      end
+  end
+end

data/lib/plate/markdown_template.rb

@@ -0,0 +1,22 @@
+module Plate
+  # Generic markdown template, currently uses RedCarpet2
+  class MarkdownTemplate < Tilt::Template
+    self.default_mime_type = 'text/html'
+
+    def self.engine_initialized?
+      defined? ::Redcarpet::Render
+    end
+
+    def initialize_engine
+      require_template_library 'redcarpet'
+    end
+
+    def prepare
+      @engine = ::Redcarpet::Markdown.new(Redcarpet::Render::HTML, options)
+    end
+  
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.render(data)
+    end
+  end
+end

data/lib/plate/page.rb

@@ -0,0 +1,280 @@
+require 'digest'
+
+module Plate
+  class Page
+    include Callbacks
+    
+    attr_accessor :body, :content, :file, :meta, :site
+    
+    def initialize(site, file = nil, load_on_initialize = true)
+      self.site = site
+      self.file = file
+      self.meta = {}
+      self.content = ""
+          
+      load! if load_on_initialize and file?
+    end
+    
+    # Setup some shortcut getters for meta attributes
+    %w( title description tags category ).each do |meta_attribute|
+      class_eval <<-META
+        def #{meta_attribute}                         # def title
+          self.meta[:#{meta_attribute}]               #   self.meta[:title]
+        end                                           # end
+        
+        def #{meta_attribute}=(value)                 # def title=(value)
+          self.meta[:#{meta_attribute}] = value       #   self.meta[:title] = value
+        end                                           # end
+      META
+    end
+    
+    # The name of the file, without any path data
+    def basename
+      File.basename(self.file)
+    end
+    alias_method :name, :basename
+    
+    # The directory this page is located in, relative to the site root.
+    def directory
+      return @directory if @directory
+      
+      base = Pathname.new(File.join(self.site.source, 'content'))
+      current = Pathname.new(self.file)
+      
+      dirs = current.relative_path_from(base).to_s.split('/')
+      
+      if dirs.size > 1
+        dirs.pop
+        @directory = "/#{dirs.join('/')}"
+      else
+        @directory = "/"
+      end
+    end
+    
+    def engines
+      @engines ||= self.extensions.reverse.collect { |e| self.site.registered_page_engines[e.gsub(/\./, '').to_sym] }.reject { |e| !e }
+    end
+    
+    def extensions
+      @extensions ||= self.basename.scan(/\.[^.]+/)
+    end
+    
+    # Does the file exist or not. 
+    def file?
+      return false if self.file.nil?
+      File.exists?(self.file)
+    end
+    
+    # Returns just the file name, no extension.
+    def file_name
+      File.basename(self.file, '.*')
+    end
+    
+    # The full file path of where this file will be written to. (Relative to site root)
+    def file_path
+      return self.meta[:path] if self.meta.has_key?(:path)
+      return @file_path if @file_path
+      
+      result = directory
+      result << '/' unless result =~ /\/$/    
+      result << slug unless slug == "index"
+      
+      # Remove any double slashes
+      result.gsub!(/\/\//, '/')
+      
+      # Remove file extensions, and cleanup URL
+      result = result.split('/').reject{ |segment| segment =~ /^\.+$/ }.join('/')
+      
+      # Add a trailing slash
+      result << '/' unless result =~ /\/$/
+      
+      # Tack on index.html for the folder
+      result << "index.html"
+      @file_path = result
+    end
+    
+    def format_extension      
+      format = self.extensions.reverse.detect() { |e| !self.site.page_engine_extensions.include?(e) }
+      format = ".html" if format.nil?
+      format
+    end
+
+    # A unique ID for this page.
+    def id      
+      @id ||= Digest::MD5.hexdigest(relative_file)
+    end
+    
+    def inspect
+      "#<#{self.class}:0x#{object_id.to_s(16)} name=#{name.to_s.inspect}>"
+    end
+    
+    # Utility method to sanitize keywords output. Keywords are returned as an array.
+    def keywords
+      @keywords ||= (Array === self.meta[:keywords] ? self.meta[:keywords] : self.meta[:keywords].to_s.strip.split(',').collect(&:strip))
+    end
+    
+    # The layout to use when rendering this page. Returns nil if no default layout is available,
+    # or the layout has specifically been turned off within the config.
+    def layout
+      return nil if self.meta[:layout] == false
+      return @layout if @layout
+      
+      if self.meta[:layout]
+        @layout = self.site.find_layout(self.meta[:layout])
+      else
+        @layout = self.site.default_layout
+      end
+      
+      @layout
+    end
+    
+    # Has this page been loaded from file?
+    def loaded?
+      !!@loaded
+    end
+    
+    # Read the file data for this page
+    def load!
+      return if @loaded      
+      raise FileNotFound unless file?
+      
+      read_file!
+      read_metadata!
+      
+      @loaded = true
+    end
+    
+    def path
+      return '/' if self.file_path == '/index.html'
+      @path ||= self.file_path.sub(/(.*?)\/index\.html$/i, '\1')      
+    end
+    
+    # The file's source path, relative to site root.
+    def relative_file
+      @relative_file ||= self.site.relative_path(self.file)
+    end
+    
+    def reload!
+      @layout = nil
+      @loaded = false
+      @content = nil
+      @meta = {}
+      @keywords = nil
+      @rendered_content = nil
+      @body = nil
+      
+      load!
+    end
+    
+    # Returns the rendered body of this page, without the layout.
+    def rendered_body
+      return @body if @body
+      
+      result = ""
+      
+      around_callback :render do
+        result = self.content
+        
+        view = View.new(self.site, self)
+
+        self.engines.each do |engine|
+          template = engine.new(self.file) { result }
+          result = template.render(view, {})
+        end
+
+        view = nil
+        
+        @body = result
+      end
+      
+      @body
+    end
+    
+    def rendered_content
+      @rendered_content ||= self.apply_layout_to(rendered_body)
+    end
+    
+    # Name of the file to be saved. Just takes the current file name and removes any extensions.
+    def slug
+      self.basename.to_s.downcase.split('.')[0].dasherize.parameterize
+    end
+    
+    # The title from this page's meta data, turned into a parameter for use in a url.
+    def title_for_url
+      self.title.to_s.dasherize.parameterize
+    end
+    
+    # Returns this page's content
+    def to_s
+      self.inspect
+    end
+    
+    # The full URL of this page. Depends on the site's URL attribute and a config option of `:base_url`
+    def url
+      @url ||= "#{site.url}#{path}"
+    end
+    
+    # Write this compiled page to its destination file.
+    def write!      
+      path = File.join(site.build_destination, file_path)
+      
+      FileUtils.mkdir_p(File.dirname(path))
+      
+      File.open(path, 'w') do |f|
+        f.write(self.rendered_content)
+      end
+      
+      path
+    end
+    
+    # Is this page equal to another page being sent?
+    def ==(other)
+      other = other.relative_file if other.respond_to?(:relative_file)
+      self.id == other or self.relative_file == other
+    end
+    
+    protected
+      def apply_layout_to(content)
+        return content unless Layout === self.layout
+        self.layout.render(content, self)
+      end
+    
+      # Reading page details
+      # #####################################################################
+
+      # Read the file and store it in @content
+      def read_file!
+        self.content = file? ? File.read(self.file) : nil
+      end
+
+      # Reads all content from a page's meta data
+      #
+      # Meta data is stored in YAML format within the head of a page after the -- declaration like so:
+      # 
+      #     ---
+      #     title: "Hello"
+      #     description: "This is some meta data"
+      #     keywords: [ blah, blah ]
+      #     tags: [ blah, blah ]
+      #     category: Test
+      #     layout: default
+      #
+      #     # Start of actual content
+      def read_metadata!
+        return unless self.content
+        
+        begin
+          if matches = /^(---\n)(.*?)^\s*?$/m.match(self.content)
+            if matches.size == 3
+              self.content = matches.post_match.strip
+              self.meta = YAML.load(matches[2])
+              self.meta.symbolize_keys!
+            end
+          end        
+        rescue Exception => e
+          self.meta = {}
+          self.site.log("  ** Problem reading YAML for file #{relative_file} (#{e.message}). Meta data skipped")
+        end
+      end
+  end
+end