jekyll 3.0.5 → 3.1.0.pre.beta1

data/lib/jekyll/commands/serve/servlet.rb

@@ -0,0 +1,61 @@
+require "webrick"
+
+module Jekyll
+  module Commands
+    class Serve
+      class Servlet < WEBrick::HTTPServlet::FileHandler
+        DEFAULTS = {
+          "Cache-Control" => "private, max-age=0, proxy-revalidate, " \
+            "no-store, no-cache, must-revalidate"
+        }
+
+        def initialize(server, root, callbacks)
+          # So we can access them easily.
+          @jekyll_opts = server.config[:JekyllOptions]
+          set_defaults
+          super
+        end
+
+        # Add the ability to tap file.html the same way that Nginx does on our
+        # Docker images (or on Github pages.) The difference is that we might end
+        # up with a different preference on which comes first.
+
+        def search_file(req, res, basename)
+          # /file.* > /file/index.html > /file.html
+          super || super(req, res, "#{basename}.html")
+        end
+
+        #
+
+        def do_GET(req, res)
+          rtn = super
+          validate_and_ensure_charset(req, res)
+          res.header.merge!(@headers)
+          rtn
+        end
+
+        #
+
+        private
+        def validate_and_ensure_charset(req, res)
+          key = res.header.keys.grep(/content-type/i).first
+          typ = res.header[key]
+
+          unless typ =~ /;\s*charset=/
+            res.header[key] = "#{typ}; charset=#{@jekyll_opts["encoding"]}"
+          end
+        end
+
+        #
+
+        private
+        def set_defaults
+          hash_ = @jekyll_opts.fetch("webrick", {}).fetch("headers", {})
+          DEFAULTS.each_with_object(@headers = hash_) do |(key, val), hash|
+            hash[key] = val if !hash.key?(key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/configuration.rb

@@ -65,39 +65,14 @@ module Jekyll
 
       'kramdown' => {
         'auto_ids'       => true,
-        'footnote_nr'    => 1,
-        'entity_output'  => 'as_char',
         'toc_levels'     => '1..6',
+        'entity_output'  => 'as_char',
         'smart_quotes'   => 'lsquo,rsquo,ldquo,rdquo',
-        'enable_coderay' => false,
-
-        'coderay' => {
-          'coderay_wrap'              => 'div',
-          'coderay_line_numbers'      => 'inline',
-          'coderay_line_number_start' => 1,
-          'coderay_tab_width'         => 4,
-          'coderay_bold_every'        => 10,
-          'coderay_css'               => 'style'
-        }
+        'input'          => "GFM",
+        'hard_wrap'      => false,
+        'footnote_nr'    => 1
       }
-    }].freeze
-
-    class << self
-      # Static: Produce a Configuration ready for use in a Site.
-      # It takes the input, fills in the defaults where values do not
-      # exist, and patches common issues including migrating options for
-      # backwards compatiblity. Except where a key or value is being fixed,
-      # the user configuration will override the defaults.
-      #
-      # user_config - a Hash or Configuration of overrides.
-      #
-      # Returns a Configuration filled with defaults and fixed for common
-      # problems and backwards-compatibility.
-      def from(user_config)
-        Utils.deep_merge_hashes(DEFAULTS, Configuration[user_config].stringify_keys).
-          fix_common_issues.add_default_collections
-      end
-    end
+    }]
 
     # Public: Turn all keys into string
     #
@@ -135,7 +110,7 @@ module Jekyll
         Jekyll::External.require_with_graceful_fail('toml') unless defined?(TOML)
         TOML.load_file(filename)
       when /\.ya?ml/i
-        SafeYAML.load_file(filename)
+        SafeYAML.load_file(filename) || {}
       else
         raise ArgumentError, "No parser for '#{filename}' is available. Use a .toml or .y(a)ml file instead."
       end
@@ -170,7 +145,7 @@ module Jekyll
     # Returns this configuration, overridden by the values in the file
     def read_config_file(file)
       next_config = safe_load_file(file)
-      raise ArgumentError.new("Configuration file: (INVALID) #{file}".yellow) unless next_config.is_a?(Hash)
+      check_config_is_hash!(next_config, file)
       Jekyll.logger.info "Configuration file:", file
       next_config
     rescue SystemCallError
@@ -194,7 +169,6 @@ module Jekyll
 
       begin
         files.each do |config_file|
-          next if config_file.nil? or config_file.empty?
           new_config = read_config_file(config_file)
           configuration = Utils.deep_merge_hashes(configuration, new_config)
         end
@@ -254,14 +228,15 @@ module Jekyll
       end
 
       %w[include exclude].each do |option|
-        if config.fetch(option, []).is_a?(String)
+        config[option] ||= []
+        if config[option].is_a?(String)
           Jekyll::Deprecator.deprecation_message "The '#{option}' configuration option" +
             " must now be specified as an array, but you specified" +
             " a string. For now, we've treated the string you provided" +
             " as a list of comma-separated values."
           config[option] = csv_to_array(config[option])
         end
-        config[option].map!(&:to_s) if config[option]
+        config[option].map!(&:to_s)
       end
 
       if (config['kramdown'] || {}).key?('use_coderay')
@@ -296,22 +271,14 @@ module Jekyll
     def add_default_collections
       config = clone
 
-      # It defaults to `{}`, so this is only if someone sets it to null manually.
       return config if config['collections'].nil?
 
-      # Ensure we have a hash.
       if config['collections'].is_a?(Array)
         config['collections'] = Hash[config['collections'].map{|c| [c, {}]}]
       end
-
-      config['collections'] = Utils.deep_merge_hashes(
-        { 'posts' => {} }, config['collections']
-      ).tap do |collections|
-        collections['posts']['output'] = true
-        if config['permalink']
-          collections['posts']['permalink'] ||= style_to_permalink(config['permalink'])
-        end
-      end
+      config['collections']['posts'] ||= {}
+      config['collections']['posts']['output'] = true
+      config['collections']['posts']['permalink'] = style_to_permalink(config['permalink'])
 
       config
     end
@@ -326,6 +293,7 @@ module Jekyll
     end
 
     private
+
     def style_to_permalink(permalink_style)
       case permalink_style.to_sym
       when :pretty
@@ -340,5 +308,17 @@ module Jekyll
         permalink_style.to_s
       end
     end
+
+    # Private: Checks if a given config is a hash
+    #
+    # extracted_config - the value to check
+    # file - the file from which the config was extracted
+    #
+    # Raises an ArgumentError if given config is not a hash
+    def check_config_is_hash!(extracted_config, file)
+      unless extracted_config.is_a?(Hash)
+        raise ArgumentError.new("Configuration file: (INVALID) #{file}".yellow)
+      end
+    end
   end
 end

data/lib/jekyll/converters/markdown.rb

@@ -1,54 +1,59 @@
 module Jekyll
   module Converters
     class Markdown < Converter
-      safe true
-
       highlighter_prefix "\n"
       highlighter_suffix "\n"
+      safe true
 
       def setup
         return if @setup
-        @parser =
-          case @config['markdown'].downcase
-            when 'redcarpet' then RedcarpetParser.new(@config)
-            when 'kramdown'  then KramdownParser.new(@config)
-            when 'rdiscount' then RDiscountParser.new(@config)
-          else
-            # So they can't try some tricky bullshit or go down the ancestor chain, I hope.
-            if allowed_custom_class?(@config['markdown'])
-              self.class.const_get(@config['markdown']).new(@config)
-            else
-              Jekyll.logger.error "Invalid Markdown Processor:", "#{@config['markdown']}"
-              Jekyll.logger.error "", "Valid options are [ #{valid_processors.join(" | ")} ]"
-              raise Errors::FatalException, "Invalid Markdown Processor: #{@config['markdown']}"
-            end
-          end
+        if (!@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(", ")}"
+          raise Errors::FatalException, "Bailing out; invalid Markdown processor."
+        end
+
         @setup = true
       end
 
+      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
+        end
+      end
+
+      # Public: Provides you with a list of processors, the ones we
+      # support internally and the ones that you have provided to us (if you
+      # are not in safe mode.)
+
       def valid_processors
-        %w[
-          rdiscount
-          kramdown
-          redcarpet
-        ] + third_party_processors
+        %W(rdiscount kramdown redcarpet) + third_party_processors
       end
 
+      # Public: A list of processors that you provide via plugins.
+      # This is really only available if you are not in safe mode, if you are
+      # in safe mode (re: Github) then there will be none.
+
       def third_party_processors
-        self.class.constants - %w[
-          KramdownParser
-          RDiscountParser
-          RedcarpetParser
-          PRIORITIES
-        ].map(&:to_sym)
+        self.class.constants - \
+        %w[KramdownParser RDiscountParser RedcarpetParser PRIORITIES].map(
+          &:to_sym
+        )
       end
 
       def extname_list
-        @extname_list ||= @config['markdown_ext'].split(',').map { |e| ".#{e.downcase}" }
+        @extname_list ||= @config['markdown_ext'].split(',').map do |e|
+          ".#{e.downcase}"
+        end
       end
 
       def matches(ext)
-        extname_list.include? ext.downcase
+        extname_list.include?(ext.downcase)
       end
 
       def output_ext(ext)
@@ -61,16 +66,26 @@ module Jekyll
       end
 
       private
+      def get_custom_processor
+        converter_name = @config["markdown"]
+        if custom_class_allowed?(converter_name)
+          self.class.const_get(converter_name).new(@config)
+        end
+      end
 
-      # Private: Determine whether a class name is an allowed custom markdown
-      # class name
+      # Private: Determine whether a class name is an allowed custom
+      #   markdown class name.
       #
       # parser_name - the name of the parser class
       #
-      # Returns true if the parser name contains only alphanumeric characters
-      # and is defined within Jekyll::Converters::Markdown
-      def allowed_custom_class?(parser_name)
-        parser_name !~ /[^A-Za-z0-9]/ && self.class.constants.include?(parser_name.to_sym)
+      # Returns true if the parser name contains only alphanumeric
+      # characters and is defined within Jekyll::Converters::Markdown
+
+      private
+      def custom_class_allowed?(parser_name)
+        parser_name !~ /[^A-Za-z0-9_]/ && self.class.constants.include?(
+          parser_name.to_sym
+        )
       end
     end
   end

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

@@ -1,33 +1,86 @@
+# Frozen-string-literal: true
+# Encoding: utf-8
+
 module Jekyll
   module Converters
     class Markdown
       class KramdownParser
+        CODERAY_DEFAULTS = {
+          "css"               => "style",
+          "bold_every"        => 10,
+          "line_numbers"      => "inline",
+          "line_number_start" => 1,
+          "tab_width"         => 4,
+          "wrap"              => "div"
+        }
+
         def initialize(config)
-          require 'kramdown'
-          @config = config
-          # If kramdown supported highlighter enabled, use that
-          highlighter = @config['highlighter']
-          if highlighter == 'rouge' || highlighter == 'coderay'
-            @config['kramdown']['syntax_highlighter'] ||= highlighter
-          end
-        rescue LoadError
-          STDERR.puts 'You are missing a library required for Markdown. Please run:'
-          STDERR.puts '  $ [sudo] gem install kramdown'
-          raise Errors::FatalException.new("Missing dependency: kramdown")
+          Jekyll::External.require_with_graceful_fail "kramdown"
+          @main_fallback_highlighter = config["highlighter"] || "rogue"
+          @config = config["kramdown"] || {}
+          setup
+        end
+
+        # Setup and normalize the configuration:
+        #   * Create Kramdown if it doesn't exist.
+        #   * 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.
+
+        def setup
+          @config["syntax_highlighter"] ||= highlighter
+          @config["syntax_highlighter_opts"] ||= {}
+          @config["coderay"] ||= {} # XXX: Legacy.
+          modernize_coderay_config
         end
 
         def convert(content)
-          # Check for use of coderay
-          if @config['kramdown']['enable_coderay']
-            %w[wrap line_numbers line_numbers_start tab_width bold_every css default_lang].each do |opt|
-              key = "coderay_#{opt}"
-              @config['kramdown'][key] = @config['kramdown']['coderay'][key] unless @config['kramdown'].key?(key)
+          Kramdown::Document.new(content, @config).to_html
+        end
+
+        # config[kramdown][syntax_higlighter] > config[kramdown][enable_coderay] > config[highlighter]
+        # Where `enable_coderay` is now deprecated because Kramdown
+        # supports Rouge now too.
+
+        private
+        def highlighter
+          @highlighter ||= begin
+            if highlighter = @config["syntax_highlighter"] then highlighter
+            elsif @config.key?("enable_coderay") && @config["enable_coderay"]
+              Jekyll::Deprecator.deprecation_message "You are using 'enable_coderay', use syntax_highlighter: coderay in your configuration file."
+              "coderay"
+            else
+              @main_fallback_highlighter
             end
           end
+        end
 
-          Kramdown::Document.new(content, Utils.symbolize_hash_keys(@config['kramdown'])).to_html
+        private
+        def strip_coderay_prefix(hash)
+          hash.each_with_object({}) do |(key, val), hsh|
+            cleaned_key = key.gsub(/\Acoderay_/, "")
+            Jekyll::Deprecator.deprecation_message "You are using '#{key}'. Normalizing to #{cleaned_key}." if key != cleaned_key
+            hsh[cleaned_key] = val
+          end
         end
 
+        # If our highlighter is CodeRay we go in to merge the CodeRay defaults
+        # with your "coderay" key if it's there, deprecating it in the
+        # process of you using it.
+
+        private
+        def modernize_coderay_config
+          if highlighter == "coderay"
+            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(
+                @config["syntax_highlighter_opts"] \
+                  .merge(CODERAY_DEFAULTS) \
+                  .merge(@config["coderay"])
+              )
+            end
+          end
+        end
       end
     end
   end

data/lib/jekyll/convertible.rb

@@ -210,7 +210,8 @@ module Jekyll
 
       while layout
         Jekyll.logger.debug "Rendering Layout:", path
-        payload = Utils.deep_merge_hashes(payload, {"content" => output, "page" => layout.data})
+        payload.content = output
+        payload.layout  = layout.data
 
         self.output = render_liquid(layout.content,
                                          payload,
@@ -244,11 +245,11 @@ 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
-      payload["highlighter_suffix"] = converters.first.highlighter_suffix
+      payload.highlighter_prefix = converters.first.highlighter_prefix
+      payload.highlighter_suffix = converters.first.highlighter_suffix
 
       if render_with_liquid?
         Jekyll.logger.debug "Rendering Liquid:", self.relative_path