jekyll-minibundle 3.0.0 → 4.0.0

data/test/unit/jekyll_static_file_api_test.rb

@@ -1,172 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../support/test_case'
-require_relative '../support/static_file_config'
-require 'jekyll/minibundle/development_file'
-require 'jekyll/minibundle/bundle_file'
-require 'jekyll/minibundle/stamp_file'
-
-module Jekyll::Minibundle::Test
-  class JekyllStaticFileAPITest < TestCase
-    IGNORED_STATIC_FILE_METHODS = %i[cleaned_relative_path].freeze
-
-    include StaticFileConfig
-
-    def test_development_file_has_most_static_file_methods
-      assert_empty(missing_static_file_methods(DevelopmentFile))
-    end
-
-    def test_bundle_file_has_most_static_file_methods
-      assert_empty(missing_static_file_methods(BundleFile))
-    end
-
-    def test_stamp_file_has_most_static_file_methods
-      assert_empty(missing_static_file_methods(StampFile))
-    end
-
-    def test_development_file_properties_has_similar_return_types_to_static_file_properties
-      with_real_site do |site|
-        FileUtils.touch('static.txt')
-        FileUtils.touch('dev.js')
-
-        return_type_diff = diff_non_nil_response_types_of_static_file_properties(
-          make_static_file(site, 'static.txt'),
-          make_development_file(site, 'dev.js')
-        )
-
-        assert_empty(return_type_diff)
-      end
-    end
-
-    def test_bundle_file_properties_has_similar_return_types_to_static_file_properties
-      with_real_site do |site|
-        FileUtils.touch('static.txt')
-        FileUtils.touch('dependency.js')
-        FileUtils.touch('app.js')
-
-        return_type_diff = diff_non_nil_response_types_of_static_file_properties(
-          make_static_file(site, 'static.txt'),
-          make_bundle_file(site, %w[dependency app])
-        )
-
-        assert_empty(return_type_diff)
-      end
-    end
-
-    def test_stamp_file_properties_has_similar_return_types_to_static_file_properties
-      with_real_site do |site|
-        FileUtils.touch('static.txt')
-        FileUtils.touch('stamp.js')
-
-        return_type_diff = diff_non_nil_response_types_of_static_file_properties(
-          make_static_file(site, 'static.txt'),
-          make_stamp_file(site, 'stamp.js')
-        )
-
-        assert_empty(return_type_diff)
-      end
-    end
-
-    def test_development_file_has_same_to_liquid_hash_keys_as_static_file
-      with_real_site do |site|
-        FileUtils.touch('static.txt')
-        FileUtils.touch('dev.js')
-
-        expected_keys = make_static_file(site, 'static.txt').to_liquid.keys.sort
-        actual_keys = make_development_file(site, 'dev.js').to_liquid.keys.sort
-
-        assert_equal(expected_keys, actual_keys)
-      end
-    end
-
-    def test_bundle_file_has_same_to_liquid_hash_keys_as_static_file
-      with_real_site do |site|
-        FileUtils.touch('static.txt')
-        FileUtils.touch('dependency.js')
-        FileUtils.touch('app.js')
-
-        expected_keys = make_static_file(site, 'static.txt').to_liquid.keys.sort
-        actual_keys = make_bundle_file(site, %w[dependency app]).to_liquid.keys.sort
-
-        assert_equal(expected_keys, actual_keys)
-      end
-    end
-
-    def test_stamp_file_has_same_to_liquid_hash_keys_as_static_file
-      with_real_site do |site|
-        FileUtils.touch('static.txt')
-        FileUtils.touch('stamp.js')
-
-        expected_keys = make_static_file(site, 'static.txt').to_liquid.keys.sort
-        actual_keys = make_stamp_file(site, 'stamp.js').to_liquid.keys.sort
-
-        assert_equal(expected_keys, actual_keys)
-      end
-    end
-
-    private
-
-    def missing_static_file_methods(clazz)
-      Jekyll::StaticFile.public_instance_methods - IGNORED_STATIC_FILE_METHODS - clazz.public_instance_methods
-    end
-
-    def response_types_of_methods(file, methods)
-      methods.each_with_object({}) do |method_name, acc|
-        acc[method_name] =
-          begin
-            value = file.send(method_name)
-            {returned_type: value.class}
-          rescue StandardError => e
-            {raised: e}
-          end
-      end
-    end
-
-    def diff_non_nil_response_types_of_static_file_properties(file_master, file_conforming)
-      methods = STATIC_FILE_PROPERTIES - [:to_liquid]
-
-      master_response_types = response_types_of_methods(file_master, methods)
-      conforming_response_types = response_types_of_methods(file_conforming, methods)
-
-      master_to_compare = master_response_types.select do |_, value|
-        value.key?(:returned_type) && value.fetch(:returned_type) != NilClass
-      end
-
-      master_to_compare.to_a - conforming_response_types.to_a
-    end
-
-    def with_real_site(&block)
-      with_site_dir do |dir|
-        block.call(make_real_site(dir))
-      end
-    end
-
-    def make_static_file(site, path)
-      ::Jekyll::StaticFile.new(
-        site,
-        site.source,
-        "/#{File.dirname(path)}",
-        File.basename(path)
-      )
-    end
-
-    def make_development_file(site, filename)
-      DevelopmentFile.new(site, filename, filename)
-    end
-
-    def make_bundle_file(site, assets)
-      BundleFile.new(
-        site,
-        'type'             => :js,
-        'source_dir'       => '',
-        'assets'           => assets,
-        'destination_path' => 'bundle.js',
-        'minifier_cmd'     => 'false'
-      )
-    end
-
-    def make_stamp_file(site, filename)
-      StampFile.new(site, filename, filename)
-    end
-  end
-end

data/test/unit/mini_bundle_block_test.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../support/test_case'
-require_relative '../support/fixture_config'
-require 'jekyll/minibundle/mini_bundle_block'
-
-module Jekyll::Minibundle::Test
-  class MiniBundleBlockTest < TestCase
-    include FixtureConfig
-
-    def setup
-      AssetFileRegistry.clear_all
-    end
-
-    def test_raise_exception_if_no_type_argument
-      err = assert_raises(ArgumentError) do
-        Liquid::Template.parse('{% minibundle %} {% endminibundle %}')
-      end
-      assert_equal("Missing asset type for minibundle block; pass value such as 'css' or 'js' as the argument", err.to_s)
-    end
-
-    def test_raise_exception_if_missing_block_contents
-      err = assert_raises(ArgumentError) do
-        render_template(<<~LIQUID)
-          {% minibundle css %}
-
-          {% endminibundle %}
-        LIQUID
-      end
-      assert_equal('Missing configuration for minibundle block; pass configuration in YAML syntax', err.to_s)
-    end
-
-    def test_raise_exception_if_invalid_block_contents_syntax
-      err = assert_raises(ArgumentError) do
-        render_template(<<~LIQUID)
-          {% minibundle css %}
-          }
-          {% endminibundle %}
-        LIQUID
-      end
-      expected =
-        'Failed parsing minibundle block contents syntax as YAML: "}". ' \
-        'Cause: (<unknown>): did not find expected node content while parsing a block node at line 2 column 1'
-      assert_equal(expected, err.to_s)
-    end
-
-    def test_raise_exception_if_unsupported_block_contents_type
-      err = assert_raises(ArgumentError) do
-        render_template(<<~LIQUID)
-          {% minibundle css %}
-          str
-          {% endminibundle %}
-        LIQUID
-      end
-      assert_equal("Unsupported minibundle block contents type (String), only Hash is supported: \nstr\n", err.to_s)
-    end
-
-    [
-      {
-        description:        'nil_baseurl_results_in_asset_url_without_baseurl',
-        baseurl_config:     'baseurl:',
-        expected_asset_url: CSS_BUNDLE_DESTINATION_FINGERPRINT_PATH
-      },
-      {
-        description:        'empty_baseurl_results_in_asset_url_without_baseurl',
-        baseurl_config:     "baseurl: ''",
-        expected_asset_url: CSS_BUNDLE_DESTINATION_FINGERPRINT_PATH
-      },
-      {
-        description:        'slash_baseurl_results_in_asset_url_with_baseurl',
-        baseurl_config:     'baseurl: /',
-        expected_asset_url: "/#{CSS_BUNDLE_DESTINATION_FINGERPRINT_PATH}"
-      },
-      {
-        description:        'dot_baseurl_results_in_asset_url_without_baseurl',
-        baseurl_config:     'baseurl: .',
-        expected_asset_url: CSS_BUNDLE_DESTINATION_FINGERPRINT_PATH
-      },
-      {
-        description:        'dot_slash_baseurl_results_in_asset_url_without_baseurl',
-        baseurl_config:     'baseurl: ./',
-        expected_asset_url: CSS_BUNDLE_DESTINATION_FINGERPRINT_PATH
-      },
-      {
-        description:        'slash_root_baseurl_results_in_asset_url_with_baseurl',
-        baseurl_config:     'baseurl: /root',
-        expected_asset_url: "/root/#{CSS_BUNDLE_DESTINATION_FINGERPRINT_PATH}"
-      },
-      {
-        description:        'slash_root_slash_baseurl_results_in_asset_url_with_baseurl',
-        baseurl_config:     'baseurl: /root/',
-        expected_asset_url: "/root/#{CSS_BUNDLE_DESTINATION_FINGERPRINT_PATH}"
-      }
-    ].each do |spec|
-      define_method :"test_normalizing_baseurl_with_#{spec.fetch(:description)}" do
-        actual_output = render_template(<<~LIQUID)
-          {% minibundle css %}
-          source_dir: _assets/styles
-          destination_path: assets/site
-          #{spec.fetch(:baseurl_config)}
-          assets:
-            - reset
-            - common
-          minifier_cmd: #{minifier_cmd_to_remove_comments}
-          {% endminibundle %}
-        LIQUID
-
-        expected_output = %(<link rel="stylesheet" href="#{spec.fetch(:expected_asset_url)}">\n)
-
-        assert_equal(expected_output, actual_output)
-      end
-    end
-
-    private
-
-    def render_template(template)
-      compiled = Liquid::Template.parse(template)
-      rendered = nil
-      capture_io do
-        rendered = compiled.render!({}, registers: {site: make_fake_site(site_fixture_path)})
-      end
-      rendered
-    end
-  end
-end

data/test/unit/mini_stamp_tag_test.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../support/test_case'
-require_relative '../support/fixture_config'
-require 'jekyll/minibundle/mini_stamp_tag'
-
-module Jekyll::Minibundle::Test
-  class MiniStampTagTest < TestCase
-    include FixtureConfig
-
-    def test_raise_exception_if_argument_is_missing
-      err = assert_raises(ArgumentError) do
-        Liquid::Template.parse('{% ministamp %}')
-      end
-      assert_equal('Missing asset source and destination paths for ministamp tag; specify value such as "_assets/source.css assets/destination.css" as the argument', err.to_s)
-    end
-
-    def test_raise_exception_if_asset_destination_is_missing_in_string_argument_type
-      err = assert_raises(ArgumentError) do
-        Liquid::Template.parse('{% ministamp /_assets/site.css %}')
-      end
-      assert_equal('Missing asset destination path for ministamp tag; specify value such as "assets/destination.css" after asset source path argument, separated with a space', err.to_s)
-    end
-
-    def test_ignores_arguments_after_asset_destination_in_string_argument_type
-      AssetFileRegistry.clear_all
-      output = Liquid::Template
-               .parse("{% ministamp #{STAMP_SOURCE_PATH} #{STAMP_DESTINATION_PATH} rest %}")
-               .render({}, registers: {site: make_fake_site(site_fixture_path)})
-      assert_equal(STAMP_DESTINATION_FINGERPRINT_PATH, output)
-    end
-
-    def test_raise_exception_if_invalid_arguments_syntax
-      err = assert_raises(ArgumentError) do
-        Liquid::Template.parse('{% ministamp source_path: src, destination_path: dst %}')
-      end
-      expected =
-        'Failed parsing ministamp tag argument syntax as YAML: "source_path: src, destination_path: dst". ' \
-        'Cause: (<unknown>): mapping values are not allowed in this context at line 1 column 35'
-      assert_equal(expected, err.to_s)
-    end
-
-    def test_raise_exception_if_unsupported_argument_type
-      err = assert_raises(ArgumentError) do
-        Liquid::Template.parse("{% ministamp ['source_path', 'src', 'destination_path', 'dst'] %}")
-      end
-      assert_equal("Unsupported ministamp tag argument type (Array), only String and Hash are supported: ['source_path', 'src', 'destination_path', 'dst']", err.to_s)
-    end
-
-    def test_raise_exception_if_asset_source_is_missing_in_hash_argument_type
-      err = assert_raises(ArgumentError) do
-        Liquid::Template.parse('{% ministamp {} %}')
-      end
-      assert_equal('Missing asset source path for ministamp tag; specify Hash entry such as "source_path: _assets/site.css"', err.to_s)
-    end
-
-    def test_raise_exception_if_asset_destination_is_missing_in_hash_argument_type
-      err = assert_raises(ArgumentError) do
-        Liquid::Template.parse('{% ministamp { source_path: src } %}')
-      end
-      assert_equal('Missing asset destination path for ministamp tag; specify Hash entry such as "destination_path: assets/site.css"', err.to_s)
-    end
-  end
-end

data/test/unit/stamp_file_properties_test.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../support/test_case'
-require_relative '../support/fixture_config'
-require_relative '../support/static_file_config'
-require 'jekyll/minibundle/stamp_file'
-
-module Jekyll::Minibundle::Test
-  class StampFilePropertiesTest < TestCase
-    include FixtureConfig
-    include StaticFileConfig
-
-    def setup
-      @@results ||= with_stamp_file do |file|
-        get_send_results(file, STATIC_FILE_PROPERTIES)
-      end
-    end
-
-    def test_basename
-      assert_equal("screen-#{STAMP_FINGERPRINT}", @@results.fetch(:basename))
-    end
-
-    def test_data
-      assert_equal({}, @@results.fetch(:data))
-    end
-
-    def test_defaults
-      assert_equal({}, @@results.fetch(:defaults))
-    end
-
-    def test_destination_rel_dir
-      assert_equal('/assets', @@results.fetch(:destination_rel_dir))
-    end
-
-    def test_extname
-      assert_equal('.css', @@results.fetch(:extname))
-    end
-
-    def test_modified_time
-      assert_instance_of(Time, @@results.fetch(:modified_time))
-    end
-
-    def test_mtime
-      mtime = @@results.fetch(:modified_time)
-      assert_equal(mtime.to_i, @@results.fetch(:mtime))
-    end
-
-    def test_name
-      assert_equal("screen-#{STAMP_FINGERPRINT}.css", @@results.fetch(:name))
-    end
-
-    def test_path
-      assert_match(%r{\A/.+/#{STAMP_SOURCE_PATH}\z}, @@results.fetch(:path))
-    end
-
-    def test_placeholders
-      assert_equal({}, @@results.fetch(:placeholders))
-    end
-
-    def test_relative_path
-      assert_equal("/#{STAMP_SOURCE_PATH}", @@results.fetch(:relative_path))
-    end
-
-    def test_to_liquid
-      with_stamp_file do |file|
-        drop = file.to_liquid
-        assert_equal("screen-#{STAMP_FINGERPRINT}.css", drop.name)
-        assert_equal('.css', drop.extname)
-        assert_equal("screen-#{STAMP_FINGERPRINT}", drop.basename)
-        assert_instance_of(Time, drop.modified_time)
-        assert_equal("/#{STAMP_SOURCE_PATH}", drop.path)
-        assert_nil(drop.collection)
-      end
-    end
-
-    def test_type
-      assert_nil(@@results.fetch(:type))
-    end
-
-    def test_url
-      assert_equal(STAMP_DESTINATION_FINGERPRINT_PATH, @@results.fetch(:url))
-    end
-
-    def test_write?
-      assert(@@results.fetch(:write?))
-    end
-
-    private
-
-    def with_stamp_file(&block)
-      with_fake_site do |site|
-        file = StampFile.new(site, STAMP_SOURCE_PATH, STAMP_DESTINATION_PATH)
-        file.destination_path_for_markup
-        block.call(file)
-      end
-    end
-  end
-end

data/test/unit/stamp_file_writing_test.rb

@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../support/test_case'
-require_relative '../support/fixture_config'
-require 'jekyll/minibundle/stamp_file'
-
-module Jekyll::Minibundle::Test
-  class StampFileWritingTest < TestCase
-    include FixtureConfig
-
-    def test_raise_error_if_source_file_does_not_exist
-      err = assert_raises(ArgumentError) do
-        with_fake_site do |site|
-          StampFile.new(site, '_tmp', STAMP_DESTINATION_PATH)
-        end
-      end
-      assert_match(%r{\AStamp source file does not exist: .+/_tmp\z}, err.to_s)
-    end
-
-    def test_calling_destination_path_for_markup_determines_fingerprint_and_destination_write
-      with_fake_site do |site|
-        stamp_file = make_stamp_file(site)
-        source = source_path(STAMP_SOURCE_PATH)
-        old_destination = destination_path(STAMP_DESTINATION_FINGERPRINT_PATH)
-
-        # the call to destination_path_for_markup determines the
-        # fingerprint
-
-        org_markup_path = stamp_file.destination_path_for_markup
-
-        assert(write_file(stamp_file))
-
-        org_mtime = file_mtime_of(old_destination)
-
-        last_markup_path = stamp_file.destination_path_for_markup
-
-        assert_equal(org_markup_path, last_markup_path)
-
-        # change content, but don't call destination_path_for_markup yet
-
-        ensure_file_mtime_changes { File.write(source, 'h1 {}') }
-
-        # preserve content's fingerprint
-
-        refute(write_file(stamp_file))
-
-        assert_equal(org_markup_path, last_markup_path)
-        assert_equal(org_mtime, file_mtime_of(old_destination))
-        assert_equal(File.read(site_fixture_path(STAMP_SOURCE_PATH)), File.read(old_destination))
-
-        # see content's fingerprint to update after calling
-        # destination_path_for_markup
-
-        last_markup_path = stamp_file.destination_path_for_markup
-
-        refute_equal org_markup_path, last_markup_path
-
-        assert(write_file(stamp_file))
-
-        new_destination = destination_path('assets/screen-0f5dbd1e527a2bee267e85007b08d2a5.css')
-
-        assert_operator(file_mtime_of(new_destination), :>, org_mtime)
-        assert_equal(File.read(source), File.read(new_destination))
-      end
-    end
-
-    def test_many_consecutive_destination_path_for_markup_calls_trigger_one_destination_write
-      with_fake_site do |site|
-        stamp_file = make_stamp_file(site)
-        source = source_path(STAMP_SOURCE_PATH)
-        destination = destination_path(STAMP_DESTINATION_FINGERPRINT_PATH)
-        org_markup = stamp_file.destination_path_for_markup
-        stamp_file.destination_path_for_markup
-
-        assert(write_file(stamp_file))
-
-        org_mtime = file_mtime_of(destination)
-        ensure_file_mtime_changes { FileUtils.touch(source) }
-        last_markup = stamp_file.destination_path_for_markup
-        stamp_file.destination_path_for_markup
-
-        assert(write_file(stamp_file))
-        assert_equal(org_markup, last_markup)
-        assert_operator(file_mtime_of(destination), :>, org_mtime)
-        assert_equal(File.read(source), File.read(destination))
-      end
-    end
-
-    def test_calling_write_before_destination_path_for_markup_has_no_effect
-      with_fake_site do |site|
-        stamp_file = make_stamp_file(site)
-
-        refute(write_file(stamp_file))
-        assert_empty(Dir[destination_path('assets/*.css')])
-
-        stamp_file.destination_path_for_markup
-
-        assert(write_file(stamp_file))
-        assert(File.file?(destination_path(STAMP_DESTINATION_FINGERPRINT_PATH)))
-      end
-    end
-
-    def test_modified_property_determines_if_write_would_succeed
-      with_fake_site do |site|
-        stamp_file = make_stamp_file(site)
-
-        refute(stamp_file.modified?)
-        refute(write_file(stamp_file))
-
-        stamp_file.destination_path_for_markup
-
-        assert(stamp_file.modified?)
-        assert(write_file(stamp_file))
-
-        refute(stamp_file.modified?)
-        refute(write_file(stamp_file))
-      end
-    end
-
-    private
-
-    def make_stamp_file(site)
-      StampFile.new(site, STAMP_SOURCE_PATH, STAMP_DESTINATION_PATH)
-    end
-
-    def write_file(file)
-      file.write(File.join(Dir.pwd, '_site'))
-    end
-  end
-end