jekyll-minibundle 3.0.0 → 4.0.0

data/test/support/static_file_config.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Jekyll::Minibundle::Test
-  module StaticFileConfig
-    STATIC_FILE_PROPERTIES = %i[
-      basename
-      data
-      defaults
-      destination_rel_dir
-      extname
-      modified_time
-      mtime
-      name
-      path
-      placeholders
-      relative_path
-      to_liquid
-      type
-      url
-      write?
-    ].freeze
-  end
-end

data/test/support/test_case.rb

@@ -1,175 +0,0 @@
-# frozen_string_literal: true
-
-require 'fileutils'
-require 'ostruct'
-require 'tempfile'
-require 'nokogiri'
-require 'jekyll'
-require 'jekyll/minibundle'
-require 'minitest/autorun'
-require_relative 'assertions'
-
-module Jekyll::Minibundle::Test
-  class TestCase < ::Minitest::Test
-    include Assertions
-    include ::Jekyll::Minibundle
-
-    FIXTURE_DIR = File.expand_path(File.join(File.dirname(__FILE__), '../fixture'))
-
-    def site_fixture_path(*args)
-      File.join(FIXTURE_DIR, 'site', *args)
-    end
-
-    def source_path(*args)
-      File.join(Dir.pwd, *args)
-    end
-
-    def destination_path(*args)
-      File.join(Dir.pwd, '_site', *args)
-    end
-
-    def find_html_element(file, css)
-      Nokogiri::HTML(file).css(css)
-    end
-
-    def find_and_gsub_in_file(file, pattern, replacement)
-      old_content = File.read(file)
-      new_content = old_content.gsub(pattern, replacement)
-      File.write(file, new_content)
-    end
-
-    def merge_to_yaml_file(file, hash)
-      IO.write(file, YAML.load_file(file).merge(hash).to_yaml)
-    end
-
-    def file_mtime_of(path)
-      File.stat(path).mtime
-    end
-
-    def file_permissions_of(path)
-      File.stat(path).mode & 0o777
-    end
-
-    def with_env(env)
-      org_env = {}
-      env.each do |k, v|
-        org_env[k] = ENV[k]
-        ENV[k] = v
-      end
-      yield
-    ensure
-      org_env.each { |k, v| ENV[k] = v }
-    end
-
-    def with_umask(cmask)
-      org_cmask = File.umask
-      File.umask(cmask)
-      yield
-    ensure
-      File.umask(org_cmask)
-    end
-
-    def with_tmp_dir(&block)
-      Dir.mktmpdir('jekyll-minibundle-test-site-') do |dir|
-        Dir.chdir(dir, &block)
-      end
-    end
-
-    def with_site_dir(&block)
-      with_tmp_dir do |dir|
-        _copy_fixture_site_dir(dir)
-        block.call(dir)
-      end
-    end
-
-    def make_fake_site(dir)
-      OpenStruct.new(source: dir, static_files: [])
-    end
-
-    def make_real_site(dir = Dir.pwd)
-      config = nil
-      capture_io do
-        config = Jekyll.configuration('source' => dir, 'destination' => '_site')
-      end
-      Jekyll::Site.new(config)
-    end
-
-    def with_fake_site(&block)
-      with_site_dir do |dir|
-        block.call(make_fake_site(dir))
-      end
-    end
-
-    def with_precompiled_site(mode, &block)
-      Dir.chdir(_get_precompiled_site(mode), &block)
-    end
-
-    def generate_site(mode, options = {})
-      env = {
-        'JEKYLL_MINIBUNDLE_MODE'    => mode&.to_s,
-        'JEKYLL_MINIBUNDLE_CMD_CSS' => options.fetch(:minifier_cmd_css, minifier_cmd_to_remove_comments),
-        'JEKYLL_MINIBUNDLE_CMD_JS'  => options.fetch(:minifier_cmd_js, minifier_cmd_to_remove_comments)
-      }
-      with_env(env) { _generate_site(options) }
-    end
-
-    def ensure_file_mtime_changes(&block)
-      sleep 1.5
-      block.call
-    end
-
-    def minifier_cmd_to_remove_comments
-      site_fixture_path('_bin/remove_comments')
-    end
-
-    def minifier_cmd_to_remove_comments_and_count(count_file = 'minifier_cmd_count')
-      "#{site_fixture_path('_bin/with_count')} #{count_file} _bin/remove_comments"
-    end
-
-    def get_minifier_cmd_count(count_file = 'minifier_cmd_count')
-      if File.file?(count_file)
-        File.read(count_file).to_i
-      else
-        0
-      end
-    end
-
-    def get_send_results(obj, method_names)
-      method_names.each_with_object({}) do |method_name, acc|
-        acc[method_name] = obj.send(method_name)
-      end
-    end
-
-    private
-
-    def _copy_fixture_site_dir(dir)
-      FileUtils.cp_r(site_fixture_path('.'), dir)
-    end
-
-    @@_precompiled_site_dirs = {}
-
-    def _get_precompiled_site(mode)
-      @@_precompiled_site_dirs[mode] ||= begin
-        dir = Dir.mktmpdir("jekyll-minibundle-test-precompiled-site-#{mode}-")
-        at_exit do
-          FileUtils.rm_rf(dir)
-          puts "\nCleaned precompiled site in #{mode} mode for tests: #{dir}"
-        end
-        Dir.chdir(dir) do
-          _copy_fixture_site_dir(Dir.pwd)
-          generate_site(mode)
-        end
-        dir
-      end
-    end
-
-    def _generate_site(test_options)
-      if test_options.fetch(:clear_cache, true)
-        AssetFileRegistry.clear_all
-        VariableTemplateRegistry.clear
-      end
-      site = make_real_site
-      capture_io { site.process }
-    end
-  end
-end

data/test/unit/asset_bundle_test.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../support/test_case'
-require 'jekyll/minibundle/asset_bundle'
-
-module Jekyll::Minibundle::Test
-  class AssetBundleTest < TestCase
-    def test_raise_exception_if_bundle_command_fails
-      capture_io do
-        err = assert_raises(RuntimeError) { make_bundle('read _ignore ; false') }
-        assert_equal('Bundling "assets/site.js" failed with exit status 1, command: "read _ignore ; false"', err.to_s)
-      end
-    end
-
-    def test_log_minifier_stdout_if_bundle_command_fails
-      cmd = 'ruby -E ISO-8859-15 -e \'gets; puts "line 1\a\nline\t2\xa4"; abort\''
-      _, actual_stderr = capture_io do
-        assert_raises(RuntimeError) { make_bundle(cmd) }
-      end
-      expected_stderr = <<~MESSAGE
-        Minibundle: Bundling "assets/site.js" failed with exit status 1, command: #{cmd.inspect}, last 16 bytes of minifier output:
-        Minibundle: line 1\\x07
-        Minibundle: line 2\\xa4
-      MESSAGE
-      assert_equal(expected_stderr, actual_stderr.gsub(/\e\[\d+m/, '').gsub(/^ +/, ''))
-    end
-
-    def test_raise_exception_if_bundle_command_not_found
-      err = assert_raises(RuntimeError) { make_bundle('no-such-jekyll-minibundle-cmd') }
-      assert_equal('Bundling "assets/site.js" failed: No such file or directory - no-such-jekyll-minibundle-cmd', err.to_s)
-    end
-
-    def test_raise_exception_if_bundle_command_not_configured
-      err = assert_raises(RuntimeError) { make_bundle(nil) }
-      expected_errmsg = <<~MESSAGE
-        Missing minification command for bundling "assets/site.js". Specify it in
-        1) minibundle.minifier_commands.js setting in _config.yml,
-        2) $JEKYLL_MINIBUNDLE_CMD_JS environment variable, or
-        3) minifier_cmd setting inside minibundle block.
-      MESSAGE
-      assert_equal(expected_errmsg, err.to_s)
-    end
-
-    private
-
-    def make_bundle(minifier_cmd)
-      bundle = AssetBundle.new(
-        type:             :js,
-        asset_paths:      [site_fixture_path('_assets/scripts/dependency.js')],
-        destination_path: 'assets/site',
-        site_dir:         site_fixture_path,
-        minifier_cmd:     minifier_cmd
-      )
-      bundle.make_bundle
-    end
-  end
-end

data/test/unit/asset_file_drop_test.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../support/test_case'
-require_relative '../support/fixture_config'
-require 'jekyll/minibundle/asset_file_drop'
-require 'jekyll/minibundle/stamp_file'
-
-module Jekyll::Minibundle::Test
-  class AssetFileDropTest < TestCase
-    include FixtureConfig
-
-    def test_method_access_via_subscript_method
-      with_drop do |drop|
-        assert_equal("screen-#{STAMP_FINGERPRINT}.css", drop['name'])
-      end
-    end
-
-    def test_method_access_via_forwarding
-      with_drop do |drop|
-        assert_equal("screen-#{STAMP_FINGERPRINT}.css", drop['name'])
-      end
-    end
-
-    def test_key?
-      with_drop do |drop|
-        assert(drop.key?('name'))
-      end
-    end
-
-    def test_to_h
-      with_drop do |drop|
-        hash = drop.to_h
-        assert_equal(AssetFileDrop::KEYS.sort, hash.keys.sort)
-        assert_equal("screen-#{STAMP_FINGERPRINT}.css", hash['name'])
-        assert_equal('.css', hash['extname'])
-        assert_equal("screen-#{STAMP_FINGERPRINT}", hash['basename'])
-        assert_instance_of(Time, hash['modified_time'])
-        assert_equal("/#{STAMP_SOURCE_PATH}", hash['path'])
-        assert_nil(hash['collection'])
-      end
-    end
-
-    def test_to_hash
-      with_drop do |drop|
-        assert_equal(drop.to_h, drop.to_hash)
-      end
-    end
-
-    def test_inspect
-      with_drop do |drop|
-        assert_equal(drop.to_h.keys, JSON.parse(drop.inspect).keys)
-      end
-    end
-
-    private
-
-    def with_drop(&block)
-      with_fake_site do |site|
-        file = StampFile.new(site, STAMP_SOURCE_PATH, STAMP_DESTINATION_PATH)
-        file.destination_path_for_markup
-        drop = AssetFileDrop.new(file)
-        block.call(drop)
-      end
-    end
-  end
-end

data/test/unit/asset_file_registry_test.rb

@@ -1,237 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../support/test_case'
-require_relative '../support/fixture_config'
-require 'jekyll/minibundle/asset_file_registry'
-
-module Jekyll::Minibundle::Test
-  class AssetFileRegistryTest < TestCase
-    include FixtureConfig
-
-    def setup
-      AssetFileRegistry.clear_all
-    end
-
-    def test_register_returns_same_bundle_file_for_same_bundle_config
-      with_fake_site do |site|
-        first = AssetFileRegistry.register_bundle_file(site, bundle_config)
-        second = AssetFileRegistry.register_bundle_file(site, bundle_config)
-        assert_same(first, second)
-        assert_equal(1, asset_file_registry_size)
-        assert_contains_only(site.static_files, [first])
-      end
-    end
-
-    def test_register_returns_same_development_file_collection_for_same_bundle_config
-      with_fake_site do |site|
-        first = AssetFileRegistry.register_development_file_collection(site, bundle_config)
-        second = AssetFileRegistry.register_development_file_collection(site, bundle_config)
-        assert_same(first, second)
-        assert_equal(1, asset_file_registry_size)
-        assert_contains_only(site.static_files, first.files)
-      end
-    end
-
-    def test_register_returns_different_bundle_files_for_bundle_configs_with_different_destination_paths
-      with_fake_site do |site|
-        first = AssetFileRegistry.register_bundle_file(site, bundle_config.merge('destination_path' => 'assets/dest1'))
-        second = AssetFileRegistry.register_bundle_file(site, bundle_config.merge('destination_path' => 'assets/dest2'))
-        refute_same first, second
-        assert_equal(2, asset_file_registry_size)
-        assert_contains_only(site.static_files, [first, second])
-      end
-    end
-
-    def test_register_returns_different_development_file_collections_for_bundle_configs_with_different_destination_paths
-      with_fake_site do |site|
-        first = AssetFileRegistry.register_development_file_collection(site, bundle_config.merge('destination_path' => 'assets/dest1'))
-        second = AssetFileRegistry.register_development_file_collection(site, bundle_config.merge('destination_path' => 'assets/dest2'))
-        refute_same first, second
-        assert_equal(2, asset_file_registry_size)
-        assert_contains_only(site.static_files, (first.files + second.files))
-      end
-    end
-
-    def test_register_returns_different_bundle_files_for_bundle_configs_with_different_types
-      with_fake_site do |site|
-        FileUtils.touch(File.join(JS_BUNDLE_SOURCE_DIR, 'dependency.css'))
-        FileUtils.touch(File.join(JS_BUNDLE_SOURCE_DIR, 'app.css'))
-        first = AssetFileRegistry.register_bundle_file(site, bundle_config.merge('type' => :css))
-        second = AssetFileRegistry.register_bundle_file(site, bundle_config.merge('type' => :js))
-        refute_same first, second
-        assert_equal(2, asset_file_registry_size)
-        assert_contains_only(site.static_files, [first, second])
-      end
-    end
-
-    def test_register_returns_different_development_file_collections_for_bundle_configs_with_different_types
-      with_fake_site do |site|
-        FileUtils.touch(File.join(JS_BUNDLE_SOURCE_DIR, 'dependency.css'))
-        FileUtils.touch(File.join(JS_BUNDLE_SOURCE_DIR, 'app.css'))
-        first = AssetFileRegistry.register_development_file_collection(site, bundle_config.merge('type' => :css))
-        second = AssetFileRegistry.register_development_file_collection(site, bundle_config.merge('type' => :js))
-        refute_same first, second
-        assert_equal(2, asset_file_registry_size)
-        assert_contains_only(site.static_files, (first.files + second.files))
-      end
-    end
-
-    [
-      {description: 'assets', config_diff: {'assets' => %w[b1 b2]}},
-      {description: 'source_directory', config_diff: {'source_dir' => '_assets/src2'}}
-    ].each do |spec|
-      define_method :"test_raise_exception_if_registering_bundle_file_with_same_destination_path_but_with_different_#{spec.fetch(:description)}" do
-        with_fake_site do |site|
-          first_config = bundle_config
-          first_file = AssetFileRegistry.register_bundle_file(site, first_config)
-          second_config = bundle_config.merge(spec[:config_diff])
-          err = assert_raises(RuntimeError) do
-            AssetFileRegistry.register_bundle_file(site, second_config)
-          end
-          assert_equal(<<~MESSAGE, err.to_s)
-            Two or more minibundle blocks with the same destination path "assets/site.js", but having different asset configuration: #{second_config.inspect} vs. #{first_config.inspect}
-          MESSAGE
-          assert_equal(1, asset_file_registry_size)
-          assert_contains_only(site.static_files, [first_file])
-        end
-      end
-
-      define_method :"test_raise_exception_if_registering_development_file_collection_with_same_destination_path_but_with_different_#{spec.fetch(:description)}" do
-        with_fake_site do |site|
-          first_config = bundle_config
-          first_file = AssetFileRegistry.register_development_file_collection(site, first_config)
-          second_config = bundle_config.merge(spec[:config_diff])
-          err = assert_raises(RuntimeError) do
-            AssetFileRegistry.register_development_file_collection(site, second_config)
-          end
-          assert_equal(<<~MESSAGE, err.to_s)
-            Two or more minibundle blocks with the same destination path "assets/site.js", but having different asset configuration: #{second_config.inspect} vs. #{first_config.inspect}
-          MESSAGE
-          assert_equal(1, asset_file_registry_size)
-          assert_contains_only(site.static_files, first_file.files)
-        end
-      end
-    end
-
-    [
-      {description: 'stamp_file', method: :register_stamp_file},
-      {description: 'development_file', method: :register_development_file}
-    ].each do |spec|
-      define_method :"test_register_returns_same_#{spec.fetch(:description)}_for_same_source_and_destination_paths" do
-        with_fake_site do |site|
-          first = AssetFileRegistry.send(spec.fetch(:method), site, STAMP_SOURCE_PATH, 'assets/dest1.css')
-          second = AssetFileRegistry.send(spec.fetch(:method), site, STAMP_SOURCE_PATH, 'assets/dest1.css')
-          assert_same(first, second)
-          assert_equal(1, asset_file_registry_size)
-          assert_contains_only(site.static_files, [first])
-        end
-      end
-
-      define_method :"test_register_returns_different_#{spec.fetch(:description)}s_for_different_source_and_destination_paths" do
-        with_fake_site do |site|
-          first = AssetFileRegistry.send(spec.fetch(:method), site, STAMP_SOURCE_PATH, 'assets/dest1.css')
-          second = AssetFileRegistry.send(spec.fetch(:method), site, STAMP_SOURCE_PATH, 'assets/dest2.css')
-          refute_same first, second
-          assert_equal(2, asset_file_registry_size)
-          assert_contains_only(site.static_files, [first, second])
-        end
-      end
-
-      define_method :"test_raise_exception_if_registering_#{spec.fetch(:description)}s_with_different_source_and_same_destination_paths" do
-        with_fake_site do |site|
-          source_paths = %w[src1.css src2.css].map do |file|
-            File.join(CSS_BUNDLE_SOURCE_DIR, file)
-          end
-          source_paths.each { |path| FileUtils.touch(path) }
-          first = AssetFileRegistry.send(spec.fetch(:method), site, source_paths[0], 'assets/dest1.css')
-          err = assert_raises(RuntimeError) do
-            AssetFileRegistry.send(spec.fetch(:method), site, source_paths[1], 'assets/dest1.css')
-          end
-          assert_equal(<<~MESSAGE, err.to_s)
-            Two or more ministamp tags with the same destination path "assets/dest1.css", but different asset source paths: "#{source_paths[1]}" vs. "#{source_paths[0]}"
-          MESSAGE
-          assert_equal(1, asset_file_registry_size)
-          assert_contains_only(site.static_files, [first])
-        end
-      end
-    end
-
-    def test_raise_exception_if_registering_stamp_file_with_same_destination_path_as_existing_bundle_file
-      with_fake_site do |site|
-        FileUtils.touch('_assets/src.js')
-        file = AssetFileRegistry.register_bundle_file(site, bundle_config.merge('destination_path' => 'assets/dest'))
-        err = assert_raises(RuntimeError) do
-          AssetFileRegistry.register_stamp_file(site, '_assets/src.js', 'assets/dest.js')
-        end
-        assert_equal('ministamp tag has the same destination path as a minibundle block: assets/dest.js', err.to_s)
-        assert_equal(1, asset_file_registry_size)
-        assert_contains_only(site.static_files, [file])
-      end
-    end
-
-    def test_raise_exception_if_registering_bundle_file_with_same_destination_path_as_existing_stamp_file
-      with_fake_site do |site|
-        FileUtils.touch('_assets/src.js')
-        file = AssetFileRegistry.register_stamp_file(site, '_assets/src.js', 'assets/dest.js')
-        err = assert_raises(RuntimeError) do
-          AssetFileRegistry.register_bundle_file(site, bundle_config.merge('destination_path' => 'assets/dest'))
-        end
-        assert_equal('minibundle block has the same destination path as a ministamp tag: assets/dest.js', err.to_s)
-        assert_equal(1, asset_file_registry_size)
-        assert_contains_only(site.static_files, [file])
-      end
-    end
-
-    [
-      {description: 'bundle_file', method: :register_bundle_file},
-      {description: 'development_file_collection', method: :register_development_file_collection}
-    ].each do |spec|
-      define_method :"test_remove_unused_#{spec.fetch(:description)}" do
-        with_fake_site do |site|
-          AssetFileRegistry.send(spec.fetch(:method), site, bundle_config)
-          AssetFileRegistry.clear_unused
-
-          assert_equal(1, asset_file_registry_size)
-
-          AssetFileRegistry.clear_unused
-
-          assert_equal(0, asset_file_registry_size)
-        end
-      end
-    end
-
-    [
-      {description: 'stamp_file', method: :register_stamp_file},
-      {description: 'development_file', method: :register_development_file}
-    ].each do |spec|
-      define_method :"test_remove_unused_#{spec.fetch(:description)}" do
-        with_fake_site do |site|
-          AssetFileRegistry.send(spec.fetch(:method), site, STAMP_SOURCE_PATH, STAMP_DESTINATION_PATH)
-          AssetFileRegistry.clear_unused
-
-          assert_equal(1, asset_file_registry_size)
-
-          AssetFileRegistry.clear_unused
-
-          assert_equal(0, asset_file_registry_size)
-        end
-      end
-    end
-
-    private
-
-    def bundle_config
-      {
-        'type'             => :js,
-        'source_dir'       => JS_BUNDLE_SOURCE_DIR,
-        'assets'           => %w[dependency app],
-        'destination_path' => JS_BUNDLE_DESTINATION_PATH,
-        'minifier_cmd'     => 'unused_minifier_cmd'
-      }
-    end
-
-    def asset_file_registry_size
-      AssetFileRegistry.instance_variable_get(:@_files).size
-    end
-  end
-end

data/test/unit/asset_tag_markup_test.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../support/test_case'
-require 'jekyll/minibundle/asset_tag_markup'
-
-module Jekyll::Minibundle::Test
-  class AssetTagMarkupTest < TestCase
-    def test_escape_url
-      actual = AssetTagMarkup.make_markup(:css, 'https://example.com/path?a=this+"thing"&b=<br>', {})
-      expected = %(<link rel="stylesheet" href="https://example.com/path?a=this+&quot;thing&quot;&amp;b=&lt;br&gt;">)
-      assert_equal(expected, actual)
-    end
-
-    def test_escape_attribute_value
-      attributes = {media: 'screen, projection', extra: '">attack<br'}
-      actual = AssetTagMarkup.make_markup(:css, '/asset.css', attributes)
-      expected = %(<link rel="stylesheet" href="/asset.css" media="screen, projection" extra="&quot;&gt;attack&lt;br">)
-      assert_equal(expected, actual)
-    end
-
-    def test_output_just_attribute_name_for_nil_value
-      actual = AssetTagMarkup.make_markup(:css, '/asset.css', async: nil)
-      expected = %(<link rel="stylesheet" href="/asset.css" async>)
-      assert_equal(expected, actual)
-    end
-
-    def test_convert_attribute_value_to_string
-      actual = AssetTagMarkup.make_markup(:css, '/asset.css', boolean: false)
-      expected = %(<link rel="stylesheet" href="/asset.css" boolean="false">)
-      assert_equal(expected, actual)
-    end
-
-    def test_output_empty_attribute_value
-      actual = AssetTagMarkup.make_markup(:css, '/asset.css', empty: '')
-      expected = %(<link rel="stylesheet" href="/asset.css" empty="">)
-      assert_equal(expected, actual)
-    end
-
-    def test_raise_exception_if_unknown_type
-      err = assert_raises(ArgumentError) do
-        AssetTagMarkup.make_markup(:unknown, '/asset', {})
-      end
-      assert_equal('Unknown type for generating bundle markup: unknown, /asset', err.to_s)
-    end
-  end
-end