jekyll 3.2.0.pre.beta1 → 3.2.0.pre.beta2

data/lib/jekyll/converters/markdown.rb

@@ -9,23 +9,33 @@ module Jekyll
         return if @setup ||= false
         unless (@parser = get_processor)
           Jekyll.logger.error "Invalid Markdown processor given:", @config["markdown"]
-          Jekyll.logger.info  "", "Custom processors are not loaded in safe mode" if @config["safe"]
-          Jekyll.logger.error "", "Available processors are: #{valid_processors.join(", ")}"
+          if @config["safe"]
+            Jekyll.logger.info "", "Custom processors are not loaded in safe mode"
+          end
+          Jekyll.logger.error(
+            "",
+            "Available processors are: #{valid_processors.join(", ")}"
+          )
           raise Errors::FatalException, "Bailing out; invalid Markdown processor."
         end
 
         @setup = true
       end
 
+      # Rubocop does not allow reader methods to have names starting with `get_`
+      # To ensure compatibility, this check has been disabled on this method
+      #
+      # rubocop:disable Style/AccessorMethodName
       def get_processor
         case @config["markdown"].downcase
         when "redcarpet" then return RedcarpetParser.new(@config)
         when "kramdown"  then return KramdownParser.new(@config)
         when "rdiscount" then return RDiscountParser.new(@config)
         else
-          get_custom_processor
+          custom_processor
         end
       end
+      # rubocop:enable Style/AccessorMethodName
 
       # Public: Provides you with a list of processors, the ones we
       # support internally and the ones that you have provided to us (if you
@@ -41,13 +51,13 @@ module Jekyll
 
       def third_party_processors
         self.class.constants - \
-        %w(KramdownParser RDiscountParser RedcarpetParser PRIORITIES).map(
-          &:to_sym
-        )
+          %w(KramdownParser RDiscountParser RedcarpetParser PRIORITIES).map(
+            &:to_sym
+          )
       end
 
       def extname_list
-        @extname_list ||= @config['markdown_ext'].split(',').map do |e|
+        @extname_list ||= @config["markdown_ext"].split(",").map do |e|
           ".#{e.downcase}"
         end
       end
@@ -66,7 +76,7 @@ module Jekyll
       end
 
       private
-      def get_custom_processor
+      def custom_processor
         converter_name = @config["markdown"]
         if custom_class_allowed?(converter_name)
           self.class.const_get(converter_name).new(@config)
@@ -83,7 +93,7 @@ module Jekyll
 
       private
       def custom_class_allowed?(parser_name)
-        parser_name !~ /[^A-Za-z0-9_]/ && self.class.constants.include?(
+        parser_name !~ %r![^A-Za-z0-9_]! && self.class.constants.include?(
           parser_name.to_sym
         )
       end

data/lib/jekyll/converters/markdown/kramdown_parser.rb

@@ -24,7 +24,8 @@ module Jekyll
 
         # Setup and normalize the configuration:
         #   * Create Kramdown if it doesn't exist.
-        #   * Set syntax_highlighter, detecting enable_coderay and merging highlighter if none.
+        #   * Set syntax_highlighter, detecting enable_coderay and merging
+        #       highlighter if none.
         #   * Merge kramdown[coderay] into syntax_highlighter_opts stripping coderay_.
         #   * Make sure `syntax_highlighter_opts` exists.
 
@@ -52,7 +53,9 @@ module Jekyll
           end
         end
 
-        # config[kramdown][syntax_higlighter] > config[kramdown][enable_coderay] > config[highlighter]
+        # config[kramdown][syntax_higlighter] >
+        #   config[kramdown][enable_coderay] >
+        #   config[highlighter]
         # Where `enable_coderay` is now deprecated because Kramdown
         # supports Rouge now too.
 
@@ -68,8 +71,10 @@ module Jekyll
 
           @highlighter = begin
             if @config.key?("enable_coderay") && @config["enable_coderay"]
-              Jekyll::Deprecator.deprecation_message "You are using 'enable_coderay', " \
+              Jekyll::Deprecator.deprecation_message(
+                "You are using 'enable_coderay', " \
                 "use syntax_highlighter: coderay in your configuration file."
+              )
 
               "coderay"
             else
@@ -81,7 +86,7 @@ module Jekyll
         private
         def strip_coderay_prefix(hash)
           hash.each_with_object({}) do |(key, val), hsh|
-            cleaned_key = key.gsub(/\Acoderay_/, "")
+            cleaned_key = key.gsub(%r!\Acoderay_!, "")
 
             if key != cleaned_key
               Jekyll::Deprecator.deprecation_message(
@@ -100,8 +105,10 @@ module Jekyll
         private
         def modernize_coderay_config
           if highlighter == "coderay"
-            Jekyll::Deprecator.deprecation_message "You are using 'kramdown.coderay' in your configuration, " \
+            Jekyll::Deprecator.deprecation_message(
+              "You are using 'kramdown.coderay' in your configuration, " \
               "please use 'syntax_highlighter_opts' instead."
+            )
 
             @config["syntax_highlighter_opts"] = begin
               strip_coderay_prefix(

data/lib/jekyll/converters/markdown/rdiscount_parser.rb

@@ -5,14 +5,14 @@ module Jekyll
         def initialize(config)
           Jekyll::External.require_with_graceful_fail "rdiscount"
           @config = config
-          @rdiscount_extensions = @config['rdiscount']['extensions'].map(&:to_sym)
+          @rdiscount_extensions = @config["rdiscount"]["extensions"].map(&:to_sym)
         end
 
         def convert(content)
           rd = RDiscount.new(content, *@rdiscount_extensions)
           html = rd.to_html
-          if @config['rdiscount']['toc_token']
-            html = replace_generated_toc(rd, html, @config['rdiscount']['toc_token'])
+          if @config["rdiscount"]["toc_token"]
+            html = replace_generated_toc(rd, html, @config["rdiscount"]["toc_token"])
           end
           html
         end
@@ -21,7 +21,7 @@ module Jekyll
         def replace_generated_toc(rd, html, toc_token)
           if rd.generate_toc && html.include?(toc_token)
             utf8_toc = rd.toc_content
-            utf8_toc.force_encoding('utf-8') if utf8_toc.respond_to?(:force_encoding)
+            utf8_toc.force_encoding("utf-8") if utf8_toc.respond_to?(:force_encoding)
             html.gsub(toc_token, utf8_toc)
           else
             html

data/lib/jekyll/converters/markdown/redcarpet_parser.rb

@@ -1,102 +1,108 @@
-module Jekyll
-  module Converters
-    class Markdown
-      class RedcarpetParser
-        module CommonMethods
-          def add_code_tags(code, lang)
-            code = code.to_s
-            code = code.sub(/<pre>/, "<pre><code class=\"language-#{lang}\" data-lang=\"#{lang}\">")
-            code = code.sub(/<\/pre>/, "</code></pre>")
-            code
-          end
-        end
-
-        module WithPygments
-          include CommonMethods
-          def block_code(code, lang)
-            Jekyll::External.require_with_graceful_fail("pygments")
-            lang = lang && lang.split.first || "text"
-            add_code_tags(
-              Pygments.highlight(code, :lexer => lang, :options => { :encoding => 'utf-8' }),
-              lang
-            )
-          end
-        end
+class Jekyll::Converters::Markdown::RedcarpetParser
+  module CommonMethods
+    def add_code_tags(code, lang)
+      code = code.to_s
+      code = code.sub(
+        %r!<pre>!,
+        "<pre><code class=\"language-#{lang}\" data-lang=\"#{lang}\">"
+      )
+      code = code.sub(%r!</pre>!, "</code></pre>")
+      code
+    end
+  end
 
-        module WithoutHighlighting
-          require 'cgi'
+  module WithPygments
+    include CommonMethods
+    def block_code(code, lang)
+      Jekyll::External.require_with_graceful_fail("pygments")
+      lang = lang && lang.split.first || "text"
+      add_code_tags(
+        Pygments.highlight(
+          code,
+          {
+            :lexer   => lang,
+            :options => { :encoding => "utf-8" }
+          }
+        ),
+        lang
+      )
+    end
+  end
 
-          include CommonMethods
+  module WithoutHighlighting
+    require "cgi"
 
-          def code_wrap(code)
-            "<figure class=\"highlight\"><pre>#{CGI::escapeHTML(code)}</pre></figure>"
-          end
+    include CommonMethods
 
-          def block_code(code, lang)
-            lang = lang && lang.split.first || "text"
-            add_code_tags(code_wrap(code), lang)
-          end
-        end
+    def code_wrap(code)
+      "<figure class=\"highlight\"><pre>#{CGI.escapeHTML(code)}</pre></figure>"
+    end
 
-        module WithRouge
-          def block_code(code, lang)
-            code = "<pre>#{super}</pre>"
+    def block_code(code, lang)
+      lang = lang && lang.split.first || "text"
+      add_code_tags(code_wrap(code), lang)
+    end
+  end
 
-            output = "<div class=\"highlight\">"
-            output << add_code_tags(code, lang)
-            output << "</div>"
-          end
+  module WithRouge
+    def block_code(code, lang)
+      code = "<pre>#{super}</pre>"
 
-          protected
-          def rouge_formatter(_lexer)
-            Rouge::Formatters::HTML.new(:wrap => false)
-          end
-        end
+      output = "<div class=\"highlight\">"
+      output << add_code_tags(code, lang)
+      output << "</div>"
+    end
 
-        def initialize(config)
-          External.require_with_graceful_fail("redcarpet")
-          @config = config
-          @redcarpet_extensions = {}
-          @config['redcarpet']['extensions'].each { |e| @redcarpet_extensions[e.to_sym] = true }
+    protected
+    def rouge_formatter(_lexer)
+      Rouge::Formatters::HTML.new(:wrap => false)
+    end
+  end
 
-          @renderer ||= class_with_proper_highlighter(@config['highlighter'])
-        end
+  def initialize(config)
+    Jekyll::External.require_with_graceful_fail("redcarpet")
+    @config = config
+    @redcarpet_extensions = {}
+    @config["redcarpet"]["extensions"].each do |e|
+      @redcarpet_extensions[e.to_sym] = true
+    end
 
-        def class_with_proper_highlighter(highlighter)
-          case highlighter
-          when "pygments"
-            Class.new(Redcarpet::Render::HTML) do
-              include WithPygments
-            end
-          when "rouge"
-            Class.new(Redcarpet::Render::HTML) do
-              Jekyll::External.require_with_graceful_fail(%w(
-                rouge
-                rouge/plugins/redcarpet
-              ))
+    @renderer ||= class_with_proper_highlighter(@config["highlighter"])
+  end
 
-              unless Gem::Version.new(Rouge.version) > Gem::Version.new("1.3.0")
-                abort "Please install Rouge 1.3.0 or greater and try running Jekyll again."
-              end
+  def class_with_proper_highlighter(highlighter)
+    Class.new(Redcarpet::Render::HTML) do
+      case highlighter
+      when "pygments"
+        include WithPygments
+      when "rouge"
+        Jekyll::External.require_with_graceful_fail(%w(
+          rouge rouge/plugins/redcarpet
+        ))
 
-              include Rouge::Plugins::Redcarpet
-              include CommonMethods
-              include WithRouge
-            end
-          else
-            Class.new(Redcarpet::Render::HTML) do
-              include WithoutHighlighting
-            end
-          end
+        unless Gem::Version.new(Rouge.version) > Gem::Version.new("1.3.0")
+          abort "Please install Rouge 1.3.0 or greater and try running Jekyll again."
         end
 
-        def convert(content)
-          @redcarpet_extensions[:fenced_code_blocks] = !@redcarpet_extensions[:no_fenced_code_blocks]
-          @renderer.send :include, Redcarpet::Render::SmartyPants if @redcarpet_extensions[:smart]
-          markdown = Redcarpet::Markdown.new(@renderer.new(@redcarpet_extensions), @redcarpet_extensions)
-          markdown.render(content)
-        end
+        include Rouge::Plugins::Redcarpet
+        include CommonMethods
+        include WithRouge
+      else
+        include WithoutHighlighting
       end
     end
   end
+
+  def convert(content)
+    @redcarpet_extensions[:fenced_code_blocks] = \
+      !@redcarpet_extensions[:no_fenced_code_blocks]
+    if @redcarpet_extensions[:smart]
+      @renderer.send :include, Redcarpet::Render::SmartyPants
+    end
+    markdown = Redcarpet::Markdown.new(
+      @renderer.new(@redcarpet_extensions),
+      @redcarpet_extensions
+    )
+    markdown.render(content)
+  end
 end

data/lib/jekyll/convertible.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-require 'set'
+require "set"
 
 # Convertible provides methods for converting a pagelike item
 # from a certain type of markup into actual content
@@ -20,12 +20,12 @@ module Jekyll
   module Convertible
     # Returns the contents as a String.
     def to_s
-      content || ''
+      content || ""
     end
 
     # Whether the file is published or not, as indicated in YAML front-matter
     def published?
-      !(data.key?('published') && data['published'] == false)
+      !(data.key?("published") && data["published"] == false)
     end
 
     # Read the YAML frontmatter.
@@ -47,7 +47,7 @@ module Jekyll
         end
       rescue SyntaxError => e
         Jekyll.logger.warn "YAML Exception reading #{filename}: #{e.message}"
-      rescue Exception => e
+      rescue => e
         Jekyll.logger.warn "Error reading file #{filename}: #{e.message}"
       end
 
@@ -61,12 +61,13 @@ module Jekyll
 
     def validate_data!(filename)
       unless self.data.is_a?(Hash)
-        raise Errors::InvalidYAMLFrontMatterError, "Invalid YAML front matter in #{filename}"
+        raise Errors::InvalidYAMLFrontMatterError,
+          "Invalid YAML front matter in #{filename}"
       end
     end
 
     def validate_permalink!(filename)
-      if self.data['permalink'] && self.data['permalink'].size == 0
+      if self.data["permalink"] && self.data["permalink"].empty?
         raise Errors::InvalidPermalinkError, "Invalid permalink in #{filename}"
       end
     end
@@ -79,7 +80,10 @@ module Jekyll
         begin
           converter.convert output
         rescue => e
-          Jekyll.logger.error "Conversion error:", "#{converter.class} encountered an error while converting '#{path}':"
+          Jekyll.logger.error(
+            "Conversion error:",
+            "#{converter.class} encountered an error while converting '#{path}':"
+          )
           Jekyll.logger.error("", e.to_s)
           raise e
         end
@@ -112,12 +116,17 @@ module Jekyll
     def render_liquid(content, payload, info, path)
       site.liquid_renderer.file(path).parse(content).render!(payload, info)
     rescue Tags::IncludeTagError => e
-      Jekyll.logger.error "Liquid Exception:", "#{e.message} in #{e.path}, included in #{path || self.path}"
+      Jekyll.logger.error(
+        "Liquid Exception:",
+        "#{e.message} in #{e.path}, included in #{path || self.path}"
+      )
       raise e
+    # rubocop: disable RescueException
     rescue Exception => e
       Jekyll.logger.error "Liquid Exception:", "#{e.message} in #{path || self.path}"
       raise e
     end
+    # rubocop: enable RescueException
 
     # Convert this Convertible's data to a Hash suitable for use by Liquid.
     #
@@ -168,7 +177,7 @@ module Jekyll
     #
     # Returns true if extname == .coffee, false otherwise.
     def coffeescript_file?
-      '.coffee'.eql?(ext)
+      ".coffee" == ext
     end
 
     # Determine whether the file should be rendered with Liquid.
@@ -205,14 +214,20 @@ module Jekyll
       # recursively render layouts
       layout = layouts[data["layout"]]
 
-      Jekyll.logger.warn("Build Warning:", "Layout '#{data["layout"]}' requested in #{path} does not exist.") if invalid_layout? layout
+      Jekyll.logger.warn(
+        "Build Warning:",
+        "Layout '#{data["layout"]}' requested in #{path} does not exist."
+      ) if invalid_layout? layout
 
       used = Set.new([layout])
 
+      # Reset the payload layout data to ensure it starts fresh for each page.
+      payload["layout"] = nil
+
       while layout
         Jekyll.logger.debug "Rendering Layout:", path
         payload["content"] = output
-        payload["layout"]  = Utils.deep_merge_hashes(payload["layout"] || {}, layout.data)
+        payload["layout"]  = Utils.deep_merge_hashes(layout.data, payload["layout"] || {})
 
         self.output = render_liquid(layout.content,
                                     payload,
@@ -225,12 +240,9 @@ module Jekyll
           site.in_source_dir(layout.path)
         )
 
-        if layout = layouts[layout.data["layout"]]
-          if used.include?(layout)
-            layout = nil # avoid recursive chain
-          else
-            used << layout
-          end
+        if (layout = layouts[layout.data["layout"]])
+          break if used.include?(layout)
+          used << layout
         end
       end
     end
@@ -246,7 +258,10 @@ module Jekyll
 
       Jekyll.logger.debug "Pre-Render Hooks:", self.relative_path
       Jekyll::Hooks.trigger hook_owner, :pre_render, self, payload
-      info = { :filters => [Jekyll::Filters], :registers => { :site => site, :page => payload["page"] } }
+      info = {
+        :filters   => [Jekyll::Filters],
+        :registers => { :site => site, :page => payload["page"] }
+      }
 
       # render and transform content (this becomes the final content of the object)
       payload["highlighter_prefix"] = converters.first.highlighter_prefix
@@ -275,9 +290,7 @@ module Jekyll
     def write(dest)
       path = destination(dest)
       FileUtils.mkdir_p(File.dirname(path))
-      File.open(path, 'wb') do |f|
-        f.write(output)
-      end
+      File.write(path, output, :mode => "wb")
       Jekyll::Hooks.trigger hook_owner, :post_write, self
     end