middleman-blog 3.2.0 → 3.3.0

data/lib/middleman-blog/blog_article.rb

@@ -5,6 +5,26 @@ module Middleman
   module Blog
     # A module that adds blog-article methods to Resources.
     module BlogArticle
+      def self.extended(base)
+        base.class.send(:attr_accessor, :blog_controller)
+      end
+
+      def blog_data
+        if self.blog_controller
+          self.blog_controller.data
+        else
+          app.blog
+        end
+      end
+
+      def blog_options
+        if self.blog_controller
+          self.blog_controller.options
+        else
+          app.blog.options
+        end
+      end
+
       # Render this resource
       # @return [String]
       def render(opts={}, locs={}, &block)
@@ -12,15 +32,15 @@ module Middleman
           if metadata[:options] && !metadata[:options][:layout].nil?
             opts[:layout] = metadata[:options][:layout]
           end
-          opts[:layout] = app.blog.options.layout if opts[:layout].nil?
+          opts[:layout] = blog_options.layout if opts[:layout].nil?
           opts[:layout] = opts[:layout].to_s if opts[:layout].is_a? Symbol
         end
 
         content = super(opts, locs, &block)
 
         unless opts[:keep_separator]
-          if content.match(app.blog.options.summary_separator)
-            content.sub!(app.blog.options.summary_separator, "")
+          if content.match(blog_options.summary_separator)
+            content.sub!(blog_options.summary_separator, "")
           end
         end
 
@@ -43,7 +63,7 @@ module Middleman
       # @return [Boolean]
       def published?
         (data["published"] != false) and
-          (app.blog.options.publish_future_dated || date <= Time.current)
+          (blog_options.publish_future_dated || date <= Time.current)
       end
 
       # The body of this article, in HTML. This is for
@@ -66,15 +86,15 @@ module Middleman
       # desired length to trim the summary to, and the ellipsis string to use.
       #
       # @param [Number] length How many characters to trim the summary to.
-      # @param [Number] length The ellipsis string to use when content is trimmed.
+      # @param [String] ellipsis The ellipsis string to use when content is trimmed.
       # @return [String]
-      def summary(length=app.blog.options.summary_length, ellipsis='...')
+      def summary(length=blog_options.summary_length, ellipsis='...')
         rendered = render(:layout => false, :keep_separator => true)
 
-        if app.blog.options.summary_separator && rendered.match(app.blog.options.summary_separator)
-          rendered.split(app.blog.options.summary_separator).first
-        elsif app.blog.options.summary_generator
-          app.blog.options.summary_generator.call(self, rendered, length, ellipsis)
+        if blog_options.summary_separator && rendered.match(blog_options.summary_separator)
+          rendered.split(blog_options.summary_separator).first
+        elsif blog_options.summary_generator
+          blog_options.summary_generator.call(self, rendered, length, ellipsis)
         else
           default_summary_generator(rendered, length, ellipsis)
         end
@@ -83,8 +103,8 @@ module Middleman
       def default_summary_generator(rendered, length, ellipsis)
         require 'middleman-blog/truncate_html'
 
-        if rendered =~ app.blog.options.summary_separator
-          rendered.split(app.blog.options.summary_separator).first
+        if rendered =~ blog_options.summary_separator
+          rendered.split(blog_options.summary_separator).first
         elsif length
           TruncateHTML.truncate_html(rendered, length, ellipsis)
         else
@@ -108,9 +128,9 @@ module Middleman
       # @param [String] The part of the path, e.g. "year", "month", "day", "title"
       # @return [String]
       def path_part(part)
-        @_path_parts ||= app.blog.path_matcher.match(path).captures
+        @_path_parts ||= blog_data.path_matcher.match(path).captures
 
-        @_path_parts[app.blog.matcher_indexes[part]]
+        @_path_parts[blog_data.matcher_indexes[part]]
       end
 
       # Attempt to figure out the date of the post. The date should be
@@ -132,9 +152,9 @@ module Middleman
         end
 
         # Next figure out the date from the filename
-        if app.blog.options.sources.include?(":year") &&
-            app.blog.options.sources.include?(":month") &&
-            app.blog.options.sources.include?(":day")
+        if blog_options.sources.include?(":year") &&
+            blog_options.sources.include?(":month") &&
+            blog_options.sources.include?(":day")
 
           filename_date = Time.zone.local(path_part("year").to_i, path_part("month").to_i, path_part("day").to_i)
           if @_date
@@ -152,21 +172,27 @@ module Middleman
       # The "slug" of the article that shows up in its URL.
       # @return [String]
       def slug
-        @_slug ||= path_part("title")
+        @_slug ||= data["slug"]
+
+        @_slug ||= if blog_options.sources.include?(":title")
+          path_part("title")
+        else
+          title.parameterize
+        end
       end
 
       # The previous (chronologically earlier) article before this one
       # or nil if this is the first article.
       # @return [Middleman::Sitemap::Resource]
       def previous_article
-        app.blog.articles.find {|a| a.date < self.date }
+        blog_data.articles.find {|a| a.date < self.date }
       end
-      
+
       # The next (chronologically later) article after this one
       # or nil if this is the most recent article.
       # @return [Middleman::Sitemap::Resource]
       def next_article
-        app.blog.articles.reverse.find {|a| a.date > self.date }
+        blog_data.articles.reverse.find {|a| a.date > self.date }
       end
     end
   end

data/lib/middleman-blog/blog_data.rb

@@ -16,19 +16,22 @@ module Middleman
       # @return [Thor::CoreExt::HashWithIndifferentAccess]
       attr_reader :options
 
+      attr_reader :controller
+
       # @private
-      def initialize(app, options={})
+      def initialize(app, options={}, controller=nil)
         @app = app
         @options = options
+        @controller = controller
 
         # 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})").
+            gsub(":year",  "(\\d{4})").
+            gsub(":month", "(\\d{2})").
+            gsub(":day",   "(\\d{2})").
             sub(":title", "([^/]+)")
 
         subdir_matcher = matcher.sub(/\\\.[^.]+$/, "(/.*)$")
@@ -93,6 +96,10 @@ module Middleman
           if resource.path =~ path_matcher
             resource.extend BlogArticle
 
+            if @controller
+              resource.blog_controller = controller
+            end
+
             # Skip articles that are not published (in non-development environments)
             next unless @app.environment == :development || resource.published?
 

data/lib/middleman-blog/calendar_pages.rb

@@ -6,56 +6,73 @@ module Middleman
     class CalendarPages
       class << self
         # Get a path to the given calendar page, based on the :year_link, :month_link or :day_link setting.
-        # @param [Middleman::Application] app
+        # @param [Hash] blog_options
         # @param [Number] year
         # @param [Number] month
         # @param [Number] day
         # @return [String]
-        def link(app, year, month=nil, day=nil)
+        def link(blog_options, year, month=nil, day=nil)
           path = if day
-                   app.blog.options.day_link.
+                   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
-                   app.blog.options.month_link.
+                   blog_options.month_link.
                      sub(':year', year.to_s).
                      sub(':month', month.to_s.rjust(2,'0'))
                  else
-                   app.blog.options.year_link.
+                   blog_options.year_link.
                      sub(':year', year.to_s)
                  end
           ::Middleman::Util.normalize_path(path)
         end
       end
 
-      def initialize(app)
+      def initialize(app, controller=nil)
         @app = app
+        @blog_controller = controller
+      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
       
       # 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 = CalendarPages.link(@app, year)
+        # 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(@app.blog.options.year_template)
+            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
+              'articles' => year_articles,
+              'blog_controller' => @blog_controller
             }
             # Add metadata in instance variables for backwards compatibility
             p.add_metadata do
@@ -67,22 +84,21 @@ module Middleman
           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 = CalendarPages.link(@app, year, month)
+            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(@app.blog.options.month_template)
+              p.proxy_to(self.blog_options.month_template)
 
               p.add_metadata :locals => {
                 'page_type' => 'month',
                 'year' => year,
                 'month' => month,
-                'articles' => month_articles
+                'articles' => month_articles,
+                'blog_controller' => @blog_controller
               }
               p.add_metadata do
                 @year = year
@@ -94,23 +110,22 @@ module Middleman
             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 = CalendarPages.link(@app, year, month, day)
+              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(@app.blog.options.day_template)
+                p.proxy_to(self.blog_options.day_template)
 
                 p.add_metadata :locals => {
                   'page_type' => 'day',
                   'year' => year,
                   'month' => month,
                   'day' => day,
-                  'articles' => day_articles
+                  'articles' => day_articles,
+                  'blog_controller' => @blog_controller
                 }
                 p.add_metadata do
                   @year = year

data/lib/middleman-blog/{extension.rb → extension_3_0.rb}

@@ -24,31 +24,29 @@ module Middleman
               :page_link,
               :publish_future_dated
              ]
-      
+
       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'
         require 'active_support/core_ext/time/zones'
 
-        app.set :time_zone, 'UTC'
-
         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"
@@ -90,6 +88,7 @@ module Middleman
           # 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 = self.time_zone if self.respond_to?(:time_zone)
           time_zone = Time.zone if Time.zone
           zone_default = Time.find_zone!(time_zone || 'UTC')
           unless zone_default
@@ -97,9 +96,14 @@ module Middleman
           end
           Time.zone_default = zone_default
 
+          ignore(options.calendar_template) if options.calendar_template
+          ignore(options.year_template) if options.year_template
+          ignore(options.month_template) if options.month_template
+          ignore(options.day_template) if options.day_template
+
           # Initialize blog with options
           blog(options)
-          
+
           sitemap.register_resource_list_manipulator(
                                                      :blog_articles,
                                                      blog,
@@ -117,8 +121,8 @@ module Middleman
                                                        )
           end
 
-          if options.year_template || 
-              options.month_template || 
+          if options.year_template ||
+              options.month_template ||
               options.day_template
 
             require 'middleman-blog/calendar_pages'
@@ -167,31 +171,31 @@ module Middleman
       # @param [String] tag
       # @return [String]
       def tag_path(tag)
-        sitemap.find_resource_by_path(TagPages.link(self, tag)).try(:url)
+        sitemap.find_resource_by_path(TagPages.link(self.blog.options, tag)).try(:url)
       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)
-        sitemap.find_resource_by_path(CalendarPages.link(self, year)).try(:url)
+        sitemap.find_resource_by_path(CalendarPages.link(self.blog.options, year)).try(:url)
       end
 
       # Get a path to the given month-based calendar page, based on the :month_link setting.
-      # @param [Number] year        
+      # @param [Number] year
       # @param [Number] month
       # @return [String]
       def blog_month_path(year, month)
-        sitemap.find_resource_by_path(CalendarPages.link(self, year, month)).try(:url)
+        sitemap.find_resource_by_path(CalendarPages.link(self.blog.options, year, month)).try(:url)
       end
 
       # Get a path to the given day-based calendar page, based on the :day_link setting.
-      # @param [Number] year        
+      # @param [Number] year
       # @param [Number] month
       # @param [Number] day
       # @return [String]
       def blog_day_path(year, month, day)
-        sitemap.find_resource_by_path(CalendarPages.link(self, year, month, day)).try(:url)
+        sitemap.find_resource_by_path(CalendarPages.link(self.blog.options, year, month, day)).try(:url)
       end
 
 

data/lib/middleman-blog/extension_3_1.rb

@@ -0,0 +1,208 @@
+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'
+    option :permalink, "/:year/:month/:day/:title.html", 'HTTP path to host articles at'
+    option :sources, ":year-:month-:day-:title.html", 'How to extract metadata from on-disk files'
+    option :taglink, "tags/:tag.html", 'HTTP path to host tag pages at'
+    option :layout, "layout", 'Article-specific layout'
+    option :summary_separator, /(READMORE)/, 'How to split article summaries around a delimeter'
+    option :summary_length, 250, 'Length of words in automatic summaries'
+    option :summary_generator, nil, 'Block to definte how summaries are extracted'
+    option :year_link, "/:year.html", 'HTTP path for yearly archives'
+    option :month_link, "/:year/:month.html", 'HTTP path for monthly archives'
+    option :day_link, "/:year/:month/:day.html", 'HTTP path for daily archives'
+    option :default_extension, ".markdown", 'Default article extension'
+    option :calendar_template, nil, 'Template for calendar pages'
+    option :year_template, nil, 'Template for yearly archive pages'
+    option :month_template, nil, 'Template for monthyl archive pages'
+    option :day_template, nil, 'Template for daily archive pages'
+    option :tag_template, nil, 'Template for tag archive pages'
+    option :paginate, false, 'Whether to paginate pages'
+    option :per_page, 10, 'Articles per page when paginating'
+    option :page_link, "page/:num", 'HTTP path for paging'
+    option :publish_future_dated, false, 'Whether to pubish articles dated in the future'
+
+    attr_accessor :data, :uid
+
+    def initialize(app, options_hash={}, &block)
+      super
+
+      @uid = options.name
+
+      require 'middleman-blog/blog_data'
+      require 'middleman-blog/blog_article'
+      require 'active_support/core_ext/time/zones'
+
+      # app.set :time_zone, 'UTC'
+
+      # 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
+    end
+
+    def after_configuration
+      @uid ||= "blog#{@app.blog_instances.keys.length}"
+
+      @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.blog_instances[@uid.to_sym] = 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 if Time.zone
+      zone_default = Time.find_zone!(time_zone || 'UTC')
+      unless zone_default
+        raise 'Value assigned to time_zone not recognized.'
+      end
+      Time.zone_default = zone_default
+
+      # Initialize blog with options
+
+      @data = ::Middleman::Blog::BlogData.new(@app, options, self)
+
+      @app.sitemap.register_resource_list_manipulator(
+        :"blog_#{uid}_articles",
+        @data,
+        false
+      )
+
+      if options.tag_template
+        @app.ignore options.tag_template
+
+        require 'middleman-blog/tag_pages'
+        @app.sitemap.register_resource_list_manipulator(
+          :"blog_#{uid}_tags",
+          ::Middleman::Blog::TagPages.new(@app, self),
+          false
+        )
+      end
+
+      if options.year_template || options.month_template || options.day_template
+        require 'middleman-blog/calendar_pages'
+        @app.sitemap.register_resource_list_manipulator(
+          :"blog_#{uid}_calendar",
+          ::Middleman::Blog::CalendarPages.new(@app, self),
+          false
+        )
+      end
+
+      if options.paginate
+        require 'middleman-blog/paginator'
+        @app.sitemap.register_resource_list_manipulator(
+          :"blog_#{uid}_paginate",
+          ::Middleman::Blog::Paginator.new(@app, self),
+          false
+        )
+      end
+    end
+
+    # Helpers for use within templates and layouts.
+    helpers do
+      def blog_instances
+        @blog_instances ||= {}
+      end
+
+      def blog_controller(key=nil)
+        key ||= (current_resource && current_resource.metadata[:page]["blog"]) || blog_instances.keys.first
+        blog_instances[key.to_sym]
+      end
+
+      def blog(key=nil)
+        blog_controller(key).data
+      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_instances.each do |key, blog|
+          found = blog.data.article(current_resource.path)
+          return found if found
+        end
+
+        nil
+      end
+
+      # Get a path to the given tag, based on the :taglink setting.
+      # @param [String] tag
+      # @return [String]
+      def tag_path(tag, key=nil)
+        sitemap.find_resource_by_path(::Middleman::Blog::TagPages.link(blog_controller(key).options, tag)).try(:url)
+      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, key=nil)
+        sitemap.find_resource_by_path(::Middleman::Blog::CalendarPages.link(blog_controller(key).options, year)).try(:url)
+      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, key=nil)
+        sitemap.find_resource_by_path(::Middleman::Blog::CalendarPages.link(blog_controller(key).options, year, month)).try(:url)
+      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, key=nil)
+        sitemap.find_resource_by_path(::Middleman::Blog::CalendarPages.link(blog_controller(key).options, year, month, day)).try(:url)
+      end
+
+      # Pagination Helpers
+      # These are used by the template if pagination is off, to allow a single template to work
+      # in both modes. They get overridden by the local variables if the paginator is active.
+
+      # Returns true if pagination is turned on for this template; false otherwise.
+      # @return [Boolean]
+      def paginate; false; end
+
+      # Returns the list of articles to display on this page.
+      # @return [Array<Middleman::Sitemap::Resource>]
+      def page_articles(key=nil)
+        limit = (current_resource.metadata[:page]["per_page"] || 0) - 1
+
+        # "articles" local variable is populated by Calendar and Tag page generators
+        # If it's not set then use the complete list of articles
+        d = (current_resource.metadata[:locals]["articles"] || blog(key).articles)[0..limit]
+      end
+    end
+  end
+end