jekyll-minibundle 1.4.6 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3033c98c36f602ceef9d58172d191d2a11508f79
-  data.tar.gz: b8c1a7471f47be584ecf61964f078225ed9e7ae4
+  metadata.gz: 0f6bdd5c8d86c6ae46c876c1898698012e141a55
+  data.tar.gz: b6e02cb3cccb431144eb9570f3b55e583b2b67fb
 SHA512:
-  metadata.gz: 65cacc8d91187ec779f4fd94a2bd11fe2c708d7526a353d2e12ad519307a9e041d6c6bb9670414cbf57a3ba451081e991b541e2457d9026a871ae70a7dad7784
-  data.tar.gz: 94e875d5205d0ba70ed44bb88dc93592766bb792361d8073d9604750b14fc6d00faf8fc78a1b80df823a63baeeb32c898c1fd49c41c01fd070f9e8e7b3466af8
+  metadata.gz: 5935d3fd4affcc1c72011f4efeaf4aa2b4b825a40bb1deeca44e5a546d2c5f0b8daf91932bed9922e4af8989aafc1e2277c496cc60ebc4bc679ab6c701d7f8fe
+  data.tar.gz: 3ed84507cb56cf1d6a1b5604085d11f09e7a39c446f6fc67bcc6991405da09181d290d1e7f28a2dc7cae47e9c10167f44fc3e19dbe1bfac48abd04319a018fa8

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 1.5.0 / 2014-07-27
+
+* Support minifier command specification in `_config.yml` and inside
+  `minibundle` block (#4, @phillipadsmith)
+* Support enabling development mode from `_config.yml`
+* Add argument validation to `minibundle` block and `ministamp` tag
+* Document how to load the gem with Jekyll's `gems` config setting
+
 # 1.4.6 / 2014-05-10
 
 * Handle compatibility issues with safe_yaml and logger flexibly. This

data/README.md

@@ -23,17 +23,17 @@ feature.
 
 Asset bundling consists of concatenation and minification. The plugin
 implements concatenation and leaves choosing the minification tool up
-to you. [UglifyJS2](https://github.com/mishoo/UglifyJS2) is a good and
-fast minifier, for example. The plugin connects to the minifier with
-standard unix pipe, feeding asset file contents to it in desired order
-via standard input, and reads the result from standard output.
+to you. [UglifyJS2][UglifyJS2] is a good and fast minifier, for
+example. The plugin connects to the minifier with standard unix pipe,
+feeding asset file contents to it in desired order via standard input,
+and reads the result from standard output.
 
 Why is this good? A fingerprint in asset's path is the
-[recommended way](https://developers.google.com/speed/docs/best-practices/caching)
-to handle caching of static resources, because you can allow caching
-the asset forever. Calculating MD5 digest over the contents of the
-asset is fast and the resulting digest is reasonably unique to be
-generated automatically.
+[recommended way][GoogleCachingBestPractices] to handle caching of
+static resources, because you can allow caching the asset
+forever. Calculating MD5 digest over the contents of the asset is fast
+and the resulting digest is reasonably unique to be generated
+automatically.
 
 Asset bundling is good for reducing the number of requests to the
 backend upon page load. The minification of stylesheets and JavaScript
@@ -42,22 +42,33 @@ network.
 
 # Usage
 
-The plugin is shipped as a
-[RubyGem](https://rubygems.org/gems/jekyll-minibundle):
+The plugin ships as a
+[RubyGem](https://rubygems.org/gems/jekyll-minibundle). To install:
 
 ``` bash
 $ gem install jekyll-minibundle
 ```
 
-Add `_plugins/minibundle.rb` file to your Jekyll site project with
-this line:
+(You should use [Bundler][GemBundler] to manage the gems in your
+project.)
+
+Then, instruct Jekyll to load the gem by adding this line to the
+[configuration file][JekyllConf] of your Jekyll site project
+(`_config.yml`):
+
+``` yaml
+gems: ['jekyll/minibundle']
+```
+
+An alternative to using the `gems` configuration setting is to add
+`_plugins/minibundle.rb` file to your site project with this line:
 
 ``` ruby
 require 'jekyll/minibundle'
 ```
 
-You must allow Jekyll to use custom plugins. In
-[Jekyll's configuration][JekyllConf], do not enable `safe` setting.
+You must allow Jekyll to use custom plugins. That is, do not enable
+Jekyll's `safe` setting.
 
 ## Asset fingerprinting
 
@@ -77,9 +88,8 @@ Output, containing the MD5 digest of the file in the filename:
 Jekyll's output directory will have the asset file at that path.
 
 This feature is useful when combined with asset generation tools
-external to Jekyll. For example, you can configure
-[Compass](http://compass-style.org/) to take inputs from
-`_assets/styles/*.scss` and to produce output to
+external to Jekyll. For example, you can configure [Compass][Compass]
+to take inputs from `_assets/styles/*.scss` and to produce output to
 `_tmp/site.css`. Then, you use `ministamp` tag to copy the file with a
 fingerprint to Jekyll's output directory:
 
@@ -113,24 +123,25 @@ attributes:
 {% endminibundle %}
 ```
 
-Then, specify the command for launching your favorite minifier in
-`$JEKYLL_MINIBUNDLE_CMD_JS` environment variable. For example, when
-launching Jekyll:
+Then, specify the command for launching your favorite minifier in `_config.yml`:
 
-``` bash
-$ JEKYLL_MINIBUNDLE_CMD_JS='./node_modules/.bin/uglifyjs --' jekyll
+``` yaml
+minibundle:
+  minifier_commands:
+    js: ./node_modules/.bin/uglifyjs -
 ```
 
-You can pass custom attributes to the generated markup with
-`attributes` map in the configuration.
-
 Output in the content file:
 
 ``` html
 <script src="assets/site-8e764372a0dbd296033cb2a416f064b5.js" type="text/javascript" id="my-scripts"></script>
 ```
 
-For bundling CSS assets, you use `css` as the argument to `minibundle` block:
+You can pass custom attributes, like `id="my-scripts"` above, to the
+generated markup with `attributes` map inside the `minibundle` block.
+
+For bundling CSS assets, you use `css` as the argument to the
+`minibundle` block:
 
 ``` text
 {% minibundle css %}
@@ -144,8 +155,56 @@ attributes:
 {% endminibundle %}
 ```
 
-And then specify the command for launching bundling in
-`$JEKYLL_MINIBUNDLE_CMD_CSS` environment variable.
+And then specify the minifier command in `_config.yml`:
+
+``` yaml
+minibundle:
+  minifier_commands:
+    css: _bin/remove_whitespace
+    js: ./node_modules/.bin/uglifyjs -
+```
+
+### Minifier command specification
+
+You can specify minifier commands in three places:
+
+1. in `_config.yml` (as shown earlier):
+
+   ``` yaml
+   minibundle:
+     minifier_commands:
+       css: _bin/remove_whitespace
+       js: ./node_modules/.bin/uglifyjs -
+   ```
+
+2. as environment variables:
+
+   ``` bash
+   export JEKYLL_MINIBUNDLE_CMD_CSS=_bin/remove_whitespace
+   export JEKYLL_MINIBUNDLE_CMD_JS="./node_modules/.bin/uglifyjs -"
+   ```
+
+3. inside the minibundle block with `minifier_cmd` setting, allowing
+   blocks to have different commands from each other:
+
+   ``` text
+   {% minibundle js %}
+   source_dir: _assets/scripts
+   destination_path: assets/site
+   minifier_cmd: ./node_modules/.bin/uglifyjs -
+   assets:
+     - dependency
+     - app
+   attributes:
+     id: my-scripts
+   {% endminibundle %}
+   ```
+
+These ways of specification are listed in increasing order of
+specificity. Should multiple commands apply to a block, the most
+specific one wins. For example, the `minifier_cmd` setting inside
+`minibundle js` block overrides the setting in
+`$JEKYLL_MINIBUNDLE_CMD_JS` environment variable.
 
 ## Recommended directory layout
 
@@ -192,6 +251,16 @@ filenames and line numbers of the original asset sources.
 $ JEKYLL_MINIBUNDLE_MODE=development jekyll serve --watch
 ```
 
+Alternatively, you can enable development mode from `_config.yml`:
+
+``` yaml
+minibundle:
+  mode: development
+```
+
+Should both be defined, the setting from the environment variable
+wins.
+
 # Example site
 
 See the contents of `test/fixture/site` directory.
@@ -200,5 +269,9 @@ See the contents of `test/fixture/site` directory.
 
 MIT. See `LICENSE.txt`.
 
+[Compass]: http://compass-style.org/
+[GemBundler]: http://bundler.io/
+[GoogleCachingBestPractices]: https://developers.google.com/speed/docs/best-practices/caching
 [Jekyll]: http://jekyllrb.com/
 [JekyllConf]: http://jekyllrb.com/docs/configuration/
+[UglifyJS2]: https://github.com/mishoo/UglifyJS2

data/Rakefile

@@ -4,19 +4,19 @@ require 'shellwords'
 
 require_relative 'lib/jekyll/minibundle/version'
 
-def get_minibundle_env(overrides = {})
-  bundle_cmd = File.expand_path(File.join(File.dirname(__FILE__), 'test/fixture/site/_bin/remove_comments'))
-  {
-    'JEKYLL_MINIBUNDLE_CMD_JS'  => bundle_cmd,
-    'JEKYLL_MINIBUNDLE_CMD_CSS' => bundle_cmd,
-    'RUBYLIB'                   => File.expand_path(File.join(File.dirname(__FILE__), 'lib'))
-  }.merge(overrides)
-end
-
 def run_jekyll_in_fixture_site(command)
   Dir.chdir('test/fixture/site')
   FileUtils.rm_rf('_site')
-  sh get_minibundle_env, "jekyll #{command}"
+
+  minifier_cmd = File.expand_path(File.join(File.dirname(__FILE__), 'test/fixture/site/_bin/remove_comments'))
+  env = {
+    'JEKYLL_MINIBUNDLE_CMD_JS'  => minifier_cmd,
+    'JEKYLL_MINIBUNDLE_CMD_CSS' => minifier_cmd,
+    'RUBYLIB'                   => File.expand_path(File.join(File.dirname(__FILE__), 'lib'))
+  }
+  jekyll_cmd = "jekyll #{command}"
+
+  sh env, jekyll_cmd
 end
 
 namespace :gem do
@@ -46,11 +46,9 @@ task :test do
   files = Dir[glob].
     map { |file| %r{^test/(.+)\.rb$}.match(file)[1] }.
     shelljoin
-  opts = ENV['debug'] ? '-w -rpp -rpry' : ''
+  extra_opts = ENV['debug'] ? '-w -rpp -rpry' : ''
   eval = %{-e 'ARGV.each { |f| require f }'}
-  cmd = "ruby #{opts} #{eval} #{files}"
-  env = get_minibundle_env('RUBYLIB' => 'lib:test')
-  sh env, cmd
+  sh "ruby -I lib:test #{extra_opts} #{eval} #{files}"
 end
 
 namespace :fixture do

data/jekyll-minibundle.gemspec

@@ -27,7 +27,7 @@ minification tool (not even other gems).
 
   s.test_files = `git ls-files -- test`.split("\n")
 
-  s.add_development_dependency 'jekyll',   '~> 2.0'
+  s.add_development_dependency 'jekyll',   '~> 2.1'
   s.add_development_dependency 'minitest', '~> 5.3'
   s.add_development_dependency 'nokogiri', '~> 1.6'
   s.add_development_dependency 'rake',     '~> 10.3'

data/lib/jekyll/minibundle/asset_bundle.rb

@@ -1,11 +1,23 @@
 require 'tempfile'
-require 'jekyll/minibundle/environment'
 require 'jekyll/minibundle/compatibility'
 
 module Jekyll::Minibundle
   class AssetBundle
-    def initialize(type, asset_paths, site_dir)
-      @type, @asset_paths, @site_dir = type, asset_paths, site_dir
+    def initialize(config)
+      @type = config.fetch(:type)
+      @asset_paths = config.fetch(:asset_paths)
+      @site_dir = config.fetch(:site_dir)
+      @minifier_cmd = config.fetch(:minifier_cmd)
+
+      unless @minifier_cmd
+        fail <<-END
+Missing minification command for bundling #{@type} assets. Specify it in
+1) minibundle.minifier_commands.#{@type} setting in _config.yml,
+2) $JEKYLL_MINIBUNDLE_CMD_#{@type.to_s.upcase} environment variable, or
+3) minifier_cmd setting inside minibundle block.
+        END
+      end
+
       @temp_file = Tempfile.new("jekyll-minibundle-#{@type}-")
       at_exit { @temp_file.close! }
     end
@@ -15,8 +27,7 @@ module Jekyll::Minibundle
     end
 
     def make_bundle
-      cmd = get_minifier_cmd
-      exit_status = spawn_minifier(cmd) do |input|
+      exit_status = spawn_minifier(@minifier_cmd) do |input|
         $stdout.puts  # place newline after "(Re)generating..." log messages
         Compatibility.log_info("Bundling #{@type} assets:")
         @asset_paths.each do |asset|
@@ -25,7 +36,7 @@ module Jekyll::Minibundle
           input.puts(';') if @type == :js
         end
       end
-      fail "Bundling #{@type} assets failed with exit status #{exit_status}, command: #{cmd}" if exit_status != 0
+      fail "Bundling #{@type} assets failed with exit status #{exit_status}, command: #{@minifier_cmd}" if exit_status != 0
       self
     end
 
@@ -35,10 +46,6 @@ module Jekyll::Minibundle
       path.sub(/\A#{base}\//, '')
     end
 
-    def get_minifier_cmd
-      Environment.command_for(@type)
-    end
-
     def spawn_minifier(cmd)
       pid = nil
       rd, wr = IO.pipe

data/lib/jekyll/minibundle/asset_file_registry.rb

@@ -10,9 +10,9 @@ module Jekyll::Minibundle
         @_instances = {}
       end
 
-      def bundle_file(site, config)
-        asset_destination_path = "#{config.fetch('destination_path')}.#{config.fetch('type')}"
-        @_instances[asset_destination_path] ||= register_bundle_file(site, config)
+      def bundle_file(site, bundle_config)
+        asset_destination_path = "#{bundle_config.fetch('destination_path')}.#{bundle_config.fetch('type')}"
+        @_instances[asset_destination_path] ||= register_bundle_file(site, bundle_config)
       end
 
       def stamp_file(site, asset_source_path, asset_destination_path)
@@ -21,20 +21,20 @@ module Jekyll::Minibundle
 
       private
 
-      def register_bundle_file(site, config)
-        if Environment.development?
-          DevelopmentFileCollection.new(site, config)
+      def register_bundle_file(site, bundle_config)
+        if Environment.development?(site)
+          DevelopmentFileCollection.new(site, bundle_config)
         else
-          BundleFile.new(site, config)
+          BundleFile.new(site, bundle_config)
         end
       end
 
       def register_stamp_file(site, asset_source_path, asset_destination_path)
-        StampFile.new(site, asset_source_path, asset_destination_path, &get_stamp_file_basenamer)
+        StampFile.new(site, asset_source_path, asset_destination_path, &get_stamp_file_basenamer(site))
       end
 
-      def get_stamp_file_basenamer
-        if Environment.development?
+      def get_stamp_file_basenamer(site)
+        if Environment.development?(site)
           ->(base, ext, _) { base + ext }
         else
           ->(base, ext, stamper) { "#{base}-#{stamper.call}#{ext}" }

data/lib/jekyll/minibundle/asset_tag_markup.rb

@@ -10,7 +10,7 @@ module Jekyll::Minibundle
         when :css
           %{<link rel="stylesheet" href="#{path}"#{make_attributes(attributes)}>}
         else
-          fail "Unknown type for generating bundle markup: #{type}, #{path}"
+          fail ArgumentError, "Unknown type for generating bundle markup: #{type}, #{path}"
         end
       end
 

data/lib/jekyll/minibundle/bundle_file.rb

@@ -17,6 +17,7 @@ module Jekyll::Minibundle
       @asset_paths = config.fetch('assets').map { |asset_path| File.join(asset_source_dir, "#{asset_path}.#{@type}") }
       @destination_path = config.fetch('destination_path')
       @attributes = config.fetch('attributes')
+      @minifier_cmd = config.fetch('minifier_cmd')
       @stamped_at = nil
       @is_modified = false
     end
@@ -65,7 +66,12 @@ module Jekyll::Minibundle
     end
 
     def asset_bundle
-      @_asset_bundle ||= AssetBundle.new(@type, @asset_paths, @site.source)
+      @_asset_bundle ||= AssetBundle.new(
+        type: @type,
+        asset_paths: @asset_paths,
+        site_dir: @site.source,
+        minifier_cmd: @minifier_cmd
+      )
     end
   end
 end

data/lib/jekyll/minibundle/environment.rb

@@ -1,13 +1,31 @@
 module Jekyll::Minibundle
   module Environment
     class << self
-      def command_for(type)
-        key = "JEKYLL_MINIBUNDLE_CMD_#{type.upcase}"
-        ENV.fetch(key) { fail "You need to set command for minification in $#{key}" }
+      def minifier_command(site, type)
+        type = type.to_s
+        ENV["JEKYLL_MINIBUNDLE_CMD_#{type.upcase}"] || Environment.find_site_config(site, ['minibundle', 'minifier_commands', type], String)
       end
 
-      def development?
-        ENV['JEKYLL_MINIBUNDLE_MODE'] == 'development'
+      def development?(site)
+        mode = ENV['JEKYLL_MINIBUNDLE_MODE'] || Environment.find_site_config(site, ['minibundle', 'mode'], String)
+        mode == 'development'
+      end
+
+      def find_site_config(site, keys, type)
+        value = traverse_hash(site.config, keys)
+        if value && !value.is_a?(type)
+          fail "Invalid site configuration for key #{keys.join('.')}; expecting type #{type}"
+        end
+        value
+      end
+
+      def traverse_hash(hash, keys)
+        value = hash
+        keys.each do |key|
+          return nil unless value
+          value = value[key]
+        end
+        value
       end
     end
   end

data/lib/jekyll/minibundle/mini_bundle_block.rb

@@ -1,37 +1,46 @@
 require 'jekyll/minibundle/asset_file_registry'
 require 'jekyll/minibundle/compatibility'
+require 'jekyll/minibundle/environment'
 
 module Jekyll::Minibundle
   class MiniBundleBlock < Liquid::Block
     def initialize(tag_name, type, _tokens)
       super
-      @type = type.strip.to_sym
+      @type = type.strip.downcase.to_sym
+      if @type.empty?
+        fail ArgumentError, "No asset type for minibundle block; pass value such as 'css' or 'js' as the argument"
+      end
     end
 
     def render(context)
       site = context.registers.fetch(:site)
-      config = get_current_config(Compatibility.load_yaml(super), site)
-      file = AssetFileRegistry.bundle_file(site, config)
+      bundle_config = get_current_bundle_config(Compatibility.load_yaml(super), site)
+      file = AssetFileRegistry.bundle_file(site, bundle_config)
       file.add_as_static_file_to(site)
       file.destination_path_for_markup
     end
 
-    def self.default_config
+    def self.default_bundle_config
       {
-        'source_dir'        => '_assets',
-        'destination_path'  => 'assets/site',
-        'assets'            => [],
-        'attributes'        => {}
+        'source_dir'       => '_assets',
+        'destination_path' => 'assets/site',
+        'assets'           => [],
+        'attributes'       => {}
       }
     end
 
     private
 
-    def get_current_config(user_config, site)
-      MiniBundleBlock.default_config.
-        merge(user_config).
+    def get_current_bundle_config(local_bundle_config, site)
+      MiniBundleBlock.default_bundle_config.
+        merge(environment_bundle_config(site)).
+        merge(local_bundle_config).
         merge('type' => @type)
     end
+
+    def environment_bundle_config(site)
+      { 'minifier_cmd' => Environment.minifier_command(site, @type) }
+    end
   end
 end
 

data/lib/jekyll/minibundle/mini_stamp_tag.rb

@@ -5,6 +5,12 @@ module Jekyll::Minibundle
     def initialize(tag_name, text, _tokens)
       super
       @asset_source, @asset_destination = text.split(/\s+/, 3)[0, 2]
+      if !@asset_source || @asset_source.empty?
+        fail ArgumentError, "No asset source for ministamp tag; pass value such as '/_assets/site.css' as the first argument"
+      end
+      if !@asset_destination || @asset_destination.empty?
+        fail ArgumentError, "No asset destination for ministamp tag; pass value such as '/assets/site.css' as the second argument"
+      end
     end
 
     def render(context)

data/lib/jekyll/minibundle/version.rb

@@ -1,5 +1,5 @@
 module Jekyll
   module Minibundle
-    VERSION = '1.4.6'
+    VERSION = '1.5.0'
   end
 end

data/test/fixture/site/_config.yml

@@ -1 +1,2 @@
+gems: ['jekyll/minibundle']
 safe: false

data/test/integration/minibundle_development_mode_test.rb

@@ -111,10 +111,8 @@ module Jekyll::Minibundle::Test
 
     def test_does_not_require_bundling_commands
       with_site_dir do
-        with_env('JEKYLL_MINIBUNDLE_CMD_CSS' => nil, 'JEKYLL_MINIBUNDLE_CMD_JS' => nil) do
-          generate_site(:development)
-          pass
-        end
+        generate_site(:development, minifier_cmd_css: nil, minifier_cmd_js: nil)
+        pass
       end
     end
 
@@ -135,6 +133,22 @@ module Jekyll::Minibundle::Test
       end
     end
 
+    def test_gets_development_mode_from_site_configuration
+      with_site_dir do
+        merge_to_yaml_file('_config.yml', 'minibundle' => {'mode' => 'development'})
+        generate_site(nil)
+        assert File.exist?(destination_path(JS_BUNDLE_DESTINATION_PATH, 'app.js'))
+      end
+    end
+
+    def test_development_mode_from_environment_overrides_mode_from_site_configuration
+      with_site_dir do
+        merge_to_yaml_file('_config.yml', 'minibundle' => {'mode' => 'production'})
+        generate_site(:development)
+        assert File.exist?(destination_path(JS_BUNDLE_DESTINATION_PATH, 'app.js'))
+      end
+    end
+
     private
 
     def find_css_elements_from_index

data/test/integration/minibundle_production_mode_test.rb

@@ -166,34 +166,89 @@ module Jekyll::Minibundle::Test
 
     def test_bundles_assets_only_once_at_startup
       with_site_dir do
-        with_env('JEKYLL_MINIBUNDLE_CMD_JS' => cmd_to_remove_comments_and_count) do
-          generate_site(:production)
-        end
-        assert_equal 1, get_cmd_count
+        generate_site(:production, minifier_cmd_js: minifier_cmd_to_remove_comments_and_count)
+        assert_equal 1, get_minifier_cmd_count
       end
     end
 
     def test_does_not_rebundle_assets_when_nonsource_files_change
       with_site_dir do
-        with_env('JEKYLL_MINIBUNDLE_CMD_JS' => cmd_to_remove_comments_and_count) do
-          generate_site(:production)
-          expected_js_path = destination_path(JS_BUNDLE_DESTINATION_FINGERPRINT_PATH)
-          last_mtime = mtime_of(expected_js_path)
+        generate_site(:production, minifier_cmd_js: minifier_cmd_to_remove_comments_and_count)
+        expected_js_path = destination_path(JS_BUNDLE_DESTINATION_FINGERPRINT_PATH)
+        last_mtime = mtime_of(expected_js_path)
+
+        assert_equal 1, get_minifier_cmd_count
 
-          assert_equal 1, get_cmd_count
+        ensure_file_mtime_changes { File.write(source_path(CSS_BUNDLE_SOURCE_DIR, 'common.css'), 'h1 {}') }
+        generate_site(:production, clear_cache: false, minifier_cmd_js: minifier_cmd_to_remove_comments_and_count)
 
-          ensure_file_mtime_changes { File.write(source_path(CSS_BUNDLE_SOURCE_DIR, 'common.css'), 'h1 {}') }
-          generate_site(:production, clear_cache: false)
+        assert_equal last_mtime, mtime_of(expected_js_path)
+        assert_equal 1, get_minifier_cmd_count
 
-          assert_equal last_mtime, mtime_of(expected_js_path)
-          assert_equal 1, get_cmd_count
+        ensure_file_mtime_changes { FileUtils.touch('index.html') }
+        generate_site(:production, clear_cache: false, minifier_cmd_js: minifier_cmd_to_remove_comments_and_count)
 
-          ensure_file_mtime_changes { FileUtils.touch('index.html') }
-          generate_site :production, clear_cache: false
+        assert_equal last_mtime, mtime_of(expected_js_path)
+        assert_equal 1, get_minifier_cmd_count
+      end
+    end
 
-          assert_equal last_mtime, mtime_of(expected_js_path)
-          assert_equal 1, get_cmd_count
-        end
+    def test_gets_minifier_command_from_site_configuration
+      with_site_dir do
+        merge_to_yaml_file('_config.yml', 'minibundle' => {'minifier_commands' => {'js' => minifier_cmd_to_remove_comments_and_count('minifier_cmd_config_count')}})
+
+        generate_site(:production, minifier_cmd_js: nil)
+
+        assert_equal 0, get_minifier_cmd_count
+        assert_equal 1, get_minifier_cmd_count('minifier_cmd_config_count')
+        assert File.exist?(destination_path(JS_BUNDLE_DESTINATION_FINGERPRINT_PATH))
+      end
+    end
+
+    def test_minifier_command_from_environment_overrides_command_from_site_configuration
+      with_site_dir do
+        merge_to_yaml_file('_config.yml', 'minibundle' => {'minifier_commands' => {'js' => minifier_cmd_to_remove_comments_and_count('minifier_cmd_config_count')}})
+
+        generate_site(:production, minifier_cmd_js: minifier_cmd_to_remove_comments_and_count('minifier_cmd_env_count'))
+
+        assert_equal 0, get_minifier_cmd_count('minifier_cmd_config_count')
+        assert_equal 1, get_minifier_cmd_count('minifier_cmd_env_count')
+        assert File.exist?(destination_path(JS_BUNDLE_DESTINATION_FINGERPRINT_PATH))
+      end
+    end
+
+    def test_minifier_command_in_local_block_overrides_command_from_environment
+      with_site_dir do
+        IO.write('test.html', <<-END)
+---
+layout: override
+title: Test
+---
+        END
+
+        IO.write('_layouts/override.html', <<-END)
+<!DOCTYPE html>
+<html>
+  <body>
+    {% minibundle js %}
+    source_dir: _assets/scripts
+    destination_path: assets/deps
+    assets:
+      - dependency
+    minifier_cmd: #{minifier_cmd_to_remove_comments_and_count('minifier_cmd_local_count')}
+    {% endminibundle %}
+  </body>
+  <title>{{ page.title }}</title>
+</html>
+        END
+
+        generate_site(:production, minifier_cmd_js: minifier_cmd_to_remove_comments_and_count('minifier_cmd_global_count'))
+
+        assert_equal 1, get_minifier_cmd_count('minifier_cmd_local_count')
+        assert File.exist?(destination_path('assets/deps-71042d0b7c86c04e015fde694dd9f409.js'))
+
+        assert_equal 1, get_minifier_cmd_count('minifier_cmd_global_count')
+        assert File.exist?(destination_path(JS_BUNDLE_DESTINATION_FINGERPRINT_PATH))
       end
     end
 

data/test/support/test_case.rb

@@ -34,6 +34,10 @@ module Jekyll::Minibundle::Test
       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 mtime_of(path)
       File.stat(path).mtime
     end
@@ -59,13 +63,13 @@ module Jekyll::Minibundle::Test
     end
 
     def new_fake_site(dir)
-      OpenStruct.new(:source => dir)
+      OpenStruct.new(source: dir, static_files: [])
     end
 
     def new_real_site
       config = nil
       capture_io do
-        config = Jekyll.configuration(TestCase.site_generation_jekyll_options)
+        config = Jekyll.configuration('source' => Dir.pwd, 'destination' => '_site')
       end
       Jekyll::Site.new(config)
     end
@@ -81,9 +85,12 @@ module Jekyll::Minibundle::Test
     end
 
     def generate_site(mode, options = {})
-      with_env('JEKYLL_MINIBUNDLE_MODE' => mode.to_s) do
-        _generate_site(_get_site_generation_test_options(options))
-      end
+      env = {
+        'JEKYLL_MINIBUNDLE_MODE'    => 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)
@@ -91,13 +98,17 @@ module Jekyll::Minibundle::Test
       yield
     end
 
-    def cmd_to_remove_comments_and_count
-      site_fixture_path('_bin/with_count') + ' count _bin/remove_comments'
+    def minifier_cmd_to_remove_comments
+      site_fixture_path('_bin/remove_comments')
     end
 
-    def get_cmd_count
-      if File.exist?('count')
-        File.read('count').to_i
+    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.exist?(count_file)
+        File.read(count_file).to_i
       else
         0
       end
@@ -127,24 +138,9 @@ module Jekyll::Minibundle::Test
     end
 
     def _generate_site(test_options)
-      AssetFileRegistry.clear if test_options.fetch(:clear_cache)
+      AssetFileRegistry.clear if test_options.fetch(:clear_cache, true)
       site = new_real_site
       capture_io { site.process }
     end
-
-    def _get_site_generation_test_options(options)
-      TestCase.site_generation_test_options.merge(options)
-    end
-
-    def self.site_generation_test_options
-      { clear_cache: true }
-    end
-
-    def self.site_generation_jekyll_options
-      {
-        'source'      => Dir.pwd,
-        'destination' => '_site'
-      }
-    end
   end
 end

data/test/unit/asset_bundle_test.rb

@@ -5,30 +5,29 @@ module Jekyll::Minibundle::Test
   class AssetBundleTest < TestCase
     def test_raise_exception_if_bundle_command_fails
       capture_io do
-        with_env('JEKYLL_MINIBUNDLE_CMD_JS' => 'false') do
-          err = assert_raises(RuntimeError) { make_bundle }
-          assert_equal 'Bundling js assets failed with exit status 1, command: false', err.to_s
-        end
+        err = assert_raises(RuntimeError) { make_bundle('false') }
+        assert_equal 'Bundling js assets failed with exit status 1, command: false', err.to_s
       end
     end
 
     def test_raise_exception_if_bundle_command_not_found
-      with_env('JEKYLL_MINIBUNDLE_CMD_JS' => 'no-such-jekyll-minibundle-cmd') do
-        assert_raises(Errno::ENOENT) { make_bundle }
-      end
+      assert_raises(Errno::ENOENT) { make_bundle('no-such-jekyll-minibundle-cmd') }
     end
 
     def test_raise_exception_if_bundle_command_not_configured
-      with_env('JEKYLL_MINIBUNDLE_CMD_JS' => nil) do
-        err = assert_raises(RuntimeError) { make_bundle }
-        assert_equal 'You need to set command for minification in $JEKYLL_MINIBUNDLE_CMD_JS', err.to_s
-      end
+      err = assert_raises(RuntimeError) { make_bundle(nil) }
+      assert_match(/\AMissing minification command for bundling js assets. Specify it in/, err.to_s)
     end
 
     private
 
-    def make_bundle
-      bundle = AssetBundle.new(:js, [site_fixture_path('_assets/scripts/dependency.js')], site_fixture_path)
+    def make_bundle(minifier_cmd)
+      bundle = AssetBundle.new(
+        type: :js,
+        asset_paths: [site_fixture_path('_assets/scripts/dependency.js')],
+        site_dir: site_fixture_path,
+        minifier_cmd: minifier_cmd
+      )
       bundle.make_bundle
     end
   end

data/test/unit/asset_file_registry_test.rb

@@ -35,7 +35,8 @@ module Jekyll::Minibundle::Test
         'source_dir'       => '_assets/styles',
         'assets'           => %w{dependency app},
         'destination_path' => 'assets/site',
-        'attributes'       => {}
+        'attributes'       => {},
+        'minifier_cmd'     => 'unused_minifier_cmd'
       }
     end
 

data/test/unit/asset_tag_markup_test.rb

@@ -5,9 +5,16 @@ module Jekyll::Minibundle::Test
   class AssetTagMarkupTest < TestCase
     def test_escapes_attribute_values
       attributes = { media: 'screen, projection', extra: '">attack<br' }
-      actual = AssetTagMarkup.make_markup(:css, 'http://localhost', attributes)
-      expected = %{<link rel="stylesheet" href="http://localhost" media="screen, projection" extra="&quot;&gt;attack&lt;br">}
+      actual = AssetTagMarkup.make_markup(:css, '/asset', attributes)
+      expected = %{<link rel="stylesheet" href="/asset" media="screen, projection" extra="&quot;&gt;attack&lt;br">}
       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

data/test/unit/bundle_file_test.rb

@@ -8,91 +8,85 @@ module Jekyll::Minibundle::Test
 
     def test_calling_markup_determines_fingerprint_and_destination_write
       with_fake_site do |site|
-        with_env('JEKYLL_MINIBUNDLE_CMD_JS' => cmd_to_remove_comments_and_count) do
-          bundle_file = BundleFile.new(site, bundle_config)
-          source = source_path(JS_BUNDLE_SOURCE_DIR, 'app.js')
-          old_destination = destination_path(JS_BUNDLE_DESTINATION_FINGERPRINT_PATH)
-          org_markup, last_markup = nil
-          capture_io { org_markup = bundle_file.destination_path_for_markup }
+        bundle_file = BundleFile.new(site, bundle_config(minifier_cmd_to_remove_comments_and_count))
+        source = source_path(JS_BUNDLE_SOURCE_DIR, 'app.js')
+        old_destination = destination_path(JS_BUNDLE_DESTINATION_FINGERPRINT_PATH)
+        org_markup, last_markup = nil
+        capture_io { org_markup = bundle_file.destination_path_for_markup }
 
-          assert bundle_file.write('_site')
+        assert bundle_file.write('_site')
 
-          org_mtime = mtime_of(old_destination)
+        org_mtime = mtime_of(old_destination)
 
-          assert_equal 1, get_cmd_count
+        assert_equal 1, get_minifier_cmd_count
 
-          last_markup = bundle_file.destination_path_for_markup
-          ensure_file_mtime_changes { File.write(source, '(function() {})()') }
+        last_markup = bundle_file.destination_path_for_markup
+        ensure_file_mtime_changes { File.write(source, '(function() {})()') }
 
-          # preserve fingerprint and content seen in last markup phase
-          refute bundle_file.write('_site')
-          assert_equal org_markup, last_markup
-          assert_equal org_mtime, mtime_of(old_destination)
-          assert_equal 1, get_cmd_count
+        # preserve fingerprint and content seen in last markup phase
+        refute bundle_file.write('_site')
+        assert_equal org_markup, last_markup
+        assert_equal org_mtime, mtime_of(old_destination)
+        assert_equal 1, get_minifier_cmd_count
 
-          capture_io { last_markup = bundle_file.destination_path_for_markup }
+        capture_io { last_markup = bundle_file.destination_path_for_markup }
 
-          assert bundle_file.write('_site')
+        assert bundle_file.write('_site')
 
-          new_destination = destination_path('assets/site-375a0b430b0c5555d0edd2205d26c04d.js')
+        new_destination = destination_path('assets/site-375a0b430b0c5555d0edd2205d26c04d.js')
 
-          # see updated fingerprint in the next round
-          refute_equal org_markup, last_markup
-          assert_operator mtime_of(new_destination), :>, org_mtime
-          assert_equal 2, get_cmd_count
-        end
+        # see updated fingerprint in the next round
+        refute_equal org_markup, last_markup
+        assert_operator mtime_of(new_destination), :>, org_mtime
+        assert_equal 2, get_minifier_cmd_count
       end
     end
 
     def test_many_consecutive_markup_calls_trigger_one_destination_write
       with_fake_site do |site|
-        with_env('JEKYLL_MINIBUNDLE_CMD_JS' => cmd_to_remove_comments_and_count) do
-          bundle_file = BundleFile.new(site, bundle_config)
-          source = source_path(JS_BUNDLE_SOURCE_DIR, 'app.js')
-          destination = destination_path(JS_BUNDLE_DESTINATION_FINGERPRINT_PATH)
-          org_markup, last_markup = nil
-          capture_io { org_markup = bundle_file.destination_path_for_markup }
-          bundle_file.destination_path_for_markup
+        bundle_file = BundleFile.new(site, bundle_config(minifier_cmd_to_remove_comments_and_count))
+        source = source_path(JS_BUNDLE_SOURCE_DIR, 'app.js')
+        destination = destination_path(JS_BUNDLE_DESTINATION_FINGERPRINT_PATH)
+        org_markup, last_markup = nil
+        capture_io { org_markup = bundle_file.destination_path_for_markup }
+        bundle_file.destination_path_for_markup
 
-          assert bundle_file.write('_site')
+        assert bundle_file.write('_site')
 
-          org_mtime = mtime_of(destination)
+        org_mtime = mtime_of(destination)
 
-          assert_equal 1, get_cmd_count
+        assert_equal 1, get_minifier_cmd_count
 
-          ensure_file_mtime_changes { FileUtils.touch(source) }
-          capture_io { last_markup = bundle_file.destination_path_for_markup }
-          bundle_file.destination_path_for_markup
+        ensure_file_mtime_changes { FileUtils.touch(source) }
+        capture_io { last_markup = bundle_file.destination_path_for_markup }
+        bundle_file.destination_path_for_markup
 
-          assert bundle_file.write('_site')
-          assert_equal org_markup, last_markup
-          assert_operator mtime_of(destination), :>, org_mtime
-          assert_equal 2, get_cmd_count
-        end
+        assert bundle_file.write('_site')
+        assert_equal org_markup, last_markup
+        assert_operator mtime_of(destination), :>, org_mtime
+        assert_equal 2, get_minifier_cmd_count
       end
     end
 
     def test_calling_write_before_destination_path_for_markup_has_no_effect
       with_fake_site do |site|
-        with_env('JEKYLL_MINIBUNDLE_CMD_JS' => cmd_to_remove_comments_and_count) do
-          bundle_file = BundleFile.new(site, bundle_config)
+        bundle_file = BundleFile.new(site, bundle_config(minifier_cmd_to_remove_comments_and_count))
 
-          refute bundle_file.write('_site')
-          assert_empty Dir[destination_path('assets/*.js')]
-          assert_equal 0, get_cmd_count
+        refute bundle_file.write('_site')
+        assert_empty Dir[destination_path('assets/*.js')]
+        assert_equal 0, get_minifier_cmd_count
 
-          capture_io { bundle_file.destination_path_for_markup }
+        capture_io { bundle_file.destination_path_for_markup }
 
-          assert bundle_file.write('_site')
-          assert File.exist?(destination_path(JS_BUNDLE_DESTINATION_FINGERPRINT_PATH))
-          assert_equal 1, get_cmd_count
-        end
+        assert bundle_file.write('_site')
+        assert File.exist?(destination_path(JS_BUNDLE_DESTINATION_FINGERPRINT_PATH))
+        assert_equal 1, get_minifier_cmd_count
       end
     end
 
     def test_to_liquid
       with_fake_site do |site|
-        hash = BundleFile.new(site, bundle_config).to_liquid
+        hash = BundleFile.new(site, bundle_config(minifier_cmd_to_remove_comments)).to_liquid
         assert_match(/jekyll-minibundle-js-/, hash['path'])
         refute_empty hash['modified_time']
       end
@@ -100,13 +94,14 @@ module Jekyll::Minibundle::Test
 
     private
 
-    def bundle_config
+    def bundle_config(minifier_cmd)
       {
-       'type'             => :js,
-       'source_dir'       => JS_BUNDLE_SOURCE_DIR,
-       'assets'           => %w{dependency app},
-       'destination_path' => JS_BUNDLE_DESTINATION_PATH,
-       'attributes'       => {}
+        'type'             => :js,
+        'source_dir'       => JS_BUNDLE_SOURCE_DIR,
+        'assets'           => %w{dependency app},
+        'destination_path' => JS_BUNDLE_DESTINATION_PATH,
+        'attributes'       => {},
+        'minifier_cmd'     => minifier_cmd
       }
     end
   end

data/test/unit/environment_test.rb

@@ -0,0 +1,38 @@
+require 'support/test_case'
+require 'jekyll/minibundle/environment'
+
+module Jekyll::Minibundle::Test
+  class EnvironmentTest < TestCase
+    def test_hash_traverse_returns_value_when_found
+      assert_equal 1, Environment.traverse_hash({top: {middle: {leaf: 1}}}, [:top, :middle, :leaf])
+      assert_equal({leaf: 1}, Environment.traverse_hash({top: {middle: {leaf: 1}}}, [:top, :middle]))
+    end
+
+    def test_hash_traverse_returns_nil_when_not_found
+      assert_nil Environment.traverse_hash({}, [:top, :no_such_leaf])
+      assert_nil Environment.traverse_hash({top: {}}, [:top, :no_such_leaf])
+      assert_nil Environment.traverse_hash({top: {leaf: 1}}, [:top, :no_such_leaf])
+    end
+
+    def test_find_site_config_returns_value_when_found
+      assert_equal 1, Environment.find_site_config(new_site(top: {leaf: 1}), [:top, :leaf], Integer)
+    end
+
+    def test_find_site_config_returns_nil_when_not_found
+      assert_nil Environment.find_site_config(new_site, [:top, :leaf], Integer)
+    end
+
+    def test_find_site_config_raises_exception_if_found_value_is_of_unexpected_type
+      err = assert_raises(RuntimeError) do
+        Environment.find_site_config(new_site(top: {leaf: '1'}), [:top, :leaf], Integer)
+      end
+      assert_equal 'Invalid site configuration for key top.leaf; expecting type Integer', err.to_s
+    end
+
+    private
+
+    def new_site(config = {})
+      OpenStruct.new(config: config)
+    end
+  end
+end

data/test/unit/jekyll_payload_test.rb

@@ -52,11 +52,12 @@ module Jekyll::Minibundle::Test
 
     def bundle_config
       {
-       'type'             => :js,
-       'source_dir'       => JS_BUNDLE_SOURCE_DIR,
-       'assets'           => %w{dependency app},
-       'destination_path' => JS_BUNDLE_DESTINATION_PATH,
-       'attributes'       => {}
+        'type'             => :js,
+        'source_dir'       => JS_BUNDLE_SOURCE_DIR,
+        'assets'           => %w{dependency app},
+        'destination_path' => JS_BUNDLE_DESTINATION_PATH,
+        'attributes'       => {},
+        'minifier_cmd'     => 'unused_minifier_cmd'
       }
     end
   end

data/test/unit/mini_bundle_block_test.rb

@@ -0,0 +1,13 @@
+require 'support/test_case'
+require 'jekyll/minibundle/mini_bundle_block'
+
+module Jekyll::Minibundle::Test
+  class MiniBundleBlockTest < TestCase
+    def test_raise_exception_if_no_type_argument
+      err = assert_raises(ArgumentError) do
+        Liquid::Template.parse("{% minibundle %} {% endminibundle %}")
+      end
+      assert_equal "No asset type for minibundle block; pass value such as 'css' or 'js' as the argument", err.to_s
+    end
+  end
+end

data/test/unit/mini_stamp_tag_test.rb

@@ -0,0 +1,31 @@
+require 'support/test_case'
+require 'support/fixture_config'
+require 'jekyll/minibundle/mini_stamp_tag'
+
+module Jekyll::Minibundle::Test
+  class MiniStampTagTest < TestCase
+    include FixtureConfig
+
+    def test_raise_exception_if_no_asset_source_argument
+      err = assert_raises(ArgumentError) do
+        Liquid::Template.parse("{% ministamp %}")
+      end
+      assert_equal "No asset source for ministamp tag; pass value such as '/_assets/site.css' as the first argument", err.to_s
+    end
+
+    def test_raise_exception_if_no_asset_destination_argument
+      err = assert_raises(ArgumentError) do
+        Liquid::Template.parse("{% ministamp /_assets/site.css %}")
+      end
+      assert_equal "No asset destination for ministamp tag; pass value such as '/assets/site.css' as the second argument", err.to_s
+    end
+
+    def test_ignore_rest_arguments
+      AssetFileRegistry.clear
+      template = Liquid::Template.parse("{% ministamp #{STAMP_SOURCE_PATH} #{STAMP_DESTINATION_PATH} rest %}")
+      context = {}
+      options = {registers: {site: new_fake_site(site_fixture_path)}}
+      assert_equal STAMP_DESTINATION_FINGERPRINT_PATH, template.render(context, options)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-minibundle
 version: !ruby/object:Gem::Version
-  version: 1.4.6
+  version: 1.5.0
 platform: ruby
 authors:
 - Tuomas Kareinen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-10 00:00:00.000000000 Z
+date: 2014-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jekyll
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -106,7 +106,6 @@ files:
 - test/fixture/site/_bin/with_count
 - test/fixture/site/_config.yml
 - test/fixture/site/_layouts/default.html
-- test/fixture/site/_plugins/minibundle.rb
 - test/fixture/site/_tmp/site.css
 - test/fixture/site/about.html
 - test/fixture/site/assets/site.css
@@ -122,8 +121,11 @@ files:
 - test/unit/asset_tag_markup_test.rb
 - test/unit/bundle_file_test.rb
 - test/unit/development_file_collection_test.rb
+- test/unit/environment_test.rb
 - test/unit/jekyll_payload_test.rb
 - test/unit/jekyll_static_file_api_test.rb
+- test/unit/mini_bundle_block_test.rb
+- test/unit/mini_stamp_tag_test.rb
 - test/unit/stamp_file_test.rb
 homepage: https://github.com/tkareine/jekyll-minibundle
 licenses:
@@ -150,7 +152,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.1
 signing_key: 
 specification_version: 4
 summary: A minimalistic asset bundling plugin for Jekyll
@@ -163,7 +165,6 @@ test_files:
 - test/fixture/site/_bin/with_count
 - test/fixture/site/_config.yml
 - test/fixture/site/_layouts/default.html
-- test/fixture/site/_plugins/minibundle.rb
 - test/fixture/site/_tmp/site.css
 - test/fixture/site/about.html
 - test/fixture/site/assets/site.css
@@ -179,6 +180,9 @@ test_files:
 - test/unit/asset_tag_markup_test.rb
 - test/unit/bundle_file_test.rb
 - test/unit/development_file_collection_test.rb
+- test/unit/environment_test.rb
 - test/unit/jekyll_payload_test.rb
 - test/unit/jekyll_static_file_api_test.rb
+- test/unit/mini_bundle_block_test.rb
+- test/unit/mini_stamp_tag_test.rb
 - test/unit/stamp_file_test.rb

data/test/fixture/site/_plugins/minibundle.rb

@@ -1 +0,0 @@
-require 'jekyll/minibundle'