middleman-blog 0.1.5 → 3.0.0.beta.3

data/lib/middleman-blog/blog_data.rb

@@ -0,0 +1,94 @@
+module Middleman
+  module Blog
+    # A store of all the blog articles in the site, with accessors
+    # for the articles by various dimensions. Accessed via "blog" in
+    # templates.
+    class BlogData
+      # A regex for matching blog article source paths
+      # @return [Regex]
+      attr_reader :path_matcher
+      
+      # The configured options for this blog
+      # @return [Thor::CoreExt::HashWithIndifferentAccess]
+      attr_reader :options
+
+      # @private
+      def initialize(app, options={})
+        @app = app
+        @options = options
+
+        # A list of resources corresponding to blog articles
+        @_articles = []
+        
+        matcher = Regexp.escape(options.sources).
+            sub(/^\//, "").
+            sub(":year",  "(\\d{4})").
+            sub(":month", "(\\d{2})").
+            sub(":day",   "(\\d{2})").
+            sub(":title", "(.*)")
+
+        @path_matcher = /^#{matcher}/
+      end
+
+      # A list of all blog articles, sorted by date
+      # @return [Array<Middleman::Sitemap::Resource>]
+      def articles
+        @_articles.sort do |a,b|
+          b.date <=> a.date
+        end
+      end
+
+      # The BlogArticle for the given path, or nil if one doesn't exist.
+      # @return [Middleman::Sitemap::Resource]
+      def article(path)
+        article = @app.sitemap.find_resource_by_path(path.to_s)
+        if article && article.is_a?(BlogArticle)
+          article
+        else
+          nil
+        end
+      end
+
+      # Returns a map from tag name to an array
+      # of BlogArticles associated with that tag.
+      # @return [Hash<String, Array<Middleman::Sitemap::Resource>>]
+      def tags
+        tags = {}
+        @_articles.each do |article|
+          article.tags.each do |tag|
+            tags[tag] ||= []
+            tags[tag] << article
+          end
+        end
+
+        tags
+      end
+
+      # Updates' blog articles destination paths to be the
+      # permalink.
+      # @return [void]
+      def manipulate_resource_list(resources)
+        @_articles = []
+
+        resources.each do |resource|
+          if resource.path =~ path_matcher
+            resource.extend BlogArticle
+            resource.slug = $4
+            
+            # compute output path:
+            #   substitute date parts to path pattern
+            resource.destination_path = options.permalink.
+              sub(':year', resource.date.year.to_s).
+              sub(':month', resource.date.month.to_s.rjust(2,'0')).
+              sub(':day', resource.date.day.to_s.rjust(2,'0')).
+              sub(':title', resource.slug)
+
+            resource.destination_path = Middleman::Util.normalize_path(resource.destination_path)
+
+            @_articles << resource
+          end
+        end
+      end
+    end
+  end
+end

data/lib/middleman-blog/calendar_pages.rb

@@ -0,0 +1,85 @@
+module Middleman
+  module Blog
+
+    # A sitemap plugin that adds month/day/year pages to the sitemap
+    # based on the dates of blog articles.
+    class CalendarPages
+      def initialize(app)
+        @app = app
+      end
+      
+      # Update the main sitemap resource list
+      # @return [void]
+      def manipulate_resource_list(resources)
+        new_resources = []
+        # Set up date pages if the appropriate templates have been specified
+        @app.blog.articles.group_by {|a| a.date.year }.each do |year, year_articles|
+          if @app.blog.options.year_template
+            @app.ignore @app.blog.options.year_template
+
+            path = Middleman::Util.normalize_path(@app.blog_year_path(year))
+          
+            p = ::Middleman::Sitemap::Resource.new(
+              @app.sitemap,
+              path
+            )
+            p.proxy_to(@app.blog.options.year_template)
+
+            p.add_metadata do
+              @year = year
+              @articles = year_articles
+            end
+
+            new_resources << p
+          end
+            
+          year_articles.group_by {|a| a.date.month }.each do |month, month_articles|
+            if @app.blog.options.month_template
+              @app.ignore @app.blog.options.month_template
+
+              path = Middleman::Util.normalize_path(@app.blog_month_path(year, month))
+          
+              p = ::Middleman::Sitemap::Resource.new(
+                @app.sitemap,
+                path
+              )
+              p.proxy_to(@app.blog.options.month_template)
+
+              p.add_metadata do
+                @year = year
+                @month = month
+                @articles = month_articles
+              end
+
+              new_resources << p
+            end
+            
+            month_articles.group_by {|a| a.date.day }.each do |day, day_articles|
+              if @app.blog.options.day_template
+                @app.ignore @app.blog.options.day_template
+
+                path = Middleman::Util.normalize_path(@app.blog_day_path(year, month, day))
+                p = ::Middleman::Sitemap::Resource.new(
+                  @app.sitemap,
+                  path
+                )
+                p.proxy_to(@app.blog.options.month_template)
+
+                p.add_metadata do
+                  @year = year
+                  @month = month
+                  @day = day
+                  @articles = day_articles
+                end
+
+                new_resources << p
+              end
+            end
+          end
+        end
+
+        resources + new_resources
+      end      
+    end
+  end
+end

data/lib/middleman-blog/commands/article.rb

@@ -0,0 +1,52 @@
+require 'middleman-core/cli'
+require 'date'
+
+module Middleman
+  module Cli
+    # This class provides an "article" command for the middleman CLI.
+    class Article < Thor
+      include Thor::Actions
+
+      check_unknown_options!
+
+      namespace :article
+
+      # Template files are relative to this file
+      # @return [String]
+      def self.source_root
+        File.dirname(__FILE__)
+      end
+
+      # Tell Thor to exit with a nonzero exit code on failure
+      def self.exit_on_failure?
+        true
+      end
+
+      desc "article TITLE", "Create a new blog article"
+      method_option "date",
+        :aliases => "-d",
+        :desc => "The date to create the post with (defaults to now)"      
+      def article(title)
+        shared_instance = ::Middleman::Application.server.inst
+
+        # This only exists when the config.rb sets it!
+        if shared_instance.respond_to? :blog
+          @title = title
+          @slug = title.parameterize
+          @date = options[:date] ? DateTime.parse(options[:date]) : DateTime.now
+
+          article_path = shared_instance.blog.options.sources.
+            sub(':year', @date.year.to_s).
+            sub(':month', @date.month.to_s.rjust(2,'0')).
+            sub(':day', @date.day.to_s.rjust(2,'0')).
+            sub(':title', @slug)
+
+          template "article.tt", File.join(shared_instance.source_dir, article_path + shared_instance.blog.options.default_extension)
+        else
+          raise Thor::Error.new "You need to activate the blog extension in config.rb before you can create an article"
+        end
+      end
+    end
+  end
+end
+

data/lib/middleman-blog/commands/article.tt

@@ -0,0 +1,6 @@
+---
+title: <%= @title %>
+date: <%= @date.strftime('%F %R %Z') %>
+tags:
+---
+

data/lib/middleman-blog/extension.rb

@@ -0,0 +1,170 @@
+module Middleman
+  module Blog
+    class Options
+      KEYS = [
+        :prefix,
+        :permalink,
+        :sources,
+        :taglink,
+        :layout,
+        :summary_separator,
+        :summary_length,
+        :year_link,
+        :month_link,
+        :day_link,
+        :default_extension,
+        :calendar_template,
+        :year_template,
+        :month_template,
+        :day_template,
+        :tag_template
+      ]
+      
+      KEYS.each do |name|
+        attr_accessor name
+      end
+      
+      def initialize(options={})
+        options.each do |k,v|
+          self.send(:"#{k}=", v)
+        end
+      end
+    end
+    
+    class << self
+      def registered(app, options_hash={}, &block)
+        require 'middleman-blog/blog_data'
+        require 'middleman-blog/blog_article'
+        
+        app.send :include, Helpers
+        
+        options = Options.new(options_hash)
+        yield options if block_given?
+        
+        options.permalink         ||= "/:year/:month/:day/:title.html"
+        options.sources           ||= ":year-:month-:day-:title.html"
+        options.taglink           ||= "tags/:tag.html"
+        options.layout            ||= "layout"
+        options.summary_separator ||= /(READMORE)/
+        options.summary_length    ||= 250
+        options.year_link         ||= "/:year.html"
+        options.month_link        ||= "/:year/:month.html"
+        options.day_link          ||= "/:year/:month/:day.html"
+        options.default_extension ||= ".markdown"
+
+        # optional: :tag_template
+        # optional: :year_template
+        # optional: :month_template
+        # optional: :day_template
+        # Allow one setting to set all the calendar templates
+        if options.calendar_template
+          options.year_template  ||= options.calendar_template
+          options.month_template ||= options.calendar_template
+          options.day_template   ||= options.calendar_template
+        end
+
+        # If "prefix" option is specified, all other paths are relative to it.
+        if options.prefix
+          options.prefix = "/#{options.prefix}" unless options.prefix.start_with? '/'
+          options.permalink = File.join(options.prefix, options.permalink)
+          options.sources = File.join(options.prefix, options.sources)
+          options.taglink = File.join(options.prefix, options.taglink)
+          options.year_link = File.join(options.prefix, options.year_link)
+          options.month_link = File.join(options.prefix, options.month_link)
+          options.day_link = File.join(options.prefix, options.day_link)
+        end
+
+        app.after_configuration do
+          # Initialize blog with options
+          blog(options)
+          
+          sitemap.register_resource_list_manipulator(
+            :blog_articles,
+            blog,
+            false
+          )
+
+          if options.tag_template
+            ignore options.tag_template
+
+            require 'middleman-blog/tag_pages'
+            sitemap.register_resource_list_manipulator(
+              :blog_tags,
+              TagPages.new(self),
+              false
+            )
+          end
+
+          if options.year_template || 
+             options.month_template || 
+             options.day_template
+
+            require 'middleman-blog/calendar_pages'
+            sitemap.register_resource_list_manipulator(
+              :blog_calendar,
+              CalendarPages.new(self),
+              false
+            )
+          end
+        end
+      end
+      alias :included :registered
+    end
+
+    # Helpers for use within templates and layouts.
+    module Helpers
+      # Get the {BlogData} for this site.
+      # @return [BlogData]
+      def blog(options=nil)
+        @_blog ||= BlogData.new(self, options)
+      end
+
+      # Determine whether the currently rendering template is a blog article.
+      # This can be useful in layouts.
+      # @return [Boolean]
+      def is_blog_article?
+        !current_article.nil?
+      end
+
+      # Get a {Resource} with mixed in {BlogArticle} methods representing the current article.
+      # @return [Middleman::Sitemap::Resource]
+      def current_article
+        blog.article(current_page.path)
+      end
+
+      # Get a path to the given tag, based on the :taglink setting.
+      # @param [String] tag
+      # @return [String]
+      def tag_path(tag)
+        blog.options.taglink.sub(':tag', tag.parameterize)
+      end
+
+      # Get a path to the given year-based calendar page, based on the :year_link setting.
+      # @param [Number] year
+      # @return [String]
+      def blog_year_path(year)
+        blog.options.year_link.sub(':year', year.to_s)
+      end
+
+      # Get a path to the given month-based calendar page, based on the :month_link setting.
+      # @param [Number] year        
+      # @param [Number] month
+      # @return [String]
+      def blog_month_path(year, month)
+        blog.options.month_link.sub(':year', year.to_s).
+          sub(':month', month.to_s.rjust(2,'0'))
+      end
+
+      # Get a path to the given day-based calendar page, based on the :day_link setting.
+      # @param [Number] year        
+      # @param [Number] month
+      # @param [Number] day
+      # @return [String]
+      def blog_day_path(year, month, day)
+        blog.options.day_link.sub(':year', year.to_s).
+          sub(':month', month.to_s.rjust(2,'0')).
+          sub(':day', day.to_s.rjust(2,'0'))
+      end
+    end
+  end
+end

data/lib/middleman-blog/tag_pages.rb

@@ -0,0 +1,33 @@
+module Middleman
+  module Blog
+
+    # A sitemap plugin that adds tag pages to the sitemap
+    # based on the tags of blog articles.
+    class TagPages
+      def initialize(app)
+        @app = app
+      end
+      
+      # Update the main sitemap resource list
+      # @return [void]
+      def manipulate_resource_list(resources)
+        resources + @app.blog.tags.map do |tag, articles|
+          path = Middleman::Util.normalize_path(@app.tag_path(tag))
+          
+          p = ::Middleman::Sitemap::Resource.new(
+            @app.sitemap,
+            path
+          )
+          p.proxy_to(@app.blog.options.tag_template)
+
+          p.add_metadata do
+            @tag = tag
+            @articles = articles
+          end
+
+          p
+        end
+      end
+    end
+  end
+end

data/lib/middleman-blog/template.rb

@@ -1,24 +1,35 @@
+require "middleman-core/templates"
+
 module Middleman
   module Blog
+
+    # A template that generates a blog-specific config.rb
+    # and a set of example templates for index, layout, tags, and calendar.
     class Template < Middleman::Templates::Base
+      class_option "css_dir", 
+        :default => "stylesheets", 
+        :desc    => 'The path to the css files'
+      class_option "js_dir", 
+        :default => "javascripts", 
+        :desc    => 'The path to the javascript files'
+      class_option "images_dir", 
+        :default => "images", 
+        :desc    => 'The path to the image files'
+
       def self.source_root
-        File.dirname(__FILE__)
+        File.join(File.dirname(__FILE__), 'template')
       end
   
       def build_scaffold
-        template "template/config.tt", File.join(location, "config.rb")
-        directory "template/source", File.join(location, "source")
+        template "config.tt", File.join(location, "config.rb")
+        directory "source", File.join(location, "source")
     
         empty_directory File.join(location, "source", options[:css_dir])
         empty_directory File.join(location, "source", options[:js_dir])
         empty_directory File.join(location, "source", options[:images_dir])
       end
-  
-      def generate_rack
-        template "template/config.ru", File.join(location, "config.ru")
-      end
     end
   end
 end
 
-Middleman::Templates.register(:blog, Middleman::Blog::Template)
+Middleman::Templates.register(:blog, Middleman::Blog::Template)