jekyll 2.2.0 → 2.3.0

data/test/test_command.rb

@@ -1,53 +0,0 @@
-require 'helper'
-
-class TestCommand < Test::Unit::TestCase
-  context "when calling .ignore_paths" do
-    context "when source is absolute" do
-      setup { @source = source_dir }
-      should "return an array with regex for destination" do
-        absolute = source_dir('dest')
-        relative = Pathname.new(source_dir('dest')).relative_path_from(Pathname.new('.').expand_path).to_s
-        [absolute, relative].each do |dest|
-          config = build_configs("source" => @source, "destination" => dest)
-          assert Command.ignore_paths(config).include?(/dest/), "failed with destination: #{dest}"
-        end
-      end
-    end
-    context "when source is relative" do
-      setup { @source = Pathname.new(source_dir).relative_path_from(Pathname.new('.').expand_path).to_s }
-      should "return an array with regex for destination" do
-        absolute = source_dir('dest')
-        relative = Pathname.new(source_dir('dest')).relative_path_from(Pathname.new('.').expand_path).to_s
-        [absolute, relative].each do |dest|
-          config = build_configs("source" => @source, "destination" => dest)
-          assert Command.ignore_paths(config).include?(/dest/), "failed with destination: #{dest}"
-        end
-      end
-    end
-    context "multiple config files" do
-      should "return an array with regex for config files" do
-        config = build_configs("config"=> ["_config.yaml", "_config2.yml"])
-        ignore_paths = Command.ignore_paths(config)
-        assert ignore_paths.include?(/_config\.yaml/), 'did not include _config.yaml'
-        assert ignore_paths.include?(/_config2\.yml/), 'did not include _config2.yml'
-      end
-    end
-  end
-  context "when calling .add_build_options" do
-    should "add common options" do
-      cmd = Object.new
-      mock(cmd).option.with_any_args.at_least(1)
-      Command.add_build_options(cmd)
-    end
-  end
-  context "when calling .process_site" do
-    context "when fatal error occurs" do
-      should "exit with non-zero error code" do
-        site = Object.new
-        stub(site).process { raise Jekyll::Errors::FatalException }
-        error = assert_raise(SystemExit) { Command.process_site(site) }
-        assert_not_equal 0, error.status
-      end
-    end
-  end
-end

data/test/test_configuration.rb

@@ -1,201 +0,0 @@
-require 'helper'
-
-class TestConfiguration < Test::Unit::TestCase
-  context "#stringify_keys" do
-    setup do
-      @mixed_keys = Configuration[{
-        'markdown' => 'kramdown',
-        :permalink => 'date',
-        'baseurl'  => '/',
-        :include   => ['.htaccess'],
-        :source    => './'
-      }]
-      @string_keys = Configuration[{
-        'markdown'  => 'kramdown',
-        'permalink' => 'date',
-        'baseurl'   => '/',
-        'include'   => ['.htaccess'],
-        'source'    => './'
-      }]
-    end
-    should "stringify symbol keys" do
-      assert_equal @string_keys, @mixed_keys.stringify_keys
-    end
-    should "not mess with keys already strings" do
-      assert_equal @string_keys, @string_keys.stringify_keys
-    end
-  end
-  context "#config_files" do
-    setup do
-      @config = Configuration[{"source" => source_dir}]
-      @no_override     = {}
-      @one_config_file = {"config" => "config.yml"}
-      @multiple_files  = {"config" => %w[config/site.yml config/deploy.toml configuration.yml]}
-    end
-
-    should "always return an array" do
-      assert @config.config_files(@no_override).is_a?(Array)
-      assert @config.config_files(@one_config_file).is_a?(Array)
-      assert @config.config_files(@multiple_files).is_a?(Array)
-    end
-    should "return the default config path if no config files are specified" do
-      assert_equal [source_dir("_config.yml")], @config.config_files(@no_override)
-    end
-    should "return .yaml if it exists but .yml does not" do
-      mock(File).exists?(source_dir("_config.yml")) { false }
-      mock(File).exists?(source_dir("_config.yaml")) { true }
-      assert_equal [source_dir("_config.yaml")], @config.config_files(@no_override)
-    end
-    should "return .yml if both .yml and .yaml exist" do
-      mock(File).exists?(source_dir("_config.yml")) { true }
-      assert_equal [source_dir("_config.yml")], @config.config_files(@no_override)
-    end
-    should "return the config if given one config file" do
-      assert_equal %w[config.yml], @config.config_files(@one_config_file)
-    end
-    should "return an array of the config files if given many config files" do
-      assert_equal %w[config/site.yml config/deploy.toml configuration.yml], @config.config_files(@multiple_files)
-    end
-  end
-  context "#backwards_compatibilize" do
-    setup do
-      @config = Configuration[{
-        "auto"     => true,
-        "watch"    => true,
-        "server"   => true,
-        "exclude"  => "READ-ME.md, Gemfile,CONTRIBUTING.hello.markdown",
-        "include"  => "STOP_THE_PRESSES.txt,.heloses, .git",
-        "pygments" => true,
-      }]
-    end
-    should "unset 'auto' and 'watch'" do
-      assert @config.has_key?("auto")
-      assert @config.has_key?("watch")
-      assert !@config.backwards_compatibilize.has_key?("auto")
-      assert !@config.backwards_compatibilize.has_key?("watch")
-    end
-    should "unset 'server'" do
-      assert @config.has_key?("server")
-      assert !@config.backwards_compatibilize.has_key?("server")
-    end
-    should "transform string exclude into an array" do
-      assert @config.has_key?("exclude")
-      assert @config.backwards_compatibilize.has_key?("exclude")
-      assert_equal @config.backwards_compatibilize["exclude"], %w[READ-ME.md Gemfile CONTRIBUTING.hello.markdown]
-    end
-    should "transform string include into an array" do
-      assert @config.has_key?("include")
-      assert @config.backwards_compatibilize.has_key?("include")
-      assert_equal @config.backwards_compatibilize["include"], %w[STOP_THE_PRESSES.txt .heloses .git]
-    end
-    should "set highlighter to pygments" do
-      assert @config.has_key?("pygments")
-      assert !@config.backwards_compatibilize.has_key?("pygments")
-      assert_equal @config.backwards_compatibilize["highlighter"], "pygments"
-    end
-  end
-  context "#fix_common_issues" do
-    setup do
-      @config = Proc.new do |val|
-        Configuration[{
-          'paginate' => val
-        }]
-      end
-    end
-    should "sets an invalid 'paginate' value to nil" do
-      assert_nil @config.call(0).fix_common_issues['paginate']
-      assert_nil @config.call(-1).fix_common_issues['paginate']
-      assert_nil @config.call(true).fix_common_issues['paginate']
-    end
-  end
-  context "loading configuration" do
-    setup do
-      @path = File.join(Dir.pwd, '_config.yml')
-      @user_config = File.join(Dir.pwd, "my_config_file.yml")
-    end
-
-    should "fire warning with no _config.yml" do
-      mock(SafeYAML).load_file(@path) { raise SystemCallError, "No such file or directory - #{@path}" }
-      mock($stderr).puts("Configuration file: none".yellow)
-      assert_equal Jekyll::Configuration::DEFAULTS, Jekyll.configuration({})
-    end
-
-    should "load configuration as hash" do
-      mock(SafeYAML).load_file(@path) { Hash.new }
-      mock($stdout).puts("Configuration file: #{@path}")
-      assert_equal Jekyll::Configuration::DEFAULTS, Jekyll.configuration({})
-    end
-
-    should "fire warning with bad config" do
-      mock(SafeYAML).load_file(@path) { Array.new }
-      mock($stderr).puts(("WARNING: ".rjust(20) + "Error reading configuration. Using defaults (and options).").yellow)
-      mock($stderr).puts("Configuration file: (INVALID) #{@path}".yellow)
-      assert_equal Jekyll::Configuration::DEFAULTS, Jekyll.configuration({})
-    end
-
-    should "fire warning when user-specified config file isn't there" do
-      mock(SafeYAML).load_file(@user_config) { raise SystemCallError, "No such file or directory - #{@user_config}" }
-      mock($stderr).puts(("Fatal: ".rjust(20) + "The configuration file '#{@user_config}' could not be found.").red)
-      assert_raises LoadError do
-        Jekyll.configuration({'config' => [@user_config]})
-      end
-    end
-
-    should "not clobber YAML.load to the dismay of other libraries" do
-      assert_equal :foo, YAML.load(':foo')
-      # as opposed to: assert_equal ':foo', SafeYAML.load(':foo')
-    end
-  end
-  context "loading config from external file" do
-    setup do
-      @paths = {
-        :default => File.join(Dir.pwd, '_config.yml'),
-        :other   => File.join(Dir.pwd, '_config.live.yml'),
-        :toml    => source_dir('_config.dev.toml'),
-        :empty   => ""
-      }
-    end
-
-    should "load default config if no config_file is set" do
-      mock(SafeYAML).load_file(@paths[:default]) { Hash.new }
-      mock($stdout).puts("Configuration file: #{@paths[:default]}")
-      assert_equal Jekyll::Configuration::DEFAULTS, Jekyll.configuration({})
-    end
-
-    should "load different config if specified" do
-      mock(SafeYAML).load_file(@paths[:other]) { {"baseurl" => "http://wahoo.dev"} }
-      mock($stdout).puts("Configuration file: #{@paths[:other]}")
-      assert_equal Utils.deep_merge_hashes(Jekyll::Configuration::DEFAULTS, { "baseurl" => "http://wahoo.dev" }), Jekyll.configuration({ "config" => @paths[:other] })
-    end
-
-    should "load default config if path passed is empty" do
-      mock(SafeYAML).load_file(@paths[:default]) { Hash.new }
-      mock($stdout).puts("Configuration file: #{@paths[:default]}")
-      assert_equal Jekyll::Configuration::DEFAULTS, Jekyll.configuration({ "config" => @paths[:empty] })
-    end
-
-    should "successfully load a TOML file" do
-      Jekyll.logger.log_level = :warn
-      assert_equal Jekyll::Configuration::DEFAULTS.merge({ "baseurl" => "/you-beautiful-blog-you", "title" => "My magnificent site, wut" }), Jekyll.configuration({ "config" => [@paths[:toml]] })
-      Jekyll.logger.log_level = :info
-    end
-
-    should "load multiple config files" do
-      mock(SafeYAML).load_file(@paths[:default]) { Hash.new }
-      mock(SafeYAML).load_file(@paths[:other]) { Hash.new }
-      mock(TOML).load_file(@paths[:toml]) { Hash.new }
-      mock($stdout).puts("Configuration file: #{@paths[:default]}")
-      mock($stdout).puts("Configuration file: #{@paths[:other]}")
-      mock($stdout).puts("Configuration file: #{@paths[:toml]}")
-      assert_equal Jekyll::Configuration::DEFAULTS, Jekyll.configuration({ "config" => [@paths[:default], @paths[:other], @paths[:toml]] })
-    end
-
-    should "load multiple config files and last config should win" do
-      mock(SafeYAML).load_file(@paths[:default]) { {"baseurl" => "http://example.dev"} }
-      mock(SafeYAML).load_file(@paths[:other]) { {"baseurl" => "http://wahoo.dev"} }
-      mock($stdout).puts("Configuration file: #{@paths[:default]}")
-      mock($stdout).puts("Configuration file: #{@paths[:other]}")
-      assert_equal Utils.deep_merge_hashes(Jekyll::Configuration::DEFAULTS, { "baseurl" => "http://wahoo.dev" }), Jekyll.configuration({ "config" => [@paths[:default], @paths[:other]] })
-    end
-  end
-end

data/test/test_convertible.rb

@@ -1,49 +0,0 @@
-require 'helper'
-require 'ostruct'
-
-class TestConvertible < Test::Unit::TestCase
-  context "yaml front-matter" do
-    setup do
-      @convertible = OpenStruct.new
-      @convertible.extend Jekyll::Convertible
-      @base = File.expand_path('../fixtures', __FILE__)
-    end
-
-    should "parse the front-matter correctly" do
-      ret = @convertible.read_yaml(@base, 'front_matter.erb')
-      assert_equal({'test' => 'good'}, ret)
-    end
-
-    should "not parse if the front-matter is not at the start of the file" do
-      ret = @convertible.read_yaml(@base, 'broken_front_matter1.erb')
-      assert_equal({}, ret)
-    end
-
-    should "not parse if there is syntax error in front-matter" do
-      name = 'broken_front_matter2.erb'
-      out = capture_stderr do
-        ret = @convertible.read_yaml(@base, name)
-        assert_equal({}, ret)
-      end
-      assert_match(/YAML Exception|syntax error|Error reading file/, out)
-      assert_match(/#{File.join(@base, name)}/, out)
-    end
-
-    should "not allow ruby objects in yaml" do
-      out = capture_stderr do
-        @convertible.read_yaml(@base, 'exploit_front_matter.erb')
-      end
-      assert_no_match /undefined class\/module DoesNotExist/, out
-    end
-
-    should "not parse if there is encoding error in file" do
-      name = 'broken_front_matter3.erb'
-      out = capture_stderr do
-        ret = @convertible.read_yaml(@base, name, :encoding => 'utf-8')
-        assert_equal({}, ret)
-      end
-      assert_match(/invalid byte sequence in UTF-8/, out)
-      assert_match(/#{File.join(@base, name)}/, out)
-    end
-  end
-end

data/test/test_document.rb

@@ -1,193 +0,0 @@
-require 'helper'
-
-class TestDocument < Test::Unit::TestCase
-
-  context "a document in a collection" do
-    setup do
-      @site = Site.new(Jekyll.configuration({
-        "collections" => ["methods"],
-        "source"      => source_dir,
-        "destination" => dest_dir
-      }))
-      @site.process
-      @document = @site.collections["methods"].docs.first
-    end
-
-    should "know its relative path" do
-      assert_equal "_methods/configuration.md", @document.relative_path
-    end
-
-    should "knows its extname" do
-      assert_equal ".md", @document.extname
-    end
-
-    should "know its basename" do
-      assert_equal "configuration.md", @document.basename
-    end
-
-    should "allow the suffix to be specified for the basename" do
-      assert_equal "configuration", @document.basename(".*")
-    end
-
-    should "know whether its a yaml file" do
-      assert_equal false, @document.yaml_file?
-    end
-
-    should "know its data" do
-      assert_equal({
-        "title" => "Jekyll.configuration",
-        "whatever" => "foo.bar"
-      }, @document.data)
-    end
-
-    should "output the collection name in the #to_liquid method" do
-      assert_equal @document.to_liquid['collection'], "methods"
-    end
-
-  end
-
-  context "a document as part of a collection with frontmatter defaults" do
-    setup do
-      @site = Site.new(Jekyll.configuration({
-        "collections" => ["slides"],
-        "source"      => source_dir,
-        "destination" => dest_dir,
-        "defaults" => [{
-          "scope"=> {"path"=>"", "type"=>"slides"},
-          "values"=> {
-            "nested"=> {
-              "key"=>"myval",
-            }
-          }
-        }]
-      }))
-      @site.process
-      @document = @site.collections["slides"].docs.first
-    end
-
-    should "know the frontmatter defaults" do
-      assert_equal({
-        "title"=>"Example slide",
-        "layout"=>"slide",
-        "nested"=> { 
-          "key"=>"myval"
-        }
-      }, @document.data)
-    end
-  end
-
-  context "a document as part of a collection with overriden default values" do
-    setup do
-      @site = Site.new(Jekyll.configuration({
-        "collections" => ["slides"],
-        "source"      => source_dir,
-        "destination" => dest_dir,
-        "defaults" => [{
-          "scope"=> {"path"=>"", "type"=>"slides"},
-          "values"=> {
-            "nested"=> {
-              "test1"=>"default1",
-              "test2"=>"default1"
-            }
-          }
-        }]
-      }))
-      @site.process
-      @document = @site.collections["slides"].docs[1]
-    end
-
-    should "override default values in the document frontmatter" do
-      assert_equal({
-        "title"=>"Override title",
-        "layout"=>"slide",
-        "nested"=> { 
-          "test1"=>"override1",
-          "test2"=>"override2"
-        }
-      }, @document.data)
-    end
-  end
-
-  context "a document as part of a collection with valid path" do
-    setup do
-      @site = Site.new(Jekyll.configuration({
-        "collections" => ["slides"],
-        "source"      => source_dir,
-        "destination" => dest_dir,
-        "defaults" => [{
-          "scope"=> {"path"=>"slides", "type"=>"slides"},
-          "values"=> {
-            "nested"=> {
-              "key"=>"value123",
-            }
-          }
-        }]
-      }))
-      @site.process
-      @document = @site.collections["slides"].docs.first
-    end
-
-    should "know the frontmatter defaults" do
-      assert_equal({
-        "title"=>"Example slide",
-        "layout"=>"slide",
-        "nested"=> { 
-          "key"=>"value123"
-        }
-      }, @document.data)
-    end
-  end
-
-  context "a document as part of a collection with invalid path" do
-    setup do
-      @site = Site.new(Jekyll.configuration({
-        "collections" => ["slides"],
-        "source"      => source_dir,
-        "destination" => dest_dir,
-        "defaults" => [{
-          "scope"=> {"path"=>"somepath", "type"=>"slides"},
-          "values"=> {
-            "nested"=> {
-              "key"=>"myval",
-            }
-          }
-        }]
-      }))
-      @site.process
-      @document = @site.collections["slides"].docs.first
-    end
-
-    should "not know the specified frontmatter defaults" do
-      assert_equal({
-        "title"=>"Example slide",
-        "layout"=>"slide"
-      }, @document.data)
-    end
-  end
-
-  context "a document in a collection with a custom permalink" do
-    setup do
-      @site = Site.new(Jekyll.configuration({
-        "collections" => ["slides"],
-        "source"      => source_dir,
-        "destination" => dest_dir
-      }))
-      @site.process
-      @document = @site.collections["slides"].docs[2]
-      @dest_file = dest_dir("slide/3/index.html")
-    end
-
-    should "know its permalink" do
-      assert_equal "/slide/3/", @document.permalink
-    end
-
-    should "produce the right URL" do
-      assert_equal "/slide/3/", @document.url
-    end
-  end
-
-
-  context " a document part of a rendered collection" do
-  end
-
-end