plate 0.5.0

data/lib/plate/callbacks.rb

@@ -0,0 +1,39 @@
+module Plate
+  module Callbacks
+    def self.included(base)
+      base.send(:include, InstanceMethods)
+      base.send(:extend, ClassMethods)
+    end
+    
+    module ClassMethods
+      def callbacks
+        @callbacks ||= {}
+      end
+      
+      def register_callback(name, method_name = nil, &block)
+        callbacks[name] ||= []
+        callbacks[name] << (block || method_name)
+      end
+    end
+    
+    module InstanceMethods
+      def around_callback(name, &block)
+        run_callback "before_#{name}".to_sym
+        block.call
+        run_callback "after_#{name}".to_sym
+      end
+      
+      def run_callback(name)
+        if callbacks = self.class.callbacks[name]
+          callbacks.each do |callback|
+            if Proc === callback
+              callback.call(self)
+            elsif self.respond_to?(callback)
+              self.send(callback)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plate/cli.rb

@@ -0,0 +1,203 @@
+module Plate
+  # The CLI class controls the behavior of plate when it is used as a command line interface.
+  class CLI
+    require 'optparse'
+    
+    attr_accessor :source, :destination, :args, :options
+    
+    def initialize(args = [])
+      @args = String === args ? args.split(' ') : args.dup
+      @options = {}
+      
+      # Some defaults
+      @source = Dir.pwd
+      @destination = File.join(@source, 'public')
+    end
+    
+    def builder
+      @builder ||= Builder.new(self.source, self.destination, self.options)
+    end
+    
+    # The current command to be run. Pulled from the args attribute.
+    def command
+      self.args.size > 0 ? self.args[0] : 'build'
+    end
+    
+    def parse_options!
+      options = {}
+
+      opts = OptionParser.new do |opts|
+        banner = "Usage: plate [command] [options]"
+        
+        opts.on('--destination [PATH]', '-d', 'Set the destination directory for this build.') do |d|
+          @destination = File.expand_path(d)
+        end
+
+        opts.on('--source [PATH]', '-s', 'Set the source directory for this build.') do |s|
+          @source = File.expand_path(s)
+        end
+
+        opts.on('--verbose', '-V', 'Show output about the generation of the site.') do
+          options[:verbose] = true
+        end
+
+        opts.on('--version', '-v', 'Show the current Plate version number.') do
+          puts "You're running Plate version #{Plate::VERSION}!"
+          exit 0
+        end
+        
+        opts.on('--watch', '-w', 'Watch the source directory for changes.') do
+          options[:watch] = true
+        end
+      end
+
+      opts.parse!(self.args)
+      
+      @options = options
+    end
+    
+    # Run the given command. If the command does not exist, nothing will be run.
+    def run
+      parse_options!
+      
+      command_name = "run_#{command}_command".to_sym
+      
+      if self.respond_to?(command_name)
+        # remove command name
+        self.args.shift
+        self.send(command_name)
+      else
+        puts "Command #{command} not found"
+        return false
+      end
+      
+      true
+    end
+    
+    class << self
+      def run!
+        new(ARGV).run
+      end
+    end
+    
+    protected
+      def process_file_change(event)
+        relative_path = builder.relative_path(event.path)        
+          
+        unless relative_path.start_with?('/public/')
+          if builder.reloadable?(relative_path)
+            case event.type
+            when :added
+              puts "  -> New File: #{relative_path}"
+              builder.rebuild!
+            when :modified
+              puts "  -> Changed File: #{relative_path}"
+              builder.render_file!(relative_path)
+            when :removed
+              puts "  -> Deleted File: #{relative_path}"
+              builder.rebuild!
+            end
+          else
+            puts "  -> Modified file [#{relative_path}]"
+            puts "     Re-run `plate build` to see the changes."
+          end
+        end
+      end
+    
+      def run_build_command
+        puts "Building your site from #{source} to #{destination}"
+        
+        builder.enable_logging = true if options[:verbose]
+        builder.render!
+        
+        if builder.items?
+          # If we want to watch directories, keep the chain open
+          if options[:watch]
+            puts "Initial site build complete. Watching #{source} for changes..."
+
+            dw = DirectoryWatcher.new(source, :pre_load => true, :glob => '/**/*')
+            dw.interval = 1
+            dw.add_observer { |*args| args.each { |event| process_file_change(event) } }
+            dw.start
+
+            trap('INT') { dw.stop and exit 0 }
+
+            loop { sleep 100 }
+          else
+            puts "Site build complete."
+          end
+        else
+          puts "** There seems to be no site content in this folder. Did you mean to create a new site?\n\n    plate new .\n\n"
+        end
+      end
+      
+      def run_new_command        
+        # Set the base root
+        root = './'
+        
+        if args.size > 0
+          root = args[0]
+        end
+        
+        puts "Generating new plate site at #{root}..."
+        
+        # The starting path for the new site
+        root_path = File.expand_path(root)
+        
+        # Create all folders needed for a base site.
+        %w(
+          /
+          config
+          content
+          layouts
+          posts
+        ).each do |dir|
+          action = File.directory?(File.join(root_path, dir)) ? "exists" : "create"          
+          puts "   #{action}   #{File.join(root, dir)}"
+          
+          if action == "create"
+            FileUtils.mkdir_p(File.join(root_path, dir))
+          end          
+        end
+        
+        # Create a blank layout file
+        create_template('layouts/default.erb', 'layout.erb', root, root_path)
+        
+        # Config file
+        create_template('config/plate.yml', 'config.yml', root, root_path)
+        
+        # Index page
+        create_template('content/index.md', 'index.md', root, root_path)
+        
+        puts "New site generated!"
+      end
+      
+      def run_post_command
+        title = args.size == 0 ? "" : args[0]
+        slug = title.parameterize
+        date = Time.now
+        filename = File.join(self.source, 'posts', date.strftime('%Y/%m'), "#{date.strftime('%Y-%m-%d')}-#{slug}.md")
+        content = %Q(---\ntitle: "#{title}"\ndate: #{date.strftime('%Y-%m-%d %H:%M:%S')}\ntags: []\n\n# #{title}\n\n)
+        
+        FileUtils.mkdir_p(File.dirname(filename))
+        File.open(filename, 'w') { |f| f.write(content) }
+        
+        puts "New post file added [#{filename}]"
+      end
+      
+      def create_template(path, template, root, root_path)
+        action = File.exist?(File.join(root_path, path)) ? "exists" : "create"          
+        puts "   #{action}   #{File.join(root, path)}"
+        
+        if action == "create"
+          template_root = File.expand_path(File.join(File.dirname(__FILE__), '..', 'templates'))
+          
+          contents = File.read(File.join(template_root, template))
+          
+          unless contents.to_s.blank?
+            File.open(File.join(root_path, path), 'w') { |f| f.write(contents) }
+          end
+        end        
+      end
+  end
+end

data/lib/plate/dynamic_page.rb

@@ -0,0 +1,27 @@
+module Plate
+  class DynamicPage < Page    
+    attr_accessor :file_path, :locals
+    
+    def initialize(site, destination_path, meta = {})
+      self.site = site
+      self.file_path = destination_path
+      self.meta = meta      
+      self.content = ""
+      self.locals = {}
+    end
+    
+    def locals=(hash)
+      @locals = hash.symbolize_keys!
+    end
+    
+    def rendered_body
+      self.content
+    end
+    
+    # Check to see if a method called is in your locals.
+    def method_missing(sym, *args)
+      return locals[sym] if locals.has_key?(sym)
+      super
+    end
+  end
+end

data/lib/plate/engine.rb

@@ -0,0 +1,25 @@
+module Plate
+  module Engine
+    # All engines that have been registered for markup templating
+    def asset_engines
+      @engines[:assets].dup
+    end
+    
+    # Register a new asset engine.
+    def register_asset_engine(extension, klass)
+      @engines[:assets] ||= {}
+      @engines[:assets][extension] = klass
+    end
+    
+    # Register a new templating engine.
+    def register_template_engine(extension, klass)
+      @engines[:templates] ||= {}
+      @engines[:templates][extension] = klass
+    end
+    
+    # All engines that have been registered for markup templating
+    def template_engines
+      @engines[:templates].dup
+    end
+  end
+end

data/lib/plate/errors.rb

@@ -0,0 +1,10 @@
+module Plate
+  class SourceNotFound < StandardError
+  end
+  
+  class FileNotFound < StandardError
+  end
+  
+  class NoPostDateProvided < StandardError
+  end
+end

data/lib/plate/haml_template.rb

@@ -0,0 +1,18 @@
+module Plate
+  # Mostly lifted from the default SassTemplate class at 
+  # https://github.com/rtomayko/tilt/blob/master/lib/tilt/haml.rb
+  #
+  # Modifications have been made to default to html5 style
+  class HamlTemplate < Tilt::HamlTemplate
+    def prepare
+      options = @options.merge(:filename => eval_file, :line => line)
+      @engine = ::Haml::Engine.new(data, haml_options)
+    end
+
+    private
+      def haml_options
+        # Default style to html5 and double quoted attributes    
+        options.merge(:format => :html5, :attr_wrapper => '"')
+      end
+  end
+end

data/lib/plate/helpers/blogging_helper.rb

@@ -0,0 +1,102 @@
+require 'cgi'
+
+module Plate
+  # Various view helpers related to blogging. Tags, categories, archives and the like.
+  module BloggingHelper
+    # Returns a customized hash of post archives for the given category
+    def category_archives(category)
+      result = {}
+      
+      posts.archives.keys.each do |year|
+        posts.archives[year].keys.each do |month|
+          posts.archives[year][month].keys.each do |day|
+            posts.archives[year][month][day].each do |post|
+              if post.category == category
+                result[year] ||= {}
+                result[year][month] ||= {}
+                result[year][month][day] ||= []
+                result[year][month][day] << post
+              end
+            end
+          end
+        end
+      end
+      
+      result
+    end
+    
+    # Escape markup for use in XML or HTML
+    def html_escape(text)
+      ::CGI.escapeHTML(text)
+    end
+    alias_method :xml_escape, :html_escape
+    
+    # Grab the next blog post.
+    #
+    # Returns nil if this is the last post.
+    def next_post
+      return nil if post_index < 0 or post_index >= post_count
+      @next_post ||= self.posts[post_index + 1]
+    end
+    
+    # Grab the post previous to this one. 
+    #
+    # Returns nil if this is the first post.
+    def previous_post
+      return nil if post_index < 1      
+      @previous_post ||= self.posts[post_index - 1]
+    end
+    
+    # The total number blog posts
+    def post_count
+      @post_count ||= self.posts.length
+    end
+    
+    # Returns a number of where this post is in all posts
+    def post_index
+      @post_index ||= self.posts.index(self.post)
+    end
+    
+    # Find all posts for the given year, month and optional category.
+    def posts_for_month(year, month, category = nil)
+      result = []
+      
+      if months = self.posts.archives[year.to_s]
+        if month = months[month.to_s]
+          month.each_value do |day|
+            result << day.select { |post| category == nil or post.category == category }
+          end
+        end
+      end
+      
+      result.flatten
+    end
+    
+    # Find all posts for the given year and optional category.
+    def posts_for_year(year, category = nil)
+      result = []
+      
+      if months = self.posts.archives[year.to_s]
+        months.each_value do |month|
+          month.each_value do |day|
+            result << day.select { |post| category == nil or post.category == category }
+          end
+        end
+      end
+      
+      result.flatten
+    end
+    
+    def years_for_category(category)
+      result = []
+      
+      self.posts.archives.keys.each do |year|
+        if posts_for_year(year, category).size > 0
+          result << year 
+        end
+      end
+      
+      result.sort
+    end
+  end
+end

data/lib/plate/helpers/meta_helper.rb

@@ -0,0 +1,71 @@
+module Plate
+  # Methods related to the meta-data of a page
+  module MetaHelper
+    # Is there a description available for this page?
+    def description?
+      !page.description.to_s.blank?
+    end
+    
+    # Sanitize keywords output into a comma separated list string
+    def keywords      
+      page.keywords.join(", ")
+    end
+    
+    # Are there keywords available on this page?
+    def keywords?
+      page.keywords.length > 0
+    end
+    
+    # Returns a description meta tag if there is a description available for
+    # this page.
+    def meta_description_tag
+      %Q(<meta name="description" content="#{description}">) if description?
+    end
+    
+    # Returns a keywords meta tag if there are keywords for this page.
+    def meta_keywords_tag
+      %Q(<meta name="keywords" content="#{keywords}">) if keywords?
+    end
+    
+    # Output the standard meta tags (keywords and description) to a page.
+    # Omits any tags with blank data.
+    # 
+    # Optionally pass in a list of which tags to display.
+    #
+    # @example Show all available meta tags
+    #     <%= meta_tags %>
+    #
+    # @example Show only the keywords tag
+    #     <%= meta_tags :keywords %>
+    #
+    # @example Show both keywords and description (default)
+    #
+    #     <%= meta_tags :keywords, :description %>
+    #
+    # @overload meta_tags([tags...], options)
+    #   @param [optional, Symbol] tags Pass in any number of symbols to output those tags.
+    #   @param [optional, Hash] options Customize display options
+    #   @option options [String] :joiner String to use to join together multiple tags.
+    def meta_tags(*args)
+      options = args.extract_options!
+      options = options.reverse_merge({
+        :joiner => "\n"
+      })
+      
+      tags = args.length > 0 ? args : %w( description keywords )
+      
+      result = []
+      
+      tags.each do |tag|        
+        result << self.send("meta_#{tag}_tag") if self.respond_to?("meta_#{tag}_tag")
+      end
+      
+      result.join(options[:joiner]).strip
+    end
+    
+    # Does this page have a title?
+    def title?
+      !page.title.to_s.blank?
+    end
+  end
+end