middleman-blog 4.0.2 → 4.0.3

data/lib/middleman-blog/calendar_pages.rb

@@ -29,7 +29,7 @@ module Middleman
       # @param [Number] month
       # @param [Number] day
       # @return [String]
-      def link(year, month=nil, day=nil)
+      def link(year, month = nil, day = nil)
         template = if day
                      @day_link_template
                    elsif month
@@ -47,20 +47,14 @@ module Middleman
         new_resources = []
 
         # Set up date pages if the appropriate templates have been specified
-        @blog_data.articles.group_by {|a| a.date.year }.each do |year, year_articles|
-          if @generate_year_pages && @year_template
-            new_resources << year_page_resource(year, year_articles)
-          end
+        @blog_data.articles.group_by { |a| a.date.year }.each do |year, year_articles|
+          new_resources << year_page_resource(year, year_articles) if @generate_year_pages && @year_template
 
-          year_articles.group_by {|a| a.date.month }.each do |month, month_articles|
-            if @generate_month_pages && @month_template
-              new_resources << month_page_resource(year, month, month_articles)
-            end
+          year_articles.group_by { |a| a.date.month }.each do |month, month_articles|
+            new_resources << month_page_resource(year, month, month_articles) if @generate_month_pages && @month_template
 
-            month_articles.group_by {|a| a.date.day }.each do |day, day_articles|
-              if @generate_day_pages && @day_template
-                new_resources << day_page_resource(year, month, day, day_articles)
-              end
+            month_articles.group_by { |a| a.date.day }.each do |day, day_articles|
+              new_resources << day_page_resource(year, month, day, day_articles) if @generate_day_pages && @day_template
             end
           end
         end
@@ -109,4 +103,4 @@ module Middleman
       end
     end
   end
-end
+end

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

@@ -3,9 +3,7 @@ require 'date'
 require 'middleman-blog/uri_templates'
 
 module Middleman
-
   module Cli
-
     ##
     # This class provides an "article" command for the middleman CLI.
     #
@@ -18,7 +16,6 @@ module Middleman
     # @todo Tags should be removed from the template if they are not required
     ##
     class Article < ::Thor::Group
-
       include Thor::Actions
       include Blog::UriTemplates
 
@@ -27,110 +24,104 @@ module Middleman
       # Template files are relative to this file
       # @return [String]
       def self.source_root
-        File.dirname( __FILE__ )
+        File.dirname(__FILE__)
       end
 
       argument :title, type: :string
 
-      class_option "blog",
-        aliases: "-b",
-        desc:    "The name of the blog to create the post inside (for multi-blog apps, defaults to the only blog in single-blog apps)"
+      class_option 'blog',
+                   aliases: '-b',
+                   desc: 'The name of the blog to create the post inside (for multi-blog apps, defaults to the only blog in single-blog apps)'
 
-      class_option "content",
-        aliases: "-c",
-        desc: "Content of the post"
+      class_option 'content',
+                   aliases: '-c',
+                   desc: 'Content of the post'
 
-      class_option "date",
-        aliases: "-d",
-        desc:    "The date to create the post with (defaults to now)"
+      class_option 'date',
+                   aliases: '-d',
+                   desc: 'The date to create the post with (defaults to now)'
 
-      class_option "locale",
-        aliases: "-l",
-        desc:    "The locale to create the post with (defaults to I18n.default_locale if available)"
+      class_option 'locale',
+                   aliases: '-l',
+                   desc: 'The locale to create the post with (defaults to I18n.default_locale if available)'
 
-      class_option "edit",
-        aliases: "-e",
-        desc:    "Edit the newly created blog post",
-        default: false,
-        type:    :boolean
+      class_option 'edit',
+                   aliases: '-e',
+                   desc: 'Edit the newly created blog post',
+                   default: false,
+                   type: :boolean
 
-      class_option "subdirectory",
-        aliases: "-s",
-        desc:    "Generate an article subdirectory (for directory indexes, defaults to false)",
-        default: false,
-        type:    :boolean
+      class_option 'subdirectory',
+                   aliases: '-s',
+                   desc: 'Generate an article subdirectory (for directory indexes, defaults to false)',
+                   default: false,
+                   type: :boolean
 
-      class_option "tags",
-        aliases: "-t",
-        desc: "A list of comma-separated tags for the post"
+      class_option 'tags',
+                   aliases: '-t',
+                   desc: 'A list of comma-separated tags for the post'
 
       def article
-
-        @content = options[:content] || ""
-        @date    = options[ :date ] ? ::Time.zone.parse( options[ :date ] ) : Time.zone.now
-        @locale  = options[ :locale ] || ( ::I18n.default_locale if defined? ::I18n )
-        @slug    = safe_parameterize( title )
-        @tags    = options[:tags] && options[:tags].split(/\s*,\s*/) || []
+        @content = options[:content] || ''
+        @date    = options[:date] ? ::Time.zone.parse(options[:date]) : Time.zone.now
+        @locale  = options[:locale] || (::I18n.default_locale if defined? ::I18n)
+        @slug    = safe_parameterize(title)
+        @tags    = options[:tags]&.split(/\s*,\s*/) || []
         @title   = title
 
         app = ::Middleman::Application.new do
-          config[ :mode ]              = :config
-          config[ :disable_sitemap ]   = true
-          config[ :watcher_disable ]   = true
-          config[ :exit_before_ready ] = true
+          config[:mode]              = :config
+          config[:disable_sitemap]   = true
+          config[:watcher_disable]   = true
+          config[:exit_before_ready] = true
         end
 
-        blog_inst = if options[ :blog ]
-          app.extensions[ :blog ].find { | key, instance | instance.options[ :name ] == options[ :blog ] }[ 1 ]
-        else
-          app.extensions[ :blog ].values.first
-        end
+        blog_inst = if options[:blog]
+                      app.extensions[:blog].find { |_key, instance| instance.options[:name] == options[:blog] }[ 1 ]
+                    else
+                      app.extensions[:blog].values.first
+                    end
 
         unless blog_inst
-          msg = "Could not find an active blog instance"
-          msg << " named #{ options[ :blog ] }" if options[ :blog ]
+          msg = 'Could not find an active blog instance'
+          msg << " named #{options[:blog]}" if options[:blog]
           throw msg
         end
 
         path_template         = blog_inst.data.source_template
-        params                = date_to_params( @date ).merge( locale: @locale.to_s, title: @slug )
+        params                = date_to_params(@date).merge(locale: @locale.to_s, title: @slug)
         article_path          = apply_uri_template path_template, params
-        absolute_article_path = File.join( app.source_dir, article_path + blog_inst.options.default_extension )
+        absolute_article_path = File.join(app.source_dir, article_path + blog_inst.options.default_extension)
 
         template blog_inst.options.new_article_template, absolute_article_path
 
         # Edit option process
-        if options[ :edit ]
+        if options[:edit]
 
-          editor = ENV.fetch( 'MM_EDITOR', ENV.fetch( 'EDITOR', nil ) )
+          editor = ENV.fetch('MM_EDITOR', ENV.fetch('EDITOR', nil))
 
           if editor
-            system( "#{ editor } #{ absolute_article_path }" )
+            system("#{editor} #{absolute_article_path}")
           else
-            throw "Could not find a suitable editor. Try setting the environment variable MM_EDITOR."
+            throw 'Could not find a suitable editor. Try setting the environment variable MM_EDITOR.'
           end
 
         end
 
         # Subdirectory option process
-        if options[ :subdirectory ]
-          empty_directory extract_directory_path( File.join( app.source_dir, article_path ) )
-        end
-
+        empty_directory extract_directory_path(File.join(app.source_dir, article_path)) if options[:subdirectory]
       end
 
       protected
 
-      def blog_instance( key )
-        return nil unless app.extensions[ :blog ]
-        return app.extensions[ :blog ][ key ]
+      def blog_instance(key)
+        return nil unless app.extensions[:blog]
+
+        app.extensions[:blog][key]
       end
 
       # Add to CLI
-      Base.register( self, 'article', 'article TITLE [options]', 'Create a new blog article' )
-
+      Base.register(self, 'article', 'article TITLE [options]', 'Create a new blog article')
     end
-
   end
-
 end

data/lib/middleman-blog/custom_pages.rb

@@ -2,7 +2,6 @@ require 'middleman-blog/uri_templates'
 
 module Middleman
   module Blog
-
     # This adds new summary pages for arbitrarily defined blog article properties
     class CustomPages
       include UriTemplates
@@ -26,9 +25,9 @@ module Middleman
       end
 
       def manipulate_resource_list(resources)
-        articles_by_property = @blog_data.articles.
-          select {|a| a.data[property] }.
-          group_by {|a| a.data[property] }
+        articles_by_property = @blog_data.articles
+                                         .select { |a| a.data[property] }
+                                         .group_by { |a| a.data[property] }
         resources + articles_by_property.map do |property_value, articles|
           build_resource(link(property_value), property_value, articles)
         end
@@ -40,13 +39,13 @@ module Middleman
         articles = articles.sort_by(&:date).reverse
         Sitemap::ProxyResource.new(@sitemap, path, @page_template).tap do |p|
           p.add_metadata locals: {
-            "page_type"       => property.to_s,
-            property          => value,
-            "articles"        => articles,
-            "blog_controller" => @blog_controller
+            'page_type' => property.to_s,
+            property => value,
+            'articles' => articles,
+            'blog_controller' => @blog_controller
           }
         end
       end
     end
   end
-end
+end

data/lib/middleman-blog/extension.rb

@@ -39,7 +39,7 @@ module Middleman
     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 :new_article_template, File.expand_path('commands/article.tt', __dir__), '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
@@ -61,9 +61,9 @@ module Middleman
     attr_reader :custom_pages
 
     # Helpers for use within templates and layouts.
-    self.defined_helpers = [ Middleman::Blog::Helpers ]
+    self.defined_helpers = [Middleman::Blog::Helpers]
 
-    def initialize(app, options_hash={}, &block)
+    def initialize(app, options_hash = {}, &block)
       super
 
       @custom_pages = {}
@@ -88,7 +88,7 @@ module Middleman
         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|
+        options.custom_collections.each do |_key, opts|
           opts[:link] = File.join(options.prefix, opts[:link])
         end
       end
@@ -99,7 +99,7 @@ module Middleman
         found_name = nil
 
         app.extensions[:blog].values.each_with_index do |ext, i|
-          found_name = "blog#{i+1}" if ext == self
+          found_name = "blog#{i + 1}" if ext == self
         end
 
         found_name
@@ -119,9 +119,8 @@ module Middleman
       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
+      raise 'Value assigned to time_zone not recognized.' unless zone_default
+
       Time.zone_default = zone_default
 
       # Initialize blog with options

data/lib/middleman-blog/helpers.rb

@@ -26,25 +26,21 @@ module Middleman
       #
       # @param [Symbol, String] blog_name Optional name of the blog to get a controller for.
       # @return [BlogExtension]
-      def blog_controller(blog_name=nil)
+      def blog_controller(blog_name = nil)
         if !blog_name && current_resource
           blog_name = current_resource.metadata[:page][:blog]
 
-          if !blog_name
+          unless blog_name
             blog_controller = current_resource.blog_controller if current_resource.respond_to?(:blog_controller)
             return blog_controller if blog_controller
           end
         end
 
         # In multiblog situations, force people to specify the blog
-        if !blog_name && blog_instances.size > 1
-          raise "You have more than one blog so you must either use the flag --blog (ex. --blog 'myBlog') when calling this method, or add blog: [blog_name] to your page's frontmatter"
-        end
+        raise "You have more than one blog so you must either use the flag --blog (ex. --blog 'myBlog') when calling this method, or add blog: [blog_name] to your page's frontmatter" if !blog_name && blog_instances.size > 1
 
         # Warn if a non-existent blog name provided
-        if blog_name && !blog_instances.keys.include?(blog_name.to_sym)
-          raise "Non-existent blog name provided: #{blog_name}."
-        end
+        raise "Non-existent blog name provided: #{blog_name}." if blog_name && !blog_instances.key?(blog_name.to_sym)
 
         blog_name ||= blog_instances.keys.first
         blog_instances[blog_name.to_sym]
@@ -56,14 +52,14 @@ module Middleman
       # @param [Symbol, String] blog_name Optional name of the blog to get data for.
       #   Blogs can be named as an option or will default to 'blog0', 'blog1', etc..
       # @return [BlogData]
-      def blog(blog_name=nil)
+      def blog(blog_name = nil)
         blog_controller(blog_name).data
       end
 
       # Determine whether the currently rendering template is a {BlogArticle}.
       # This can be useful in layouts and helpers.
       # @return [Boolean]
-      def is_blog_article?
+      def is_blog_article? # rubocop:disable Naming/PredicateName
         !current_article.nil?
       end
 
@@ -71,18 +67,14 @@ module Middleman
       # @return [BlogArticle]
       def current_article
         article = current_resource
-        if article && article.is_a?(BlogArticle)
-          article
-        else
-          nil
-        end
+        article if article&.is_a?(BlogArticle)
       end
 
       # Get a path to the given tag page, based on the +taglink+ blog setting.
       # @param [String] tag
       # @param [Symbol, String] blog_name Optional name of the blog to use.
       # @return [String]
-      def tag_path(tag, blog_name=nil)
+      def tag_path(tag, blog_name = nil)
         build_url blog_controller(blog_name).tag_pages.link(tag)
       end
 
@@ -90,7 +82,7 @@ module Middleman
       # @param [Number] year
       # @param [Symbol, String] blog_name Optional name of the blog to use.
       # @return [String]
-      def blog_year_path(year, blog_name=nil)
+      def blog_year_path(year, blog_name = nil)
         build_url blog_controller(blog_name).calendar_pages.link(year)
       end
 
@@ -99,7 +91,7 @@ module Middleman
       # @param [Number] month
       # @param [Symbol, String] blog_name Optional name of the blog to use.
       # @return [String]
-      def blog_month_path(year, month, blog_name=nil)
+      def blog_month_path(year, month, blog_name = nil)
         build_url blog_controller(blog_name).calendar_pages.link(year, month)
       end
 
@@ -109,7 +101,7 @@ module Middleman
       # @param [Number] day
       # @param [Symbol, String] blog_name Optional name of the blog to use.
       # @return [String]
-      def blog_day_path(year, month, day, blog_name=nil)
+      def blog_day_path(year, month, day, blog_name = nil)
         build_url blog_controller(blog_name).calendar_pages.link(year, month, day)
       end
 
@@ -123,13 +115,13 @@ module Middleman
       # Returns the list of articles to display on this particular page (when using pagination).
       # @param [Symbol, String] blog_name Optional name of the blog to use.
       # @return [Array<Middleman::Sitemap::Resource>]
-      def page_articles(blog_name=nil)
+      def page_articles(blog_name = nil)
         meta = current_resource.metadata
         limit = current_resource.data[:per_page]
 
         # "articles" local variable is populated by Calendar and Tag page generators
         # If it's not set then use the complete list of articles
-        articles = meta[:locals]["articles"] || blog(blog_name).articles
+        articles = meta[:locals]['articles'] || blog(blog_name).articles
 
         limit ? articles.first(limit) : articles
       end
@@ -142,12 +134,11 @@ module Middleman
       # @param [Symbol] property Custom property which is being used to collect articles on
       # @private
       def self.generate_custom_helper(property)
-        define_method :"#{property}_path" do |value, blog_name=nil|
+        define_method :"#{property}_path" do |value, blog_name = nil|
           custom_pages = blog_controller(blog_name).custom_pages
 
-          if !custom_pages.key?(property)
-            raise "This blog does not know about the custom property #{property.inspect}"
-          end
+          raise "This blog does not know about the custom property #{property.inspect}" unless custom_pages.key?(property)
+
           build_url custom_pages[property].link(value)
         end
       end
@@ -159,4 +150,4 @@ module Middleman
       end
     end
   end
-end
+end

data/lib/middleman-blog/paginator.rb

@@ -7,7 +7,7 @@ module Middleman
     class Paginator
       include UriTemplates
 
-      def initialize( app, blog_controller )
+      def initialize(app, blog_controller)
         @app             = app
         @blog_controller = blog_controller
         @per_page        = blog_controller.options.per_page
@@ -33,8 +33,8 @@ module Middleman
           # "articles" local variable is populated by Calendar and Tag page generators
           # If it's not set then use the complete list of articles
           # TODO: Some way to allow the frontmatter to specify the article filter?
-          articles = md[:locals]["articles"] || @blog_controller.data.articles
-          articles.select!{|article| article.lang == md[:options][:locale]} if md.fetch(:options, false) and md[:options].fetch(:locale, false)
+          articles = md[:locals]['articles'] || @blog_controller.data.articles
+          articles.select! { |article| article.lang == md[:options][:locale] } if md.fetch(:options, false) && md[:options].fetch(:locale, false)
 
           # Allow blog.per_page and blog.page_link to be overridden in the frontmatter
           per_page  = md[:page][:per_page] || @per_page
@@ -72,8 +72,9 @@ module Middleman
       # Does this resource match the blog controller for this paginator?
       # @return [Boolean]
       def match_blog(res, md)
-        res_controller = md[:locals]["blog_controller"] || (res.respond_to?(:blog_controller) && res.blog_controller)
+        res_controller = md[:locals]['blog_controller'] || (res.respond_to?(:blog_controller) && res.blog_controller)
         return false if res_controller && res_controller != @blog_controller
+
         override_controller = md[:page][:blog]
         return false if override_controller && override_controller.to_s != @blog_controller.name.to_s