plate 0.7.0 → 0.7.1

data/CHANGELOG.md

@@ -1,4 +1,9 @@
-## Plate 0.7.0 (Unreleased)
+## Plate 0.7.1
+
+* Added DSL method `write` to create a dynamic page.
+* Added DSL method `archives` to create category, monthly, and yearly post archives.
+
+## Plate 0.7.0
 
 * Added support for view partials
 * Reload page layout when re-rendering a page

data/README.md

@@ -8,7 +8,7 @@ In addition to basic formatting with Markdown, Plate also supports generating mo
 
 Plate is a command line utility installed as a Ruby Gem. Installation requires Ruby 1.8.7, 1.9.2 or 1.9.3.
 
-Current version is **0.7.0**
+Current version is **0.7.1**
 
 ## Installation
 
@@ -72,7 +72,7 @@ When creating a new post, you can choose to put it in the *drafts* folder, inste
 ```
 publish: true
 ```
-    
+
 On the next site build, your post will automatically be moved to the appropriate spot in the *posts* folder.
 
 By default, the `plate post [Title]` command does not use the drafts folder. To enable draft usage by default when a new post is generated, just change the following line in the `config/plate.yml` file to true:

data/lib/plate/dsl.rb

@@ -23,6 +23,68 @@ module Plate
       end
     end
 
+    # Used for writing dynamic pages. Allows for calling:
+    #
+    #     title "Test"
+    #     layout "default"
+    #
+    # Instead of:
+    #
+    #     self.title = "Test"
+    #     self.layout = "default"
+    #
+    class PageProxy
+      def initialize(page, site)
+        @page = page
+        @site = site
+      end
+
+      %w( category month year month_name ).each do |m|
+        class_eval <<-META
+          def _#{m}=(val)                         # def _category=(val)
+            @_#{m} = val                          #   @_category = val
+          end                                     # end
+
+          def #{m}                                # def category
+            defined?(@_#{m}) ? @_#{m} : nil       #   defined?(@_category) ? @_category : nil
+          end                                     # end
+        META
+      end
+
+      def site
+        @site
+      end
+
+      def method_missing(method, *args)
+        if @page.respond_to?("#{method}=")
+          @page.send("#{method}=", *args)
+        else
+          @page.send(method, *args)
+        end
+      end
+
+      def to_url(*args)
+        @site.to_url(*args)
+      end
+    end
+
+    # Loop through the given item name to generate archive pages.
+    #
+    # Available item types are:
+    #
+    # * :category
+    # * :tag
+    # * :year
+    # * :month
+    # * :day
+    #
+    def archives(item_type, options = {}, &block)
+      # If there is a method to return the list of items
+      if self.respond_to?("archive_#{item_type}_items")
+        self.send("archive_#{item_type}_items", options, &block)
+      end
+    end
+
     # Register a new callback for the given object and event.
     #
     # @example Run block after rendering a site
@@ -64,5 +126,113 @@ module Plate
     def register_template_engine(extension, klass)
       Plate.register_template_engine(extension, klass)
     end
+
+    # Create and write a dynamic page. Pages are written during the Site.after_render
+    # callback.
+    def write_page(path, site = nil, &block)
+      delayed_write = lambda { |site|
+        page = DynamicPage.new(site, path)
+        proxy = PageProxy.new(page, site)
+        proxy.instance_eval(&block)
+        page.write!
+        proxy = nil
+        page = nil
+      }
+
+      # If a site was passed to the write method, use it.
+      if site
+        delayed_write.call(site)
+      # If no site was sent to the write method, run it after site render
+      else
+        callback :site, :after_render do |rendered_site|
+          delayed_write.call(rendered_site)
+        end
+      end
+    end
+    alias :write :write_page
+
+    protected
+      # Category archives
+      def archive_category_items(options, &block)
+        callback :site, :after_render do |site|
+          site.categories.each do |category|
+            page = DynamicPage.new(site, "/categories/#{category}")
+            proxy = PageProxy.new(page, site)
+            proxy._category = category
+            page.meta[:category] = category
+            proxy.instance_eval(&block)
+            page.write!
+            proxy = nil
+            page = nil
+          end
+        end
+      end
+
+      # Monthly archive rendering
+      def archive_month_items(options, &block)
+        filter_year = options[:year] || nil
+        filter_category = options[:category] || nil
+
+        callback :site, :after_render do |site|
+          site.posts.archives.keys.each do |year|
+            if filter_year == nil or filter_year == year
+              site.posts.archives[year].keys.each do |month|
+                posts = []
+
+                site.posts.archives[year][month].each_value do |day|
+                  posts << day.select { |post| filter_category == nil or post.category == filter_category }
+                end
+
+                posts.flatten!
+
+                if posts.size > 0
+                  page = DynamicPage.new(site, "/archives/#{year}/#{month}")
+                  proxy = PageProxy.new(page, site)
+                  proxy._year = year
+                  proxy._month = month
+                  proxy._month_name = Date.new(year.to_i, month.to_i, 1).strftime('%B %Y')
+                  proxy._category = filter_category if filter_category
+                  proxy.locals = { :monthly_posts => posts, :month => month, :year => year }
+                  proxy.instance_eval(&block)
+                  page.write!
+                  proxy = nil
+                  page = nil
+                end
+              end
+            end
+          end
+        end
+      end
+
+      # Yearly archive rendering
+      def archive_year_items(options, &block)
+        filter_category = options[:category] || nil
+
+        callback :site, :after_render do |site|
+          site.posts.archives.keys.each do |year|
+            posts = []
+
+            site.posts.archives[year].keys.each do |month|
+              site.posts.archives[year][month].each_value do |day|
+                posts << day.select { |post| filter_category == nil or post.category == filter_category }
+              end
+            end
+
+            posts.flatten!
+
+            if posts.size > 0
+              page = DynamicPage.new(site, "/archives/#{year}")
+              proxy = PageProxy.new(page, site)
+              proxy._year = year
+              proxy._category = filter_category if filter_category
+              proxy.locals = { :yearly_posts => posts, :year => year }
+              proxy.instance_eval(&block)
+              page.write!
+              proxy = nil
+              page = nil
+            end
+          end
+        end
+      end
   end
 end

data/lib/plate/dynamic_page.rb

@@ -29,18 +29,38 @@ module Plate
     # Set up a new instance of Dynamic Page
     def initialize(site, destination_path, meta = {})
       self.site = site
-      self.file_path = destination_path
+      self.path = destination_path
       self.meta = meta
       self.content = ""
       self.locals = {}
       self.partials = []
     end
-
+    
+    # name for dynamic pages is the path
+    def name
+      self.file_path
+    end
+  
     # Set the full hash to be provided to the view. Hash keys are symbolized before
     # sending to the view.
     def locals=(hash)
       @locals = hash.symbolize_keys!
     end
+    
+    # Set the destination path for this page.
+    def path=(destination_path)
+      # Remove leading and trailing slashes
+      destination_path = destination_path.to_s.gsub(/^\//, '').gsub(/\/$/, '')
+
+      # Unless file ends in an extension, add /index.html
+      unless destination_path =~ /(.*?)\.[a-z0-0]{2,4}/i
+        destination_path = "#{destination_path}/index.html"
+      end
+
+      destination_path = "/#{destination_path}"
+    
+      self.file_path = destination_path
+    end
 
     # Alias for the content that is provided
     def rendered_body

data/lib/plate/helpers/blogging_helper.rb

@@ -6,7 +6,7 @@ module Plate
     # 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|
@@ -21,16 +21,20 @@ module Plate
           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
-    
+
+    def month_name(year, month)
+      Date.new(year.to_i, month.to_i, 1).strftime('%B %Y')
+    end
+
     # Grab the next blog post.
     #
     # Returns nil if this is the last post.
@@ -38,34 +42,34 @@ module Plate
       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. 
+
+    # Grab the post previous to this one.
     #
     # Returns nil if this is the first post.
     def previous_post
-      return nil if post_index < 1      
+      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 category
     def posts_for_category(category)
       self.posts.select { |p| p.category == category }
     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|
@@ -73,14 +77,14 @@ module Plate
           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|
@@ -88,19 +92,19 @@ module Plate
           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 
+          result << year
         end
       end
-      
+
       result.sort
     end
   end

data/lib/plate/version.rb

@@ -1,3 +1,3 @@
 module Plate
-  VERSION = "0.7.0" unless defined?(::Plate::VERSION)
+  VERSION = "0.7.1" unless defined?(::Plate::VERSION)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: plate
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-31 00:00:00.000000000 Z
+date: 2012-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport