middleman-blog 3.4.1 → 3.5.0

data/lib/middleman-blog/calendar_pages.rb

@@ -1,147 +1,115 @@
+require 'middleman-blog/uri_templates'
+
 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
-      class << self
-        # Get a path to the given calendar page, based on the :year_link, :month_link or :day_link setting.
-        # @param [Hash] blog_options
-        # @param [Number] year
-        # @param [Number] month
-        # @param [Number] day
-        # @return [String]
-        def link(blog_options, year, month=nil, day=nil)
-          path = if 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'))
-                 elsif month
-                   blog_options.month_link.
-                     sub(':year', year.to_s).
-                     sub(':month', month.to_s.rjust(2,'0'))
-                 else
-                   blog_options.year_link.
-                     sub(':year', year.to_s)
-                 end
-          ::Middleman::Util.normalize_path(path)
-        end
-      end
+      include UriTemplates
 
-      def initialize(app, controller=nil)
-        @app = app
-        @blog_controller = controller
-      end
+      def initialize(app, blog_controller)
+        @sitemap = app.sitemap
+        @blog_controller = blog_controller
+        @blog_data = blog_controller.data
 
-      def blog_data
-        if @blog_controller
-          @blog_controller.data
-        else
-          @app.blog
-        end
+        blog_options = blog_controller.options
+        @day_link_template = uri_template blog_options.day_link
+        @month_link_template = uri_template blog_options.month_link
+        @year_link_template = uri_template blog_options.year_link
+        @day_template = blog_options.day_template
+        @month_template = blog_options.month_template
+        @year_template = blog_options.year_template
       end
 
-      def blog_options
-        if @blog_controller
-          @blog_controller.options
-        else
-          @app.blog.options
-        end
+      # Get a path to the given calendar page, based on the :year_link, :month_link or :day_link setting.
+      # @param [Number] year
+      # @param [Number] month
+      # @param [Number] day
+      # @return [String]
+      def link(year, month=nil, day=nil)
+        template = if day
+                     @day_link_template
+                   elsif month
+                     @month_link_template
+                   else
+                     @year_link_template
+                   end
+
+        apply_uri_template template, date_to_params(Date.new(year, month || 1, day || 1))
       end
-      
+
       # Update the main sitemap resource list
-      # @return [void]
+      # @return [Array<Middleman::Sitemap::Resource>]
       def manipulate_resource_list(resources)
         new_resources = []
 
         # Set up date pages if the appropriate templates have been specified
-        self.blog_data.articles.group_by {|a| a.date.year }.each do |year, year_articles|
-          if self.blog_options.year_template
-            path = CalendarPages.link(self.blog_options, year)
-          
-            p = ::Middleman::Sitemap::Resource.new(
-              @app.sitemap,
-              path
-            )
-            p.proxy_to(self.blog_options.year_template)
-
-            # Add metadata in local variables so it's accessible to
-            # later extensions
-            p.add_metadata :locals => {
-              'page_type' => 'year',
-              'year' => year,
-              'articles' => year_articles,
-              'blog_controller' => @blog_controller
-            }
-            # Add metadata in instance variables for backwards compatibility
-            p.add_metadata do
-              @year = year
-              @articles = year_articles
-            end
-
-            new_resources << p
+        @blog_data.articles.group_by {|a| a.date.year }.each do |year, year_articles|
+          if @year_template
+            new_resources << year_page_resource(year, year_articles)
           end
-            
-          year_articles.group_by {|a| a.date.month }.each do |month, month_articles|
-            if self.blog_options.month_template
-              path = CalendarPages.link(self.blog_options, year, month)
-          
-              p = ::Middleman::Sitemap::Resource.new(
-                @app.sitemap,
-                path
-              )
-              p.proxy_to(self.blog_options.month_template)
-
-              p.add_metadata :locals => {
-                'page_type' => 'month',
-                'year' => year,
-                'month' => month,
-                'articles' => month_articles,
-                'blog_controller' => @blog_controller
-              }
-              p.add_metadata do
-                @year = year
-                @month = month
-                @articles = month_articles
-              end
 
-              new_resources << p
+          year_articles.group_by {|a| a.date.month }.each do |month, month_articles|
+            if @month_template
+              new_resources << month_page_resource(year, month, month_articles)
             end
-            
+
             month_articles.group_by {|a| a.date.day }.each do |day, day_articles|
-              if self.blog_options.day_template
-                path = CalendarPages.link(self.blog_options, year, month, day)
-
-                p = ::Middleman::Sitemap::Resource.new(
-                  @app.sitemap,
-                  path
-                )
-                p.proxy_to(self.blog_options.day_template)
-
-                p.add_metadata :locals => {
-                  'page_type' => 'day',
-                  'year' => year,
-                  'month' => month,
-                  'day' => day,
-                  'articles' => day_articles,
-                  'blog_controller' => @blog_controller
-                }
-                p.add_metadata do
-                  @year = year
-                  @month = month
-                  @day = day
-                  @articles = day_articles
-                end
-
-                new_resources << p
+              if @day_template
+                new_resources << day_page_resource(year, month, day, day_articles)
               end
             end
           end
         end
 
         resources + new_resources
-      end      
+      end
+
+      private
+
+      def year_page_resource(year, year_articles)
+        Sitemap::Resource.new(@sitemap, link(year)).tap do |p|
+          p.proxy_to(@year_template)
+
+          # Add metadata in local variables so it's accessible to
+          # later extensions
+          p.add_metadata locals: {
+            'page_type' => 'year',
+            'year' => year,
+            'articles' => year_articles,
+            'blog_controller' => @blog_controller
+          }
+        end
+      end
+
+      def month_page_resource(year, month, month_articles)
+        Sitemap::Resource.new(@sitemap, link(year, month)).tap do |p|
+          p.proxy_to(@month_template)
+
+          p.add_metadata locals: {
+            'page_type' => 'month',
+            'year' => year,
+            'month' => month,
+            'articles' => month_articles,
+            'blog_controller' => @blog_controller
+          }
+        end
+      end
+
+      def day_page_resource(year, month, day, day_articles)
+        Sitemap::Resource.new(@sitemap, link(year, month, day)).tap do |p|
+          p.proxy_to(@day_template)
+
+          p.add_metadata locals: {
+            'page_type' => 'day',
+            'year' => year,
+            'month' => month,
+            'day' => day,
+            'articles' => day_articles,
+            'blog_controller' => @blog_controller
+          }
+        end
+      end
     end
   end
 end

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

@@ -1,20 +1,20 @@
-require 'middleman-core/cli'
+require 'middleman-core/cli'
 require 'date'
+require 'middleman-blog/uri_templates'
 
 module Middleman
   module Cli
     # This class provides an "article" command for the middleman CLI.
     class Article < Thor
       include Thor::Actions
+      include Blog::UriTemplates
 
       check_unknown_options!
 
       namespace :article
 
-      # Template files are relative to this file
-      # @return [String]
       def self.source_root
-        File.dirname(__FILE__)
+        ENV['MM_ROOT']
       end
 
       # Tell Thor to exit with a nonzero exit code on failure
@@ -24,24 +24,31 @@ module Middleman
 
       desc "article TITLE", "Create a new blog article"
       method_option "date",
-        :aliases => "-d",
-        :desc => "The date to create the post with (defaults to now)"      
+        aliases: "-d",
+        desc: "The date to create the post with (defaults to now)"
+      method_option "lang",
+        aliases: "-l",
+        desc: "The language to create the post with (defaults to I18n.default_locale if avaliable)"
+      method_option "blog",
+        aliases: "-b",
+        desc: "The name of the blog to creat the post inside (for multi-blog apps, defaults to the only blog in single-blog apps)"
       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
+          @slug = safe_parameterize(title)
           @date = options[:date] ? Time.zone.parse(options[:date]) : Time.zone.now
+          @lang = options[:lang] || ( I18n.default_locale if defined? I18n )
 
-          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)
+          blog_inst = shared_instance.blog(options[:blog])
 
-          template "article.tt", File.join(shared_instance.source_dir, article_path + shared_instance.blog.options.default_extension)
+          path_template = blog_inst.source_template
+          params = date_to_params(@date).merge(lang: @lang.to_s, title: @slug)
+          article_path = apply_uri_template path_template, params
+
+          template blog_inst.options.new_article_template, File.join(shared_instance.source_dir, article_path + blog_inst.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
@@ -49,4 +56,3 @@ module Middleman
     end
   end
 end
-

data/lib/middleman-blog/custom_pages.rb

@@ -1,85 +1,51 @@
+require 'middleman-blog/uri_templates'
+
 module Middleman
   module Blog
 
+    # This adds new summary pages for arbitrarily defined blog article properties
     class CustomPages
+      include UriTemplates
 
-      class << self
-
-        # Return a path to the given property / value pair
-        #
-        # @param [Hash] blog_options
-        # @param [String|Symbol] property Frontmatter property used to collect on
-        # @param [String| value Frontmatter value for the given article for the given property
-        def link(blog_options, property, value)
-          link_template = blog_options.custom_collections[property][:link]
-          ::Middleman::Util.normalize_path(link_template.sub(":#{property}", value.parameterize))
-        end
-
-      end
+      attr_reader :property
 
-      attr_reader :property, :app, :blog_controller
-
-      def initialize(property, app, controller = nil)
-        @property        = property
-        @app             = app
+      def initialize(property, app, controller, options)
+        @property = property
+        @sitemap = app.sitemap
         @blog_controller = controller
+        @blog_data = controller.data
+        @link_template = uri_template options[:link]
+        @page_template = options[:template]
       end
 
-      def blog_data
-        if blog_controller
-          blog_controller.data
-        else
-          app.blog
-        end
-      end
-
-      def blog_options
-        if blog_controller
-          blog_controller.options
-        else
-          app.blog.options
-        end
-      end
-
-      def articles
-        blog_data.articles
+      # Return a path to the page for this property value.
+      #
+      # @param [String] value
+      def link(value)
+        apply_uri_template @link_template, property => safe_parameterize(value)
       end
 
       def manipulate_resource_list(resources)
-        new_resources = []
-
-        articles.group_by { |a| a.data[property] }.each do |property_value, property_articles|
-          path = CustomPages.link(blog_options, property, property_value)
-          new_resources << build_resource(path, property_value, property_articles)
+        articles_by_property = @blog_data.articles.group_by { |a| a.metadata[:page][property.to_s] }
+        resources + articles_by_property.map do |property_value, articles|
+          build_resource(link(property_value), property_value, articles)
         end
-
-        resources + new_resources
       end
 
-      def build_resource(path, value, property_articles)
-        p = ::Middleman::Sitemap::Resource.new(app.sitemap, path)
-        p.proxy_to(template_for_page)
-        p.add_metadata :locals => {
-          "page_type"       => property,
-          "#{property}"     => value,
-          "articles"        => property_articles,
-          "blog_controller" => blog_controller
-        }
+      private
 
-        prop_name = property
-        p.add_metadata do
-          instance_variable_set("@#{prop_name}", value)
-          @articles = property_articles
+      def build_resource(path, value, articles)
+        articles = articles.sort_by(&:date).reverse
+        Sitemap::Resource.new(@sitemap, path).tap do |p|
+          p.proxy_to(@page_template)
+          p.add_metadata locals: {
+            "page_type"       => property.to_s,
+            property          => value,
+            "articles"        => articles,
+            "blog_controller" => @blog_controller
+          }
         end
-
-        p
-      end
-
-      def template_for_page
-        blog_options.custom_collections[property][:template]
       end
-      
     end
-
   end
 end

data/lib/middleman-blog/extension.rb

@@ -0,0 +1,175 @@
+require 'active_support/core_ext/time/zones'
+require 'middleman-blog/blog_data'
+require 'middleman-blog/blog_article'
+require 'middleman-blog/helpers'
+
+module Middleman
+  class BlogExtension < Extension
+    self.supports_multiple_instances = true
+
+    option :name, nil, 'Unique ID for telling multiple blogs apart'
+    option :prefix, nil, 'Prefix to mount the blog at (modifies permalink, sources, taglink, year_link, month_link, day_link to start with the prefix)'
+    option :permalink, '/{year}/{month}/{day}/{title}.html', 'Path articles are generated at. Tokens can be omitted or duplicated, and you can use tokens defined in article frontmatter.'
+    option :sources, '{year}-{month}-{day}-{title}.html', 'Pattern for matching source blog articles (no template extensions)'
+    option :taglink, 'tags/{tag}.html', 'Path tag pages are generated at.'
+    option :layout, 'layout', 'Article-specific layout'
+    option :summary_separator, /(READMORE)/, 'Regex or string that delimits the article summary from the rest of the article.'
+    option :summary_length, 250, 'Truncate summary to be <= this number of characters. Set to -1 to disable summary truncation.'
+    option :summary_generator, nil, 'A block that defines how summaries are extracted. It will be passed the rendered article content, max summary length, and ellipsis string as arguments.'
+    option :year_link, '/{year}.html', 'Path yearly archive pages are generated at.'
+    option :month_link, '/{year}/{month}.html', 'Path monthly archive pages are generated at.'
+    option :day_link, '/{year}/{month}/{day}.html', 'Path daily archive pages are generated at.'
+    option :calendar_template, nil, 'Template path (no template extension) for calendar pages (year/month/day archives).'
+    option :year_template, nil, 'Template path (no template extension) for yearly archive pages. Defaults to the :calendar_template.'
+    option :month_template, nil, 'Template path (no template extension) for monthly archive pages. Defaults to the :calendar_template.'
+    option :day_template, nil, 'Template path (no template extension) for daily archive pages. Defaults to the :calendar_template.'
+    option :tag_template, nil, 'Template path (no template extension) for tag archive pages.'
+    option :paginate, false, 'Whether to paginate lists of articles'
+    option :per_page, 10, 'Number of articles per page when paginating'
+    option :page_link, 'page/{num}', 'Path to append for additional pages when paginating'
+    option :publish_future_dated, false, 'Whether articles with a date in the future should be considered published'
+    option :custom_collections, {}, 'Hash of custom frontmatter properties to collect articles on and their options (link, template)'
+    option :preserve_locale, false, 'Use the global Middleman I18n.locale instead of the lang in the article\'s frontmatter'
+    option :new_article_template, File.expand_path('../commands/article.tt', __FILE__), 'Path (relative to project root) to an ERb template that will be used to generate new articles from the "middleman article" command.'
+    option :default_extension, '.markdown', 'Default template extension for articles (used by "middleman article")'
+
+    # @return [BlogData] blog data for this blog, which has all information about the blog articles
+    attr_reader :data
+
+    # @return [Symbol] the name of this blog (autogenerated if not provided).
+    attr_reader :name
+
+    # @return [TagPages] tag page handler for this blog
+    attr_reader :tag_pages
+
+    # @return [CalendarPages] calendar page handler for this blog
+    attr_reader :calendar_pages
+
+    # @return [Paginator] pagination handler for this blog
+    attr_reader :paginator
+
+    # @return [Hash<CustomPages>] custom pages handlers for this blog, indexed by property name
+    attr_reader :custom_pages
+
+    # Helpers for use within templates and layouts.
+    self.defined_helpers = [ Middleman::Blog::Helpers ]
+
+    def initialize(app, options_hash={}, &block)
+      super
+
+      @custom_pages = {}
+
+      # NAME is the name of this particular blog, and how you reference it from #blog_controller or frontmatter.
+      @name = options.name.to_sym if options.name
+
+      # 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)
+
+        options.custom_collections.each do |key, opts|
+          opts[:link] = File.join(options.prefix, opts[:link])
+        end
+      end
+    end
+
+    def after_configuration
+      @name ||= :"blog#{@app.blog_instances.keys.length}"
+
+      # TODO: break up into private methods?
+
+      @app.ignore(options.calendar_template) if options.calendar_template
+      @app.ignore(options.year_template) if options.year_template
+      @app.ignore(options.month_template) if options.month_template
+      @app.ignore(options.day_template) if options.day_template
+      @app.ignore options.tag_template if options.tag_template
+
+      @app.blog_instances[@name] = self
+
+      # Make sure ActiveSupport's TimeZone stuff has something to work with,
+      # allowing people to set their desired time zone via Time.zone or
+      # set :time_zone
+      Time.zone = app.config[:time_zone] if app.config[:time_zone]
+      time_zone = Time.zone || 'UTC'
+      zone_default = Time.find_zone!(time_zone)
+      unless zone_default
+        raise 'Value assigned to time_zone not recognized.'
+      end
+      Time.zone_default = zone_default
+
+      # Initialize blog with options
+      @data = Blog::BlogData.new(@app, self, options)
+
+      @app.sitemap.register_resource_list_manipulator(:"blog_#{name}_articles", @data, false)
+
+      if options.tag_template
+        @app.ignore options.tag_template
+
+        require 'middleman-blog/tag_pages'
+        @tag_pages = Blog::TagPages.new(@app, self)
+        @app.sitemap.register_resource_list_manipulator(:"blog_#{name}_tags", @tag_pages, false)
+      end
+
+      if options.year_template || options.month_template || options.day_template
+        require 'middleman-blog/calendar_pages'
+        @calendar_pages = Blog::CalendarPages.new(@app, self)
+        @app.sitemap.register_resource_list_manipulator(:"blog_#{name}_calendar", @calendar_pages, false)
+      end
+
+      if options.paginate
+        require 'middleman-blog/paginator'
+        @paginator = Blog::Paginator.new(@app, self)
+        @app.sitemap.register_resource_list_manipulator(:"blog_#{name}_paginate", @paginator, false)
+      end
+
+      if options.custom_collections
+        require 'middleman-blog/custom_pages'
+        register_custom_pages
+      end
+    end
+
+    private
+
+    # Register any custom page collections that may be set in the config
+    #
+    # A custom resource list manipulator will be generated for each key in the
+    # custom collections hash.
+    #
+    # The following will collect posts on the "category" frontmatter property:
+    #   ```
+    #   activate :blog do |blog|
+    #     blog.custom_collections = {
+    #       category: {
+    #         link: "/categories/:category.html",
+    #         template: "/category.html"
+    #       }
+    #     }
+    #   end
+    #   ```
+    #
+    # Category pages in the example above will use the category.html as a template file
+    # and it will be ignored when building.
+    def register_custom_pages
+      options.custom_collections.each do |property, options|
+        @app.ignore options[:template]
+
+        @custom_pages[property] = Blog::CustomPages.new(property, @app, self, options)
+        @app.sitemap.register_resource_list_manipulator(:"blog_#{name}_#{property}", @custom_pages[property], false)
+
+        Blog::Helpers.generate_custom_helper(property)
+      end
+    end
+  end
+end