jekyll_asset_pipeline 0.5.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6ecbca180339905b9bc06cf3490d19de5af2f5cc
+  data.tar.gz: 8e6fa3d8f9b9290228907c706a46946b05cf076d
+SHA512:
+  metadata.gz: 002b87529c6ba6c5409eba9c9e82696234aec6c009b0de5cf5cc69a38396f1b4222711d5e8646b79e68ec8675b8386b9b154c8d9586a462d9ada83b25b97d37a
+  data.tar.gz: 5f6bdaf8987879ec58ea81740d211df8520493a03372b4d5b1fa9b983f2b84bae0044099a79933bc558dc3b28400c2924b99db93109a4c89340e9510a8a093e7

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+## 0.4.1 (2017-12-08)
+
+* [#6]  __Test coverage increased to 100%__
+* [#35] __Updated rake dependency to 12.0__
+* [#34] __Fixed or mitigated all Rubocop offenses__
+* [#31] __Documented modules and classes__
+* [#29] Various README updates
+* [#28] Gemspec file updates (version dependencies and typos)
+* [#31] Fix random coverage jumps
+* [#33] Rescue StandardError instead of Exception
+* Removed CodeClimate integration
+
+## 0.4 (2017-12-03)
+
+* [#20] Support Jekyll 3.5, Liquid 4.0
+* [#25] Permit root level output of asset files
+* Fix and refactor to eliminate Rubocop offenses

data/LICENSE

@@ -0,0 +1,21 @@
+(The MIT License)
+
+Copyright (c) 2012 Matt Hodan (http://www.matthodan.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the 'Software'), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,377 @@
+# Jekyll Asset Pipeline
+
+[![Gem Version](https://badge.fury.io/rb/jekyll-asset-pipeline.png)](http://badge.fury.io/rb/jekyll-asset-pipeline)
+[![Build Status](https://travis-ci.org/matthodan/jekyll-asset-pipeline.svg?branch=master)](https://travis-ci.org/matthodan/jekyll-asset-pipeline)
+[![Coverage Status](https://coveralls.io/repos/matthodan/jekyll-asset-pipeline/badge.png?branch=master)](https://coveralls.io/r/matthodan/jekyll-asset-pipeline?branch=master)
+[![Dependency Status](https://gemnasium.com/matthodan/jekyll-asset-pipeline.png)](https://gemnasium.com/matthodan/jekyll-asset-pipeline)
+
+[Jekyll Asset Pipeline](http://www.matthodan.com/2012/11/22/jekyll-asset-pipeline.html) is a powerful asset pipeline that automatically collects, converts and compresses / minifies your site's JavaScript and CSS assets when you compile your [Jekyll](http://jekyllrb.com/) site.
+
+## Table of Contents
+
+- [Features](#features)
+- [How It Works](#how-it-works)
+- [Getting Started](#getting-started)
+- [Asset Preprocessing](#asset-preprocessing)
+  - [CoffeeScript](#coffeescript)
+  - [SASS / SCSS](#sass--scss)
+  - [LESS](#less)
+  - [Successive Preprocessing](#successive-preprocessing)
+- [Asset Compression](#asset-compression)
+  - [Yahoo's YUI Compressor](#yahoos-yui-compressor)
+  - [Google's Closure Compiler](#googles-closure-compiler)
+- [Templates](#templates)
+- [Configuration](#configuration)
+- [Octopress](#octopress)
+- [Contribute](#contribute)
+- [Community](#community)
+- [Credits](#credits)
+- [License](#license)
+
+## Features
+
+- Declarative dependency management via asset manifests
+- Asset preprocessing/conversion (supports [CoffeeScript](http://coffeescript.org/), [Sass / Scss](http://sass-lang.com/), [Less](http://lesscss.org/), [Erb](http://ruby-doc.org/stdlib-2.2.0/libdoc/erb/rdoc/ERB.html), etc.)
+- Asset compression (supports [YUI Compressor](http://yui.github.io/yuicompressor/), [Closure Compiler](https://developers.google.com/closure/compiler/), etc.)
+- Fingerprints bundled asset filenames with MD5 hashes for better browser caching
+- Automatic generation of HTML `link` and `script` tags that point to bundled assets
+- Integrates seamlessly into Jekyll's workflow, including auto site regeneration
+
+## How It Works
+
+Jekyll Asset Pipeline's workflow can be summarized as follows:
+
+1. Reviews site markup for instances of the `css_asset_tag` and `javascript_asset_tag` Liquid tags. Each occurrence of either of these tags identifies when a new bundle needs to be created and outlines (via a manifest) which assets to include in the bundle.
+2. Collects raw assets based on the manifest and runs them through converters / preprocessors (if necessary) to convert them into valid CSS or JavaScript.
+3. Combines the processed assets into a single bundle, compresses the bundled assets (if desired) and saves the compressed bundle to the `_site` output folder.
+4. Replaces `css_asset_tag` and `javascript_asset_tag` Liquid tags with HTML `link` and `script` tags, respectively, that link to the finished bundles.
+
+## Getting Started
+
+Jekyll Asset Pipeline is extremely easy to add to your Jekyll project and has no incremental dependencies beyond those required by Jekyll. Once you have a basic Jekyll site up and running, follow the steps below to install and configure Jekyll Asset Pipeline.
+
+1. Install the `jekyll-asset-pipeline` gem via [Rubygems](http://rubygems.org/).
+
+  ``` bash
+  $ gem install jekyll-asset-pipeline
+  ```
+
+  If you are using [Bundler](http://gembundler.com/) to manage your project's gems, you can just add `jekyll-asset-pipeline` to your Gemfile and run `bundle install`.
+
+2. Add a `_plugins` folder to your project if you do not already have one. Within the `_plugins` folder, add a file named `jekyll_asset_pipeline.rb` with the following require statement as its contents.
+
+  ``` ruby
+  require 'jekyll_asset_pipeline'
+  ```
+
+3. Move your assets into a Jekyll ignored folder (i.e. a folder that begins with an underscore `_`) so that Jekyll won't include these raw assets in the site output. It is recommended to use an `_assets` folder to hold your site's assets.
+
+4. Add the following [Liquid](http://liquidmarkup.org/) blocks to your site's HTML `head` section. These blocks will be converted into HTML `link` and `script` tags that point to bundled assets. Within each block is a manifest of assets to include in the bundle. Assets are included in the same order that they are listed in the manifest. Replace the `foo` and `bar` assets with your site's assets. At this point we are just using plain old javascript and css files (hence the `.js` and `.css` extensions). See the [Asset Preprocessing](#asset-preprocessing) section to learn how to include files that must be preprocessed (e.g. CoffeeScript, Sass, Less, Erb, etc.). Name the bundle by including a string after the opening tag. We've named our bundles "global" in the below example.
+
+  ``` html
+  {% css_asset_tag global %}
+  - /_assets/foo.css
+  - /_assets/bar.css
+  {% endcss_asset_tag %}
+
+  {% javascript_asset_tag global %}
+  - /_assets/foo.js
+  - /_assets/bar.js
+  {% endjavascript_asset_tag %}
+  ```
+  Asset manifests must be formatted as YAML arrays and include full paths to each asset from the root of the project. YAML [does not allow tabbed markup](http://www.yaml.org/faq.html), so you must use spaces when indenting your YAML manifest or you will get an error when you compile your site. If you are using assets that must be preprocessed, you should append the appropriate extension (e.g. '.js.coffee', '.css.less') as discussed in the [Asset Preprocessing](#asset-preprocessing) section.
+
+5. Run the `jekyll build` command to compile your site. You should see an output that includes the following Jekyll Asset Pipeline status messages.
+
+  ``` bash
+  $ jekyll build
+  Generating...
+  Asset Pipeline: Processing 'css_asset_tag' manifest 'global'
+  Asset Pipeline: Saved 'global-md5hash.css' to 'yoursitepath/assets'
+  Asset Pipeline: Processing 'javascript_asset_tag' manifest 'global'
+  Asset Pipeline: Saved 'global-md5hash.js' to 'yoursitepath/assets'
+  ```
+
+  If you do not see these messages, check that you have __not__ set Jekyll's `safe` option to `true` in your site's `_config.yml`. If the `safe` option is set to `true`, Jekyll will not run plugins.
+
+That is it! You should now have bundled assets. Look in the `_site` folder of your project for an `assets` folder that contains the bundled assets. HTML tags that point to these assets have been placed in the HTML output where you included the Liquid blocks. *You may notice that your assets have not been converted or compressed-- we will add that functionality next.*
+
+## Asset Preprocessing
+
+Asset preprocessing (i.e. conversion) allows us to write our assets in languages such as [CoffeeScript](http://coffeescript.org/), [Sass](http://sass-lang.com/), [Less](http://lesscss.org/), [Erb](http://ruby-doc.org/stdlib-1.9.3/libdoc/erb/rdoc/ERB.html) or any other language. One of Jekyll Asset Pipeline's key strengths is that it works with __any__ preprocessing library that has a ruby wrapper. Adding a preprocessor is straightforward, but requires a small amount of additional code.
+
+In the following example, we will add a preprocessor that converts CoffeeScript into JavaScript.
+
+### CoffeeScript
+
+1. In the `jekyll_asset_pipeline.rb` file that we created in the [Getting Started](#getting-started) section, add the following code to the end of the file (i.e. after the `require` statement).
+
+  ``` ruby
+  module JekyllAssetPipeline
+    class CoffeeScriptConverter < JekyllAssetPipeline::Converter
+      require 'coffee-script'
+
+      def self.filetype
+        '.coffee'
+      end
+
+      def convert
+        return CoffeeScript.compile(@content)
+      end
+    end
+  end
+  ```
+
+  The above code adds a CoffeeScript converter. You can name a converter anything as long as it inherits from `JekyllAssetPipeline::Converter`. The `self.filetype` method defines the type of asset a converter will process (e.g. `.coffee` for CoffeeScript) based on the extension of the raw asset file. A `@content` instance variable that contains the raw content of our asset is made available within the converter. The converter should process this content and return the processed content (as a string) via a `convert` method.
+
+2. If you haven't already, you should now install any dependancies that are required by your converter. In our case, we need to install the `coffee-script` gem.
+
+  ``` bash
+  $ gem install coffee-script
+  ```
+
+  If you are using [Bundler](http://gembundler.com/) to manage your project's gems, you can just add `coffee-script` to your Gemfile and run `bundle install`.
+
+3. Append a `.coffee` extension to the filename of any asset that should be converted with the `CoffeeScriptConverter`. For example, `foo.js` would become `foo.js.coffee`.
+
+4. Run the `jekyll build` command to compile your site.
+
+That is it! Your asset pipeline has converted any CoffeeScript assets into JavaScript before adding them to a bundle.
+
+### SASS / SCSS
+
+You probably get the gist of how converters work, but here's an example of a SASS converter for quick reference.
+
+``` ruby
+module JekyllAssetPipeline
+  class SassConverter < JekyllAssetPipeline::Converter
+    require 'sass'
+
+    def self.filetype
+      '.scss'
+    end
+
+    def convert
+      return Sass::Engine.new(@content, syntax: :scss).render
+    end
+  end
+end
+```
+
+Don't forget to install the `sass` gem or add it to your Gemfile and run `bundle install` before you run the `jekyll build` command since the above SASS converter requires the `sass` library as a dependency.
+
+If you're using `@import` statements in your SASS files, you'll probably need to specify a base load path to the SASS engine in your `convert` method.
+You can use the `@dirname` instance variable for this, which contains the path to the current asset's directory:
+
+``` ruby
+...
+def convert
+  return Sass::Engine.new(@content, syntax: :scss, load_paths: [@dirname]).render
+end
+...
+```
+
+### LESS
+
+``` ruby
+module JekyllAssetPipeline
+  class LessConverter < JekyllAssetPipeline::Converter
+    require 'less'
+
+    def self.filetype
+      '.less'
+    end
+
+    def convert
+      return Less::Parser.new.parse(@content).to_css
+    end
+  end
+end
+```
+
+Don't forget to install the `less` gem or add it to your Gemfile and run `bundle install` before you run the `jekyll build` command since the above LESS converter requires the `less` library as a dependency.
+
+As with the SASS convertor, you'll probably need to specify a base load path and pass that to the LESS Parser:
+
+``` ruby
+...
+def convert
+  return Less::Parser.new(paths: [@dirname]).parse(@content).to_css
+end
+...
+```
+
+### Successive Preprocessing
+
+If you would like to run an asset through multiple preprocessors successively, you can do so by naming your assets with nested file extensions. Nest the extensions in the order (right to left) that the asset should be processed. For example, `.css.scss.erb` would first be processed by an `erb` preprocessor then by a `scss` preprocessor before being rendered. This convention is very similar to the convention used by the [Ruby on Rails asset pipeline](http://guides.rubyonrails.org/asset_pipeline.html#preprocessing).
+
+Don't forget to define preprocessors for the extensions you use in your filenames, otherwise Jekyll Asset Pipeline will not process your asset.
+
+## Asset Compression
+
+Asset compression allows us to decrease the size of our assets and increase the speed of our site. One of Jekyll Asset Pipeline's key strengths is that it works with __any__ compression library that has a ruby wrapper. Adding asset compression is straightforward, but requires a small amount of additional code.
+
+In the following example, we will add a compressor that uses Yahoo's YUI Compressor to compress our CSS and JavaScript assets.
+
+### Yahoo's YUI Compressor
+
+1. In the `jekyll_asset_pipeline.rb` file that we created in the [Getting Started](#getting-started) section, add the following code to the end of the file (i.e. after the `require` statement).
+
+  ``` ruby
+  module JekyllAssetPipeline
+    class CssCompressor < JekyllAssetPipeline::Compressor
+      require 'yui/compressor'
+
+      def self.filetype
+        '.css'
+      end
+
+      def compress
+        return YUI::CssCompressor.new.compress(@content)
+      end
+    end
+
+    class JavaScriptCompressor < JekyllAssetPipeline::Compressor
+      require 'yui/compressor'
+
+      def self.filetype
+        '.js'
+      end
+
+      def compress
+        return YUI::JavaScriptCompressor.new(munge: true).compress(@content)
+      end
+    end
+  end
+  ```
+
+  The above code adds a CSS and a JavaScript compressor. You can name a compressor anything as long as it inherits from `JekyllAssetPipeline::Compressor`. The `self.filetype` method defines the type of asset a compressor will process (either `'.js'` or `'.css'`). The `compress` method is where the magic happens. A `@content` instance variable that contains the raw content of our bundle is made available within the compressor. The compressor should process this content and return the processed content (as a string) via a `compress` method.
+
+2. If you haven't already, you should now install any dependencies that are required by your compressor. In our case, we need to install the `yui-compressor` gem.
+
+  ``` bash
+  $ gem install yui-compressor
+  ```
+
+  If you are using [Bundler](http://gembundler.com/) to manage your project's gems, you can just add `yui-compressor` to your Gemfile and run `bundle install`.
+
+3. Run the `jekyll build` command to compile your site.
+
+That is it! Your asset pipeline has compressed your CSS and JavaScript assets. You can verify that this is the case by looking at the contents of the bundles generated in the `_site/assets` folder of your project.
+
+### Google's Closure Compiler
+
+You probably get the gist of how compressors work, but here's an example of a Google Closure Compiler compressor for quick reference.
+
+``` ruby
+class JavaScriptCompressor < JekyllAssetPipeline::Compressor
+  require 'closure-compiler'
+
+  def self.filetype
+    '.js'
+  end
+
+  def compress
+    return Closure::Compiler.new.compile(@content)
+  end
+end
+```
+
+Don't forget to install the `closure-compiler` gem before you run the `jekyll build` command since the above compressor requires the `closure-compiler` library as a dependency.
+
+## Templates
+
+When Jekyll Asset Pipeline creates a bundle, it returns an HTML tag that points to the bundle. This tag is either a `link` tag for CSS or a `script` tag for JavaScript. Under most circumstances the default tags will suffice, but you may want to customize this output for special cases (e.g. if you want to add a CSS media attribute).
+
+In the following example, we will override the default CSS link tag by adding a custom template that produces a link tag with a `media` attribute.
+
+1. In the `jekyll_asset_pipeline.rb` file that we created in the [Getting Started](#getting-started) section, add the following code.
+
+  ``` ruby
+  module JekyllAssetPipeline
+    class CssTagTemplate < JekyllAssetPipeline::Template
+      def self.filetype
+        '.css'
+      end
+
+      def html
+        "<link href='#{output_path}/#{@filename}' rel='stylesheet' " \
+          "type='text/css' media='screen' />\n"
+      end
+    end
+  end
+  ```
+
+  If you already added a compressor and/or a converter, you can include your template class alongside your compressor and/or converter within the same Jekyll Asset Pipeline module.
+
+  The “self.filetype” method defines the type of bundle a template will target (either `.js` or `.css`). The “html” method is where the magic happens. `output_path` is a helper method and `@filename` is an instance variable which are available within the class and contain the path and filename of the generated bundle, respectively. The template should return a string that contains an HTML tag pointing to the generated bundle via an `html` method.
+
+2. Run the `jekyll` command to compile your site.
+
+That is it! Your asset pipeline used your template to generate an HTML `link` tag that includes a media attribute with the value `screen`. You can verify that this is the case by viewing the generated source within your project's `_site` folder.
+
+## Configuration
+
+Jekyll Asset Pipeline provides the following configuration options that can be controlled by adding them to your project's `_config.yml` file. If you don't have a `_config.yml` file, consider reading the [configuration section](https://github.com/mojombo/jekyll/wiki/Configuration) of the Jekyll documentation.
+
+``` yaml
+asset_pipeline:
+  bundle: true
+  compress: true
+  output_path: assets
+  display_path: nil
+  gzip: false
+```
+
+Setting        | Default  | Description
+---------------|----------|-----------------------------------------------------
+`bundle`       | `true`   | controls whether Jekyll Asset Pipeline bundles the assets defined in each manifest. If set to `false`, each asset will be saved individually and individual html tags pointing to each unbundled asset will be produced when you compile your site. It is useful to set this to `false` while you are debugging your site.
+`compress`     | `true`   | tells Jekyll Asset Pipeline whether or not to compress the bundled assets. It is useful to set this setting to `false` while you are debugging your site.
+`output_path`  | `assets` | defines where generated bundles should be saved within the `_site` folder of your project.
+`display_path` | `nil`    | overrides the path to assets in generated html tags. This is useful if you are hosting your site at a path other than the root of your domain (e.g. `http://example.com/blog/`).
+`gzip`         | `false`  | controls whether Jekyll Asset Pipeline saves gzipped versions of your assets alongside un-gzipped versions.
+
+
+## Octopress
+
+[Octopress](http://octopress.org/) is a popular framework for Jekyll that can help you get a blog up and running quickly. Jekyll Asset Pipeline can be added to an Octopress site using the [Getting Started](#getting-started) steps above with the following modifications:
+
+1. Octopress uses Bundler to manage your site's dependencies. You should add `gem jekyll-asset-pipeline` to your Gemfile and then run `bundle install` to install.
+
+2. Instead of adding a `_plugins` folder, you should put `jekyll_asset_pipeline.rb` in the `plugins` folder included by default in the root of your Octopress site.
+
+3. You should still store your assets in an Jekyll ignored folder (i.e. a folder that begins with an underscore `_`), but note that this folder should be located within the `source` folder of your Octopress site (e.g. `source/_assets`).
+
+4. No change to this step.
+
+5. Instead of running the `jekyll` command to compile your site, you should use Octopress' rake commands (e.g. `rake generate`) as outlined [here](http://octopress.org/docs/blogging/).
+
+If you have any difficulties using Jekyll Asset Pipeline with Octopress, please [open an issue](http://github.com/matthodan/jekyll-asset-pipeline/issues).
+
+## Contribute
+
+You can contribute to the Jekyll Asset Pipeline by submitting a pull request [via GitHub](https://github.com/matthodan/jekyll-asset-pipeline). There are a few areas that need improvement:
+
+- __Tests, tests, tests.__ **This project is now fully tested.**
+- __Successive preprocessing.__ Currently you can only preprocess a file once. It would be better if you could run an asset through multiple preprocessors before it gets compressed and bundled. **As of v0.1.0, Jekyll Asset Pipeline now supports successive preprocessing.**
+- __Handle remote assets.__ Right now, Jekyll Asset Pipeline does not provide any way to include remote assets in bundles unless you save them locally before generating your site. Moshen's [Jekyll Asset Bundler](https://github.com/moshen/jekyll-asset_bundler) allows you to include remote assets, which is pretty interesting. That said, it is generally better to keep remote assets separate so that they load asynchronously.
+
+If you have any ideas or you would like to see anything else improved please use the [issues section](https://github.com/matthodan/jekyll-asset-pipeline/issues).
+
+## Changelog
+
+See [the changelog](CHANGELOG.md).
+
+## Community
+
+- Here is [GitHub's list of projects that use the gem](https://github.com/matthodan/jekyll-asset-pipeline/network/dependents).
+- Here is a currated list of [sites that use Jekyll Asset Pipeline](http://github.com/matthodan/jekyll-asset-pipeline/wiki/Sites-that-use-Jekyll-Asset-Pipeline). Feel free to add your site to the list if you want.
+
+## Credits
+
+* [Moshen](https://github.com/moshen/) for creating the [Jekyll Asset Bundler](https://github.com/moshen/jekyll-asset_bundler).
+* [Mojombo](https://github.com/mojombo) for creating [Jekyll](https://github.com/mojombo/jekyll) in the first place.
+
+## License
+
+Jekyll Asset Pipeline is released under the [MIT License](http://opensource.org/licenses/MIT).

data/lib/jekyll_asset_pipeline.rb

@@ -0,0 +1,57 @@
+# Stdlib dependencies
+require 'digest/md5'
+require 'fileutils'
+require 'time'
+require 'yaml'
+require 'zlib'
+
+# Third-party dependencies
+require 'jekyll'
+require 'liquid'
+
+# Jekyll extensions
+require 'jekyll_asset_pipeline/extensions/jekyll/site_extensions'
+require 'jekyll_asset_pipeline/extensions/jekyll/site'
+
+# Liquid extensions
+require 'jekyll_asset_pipeline/extensions/liquid/liquid_block_extensions'
+require 'jekyll_asset_pipeline/extensions/liquid/asset_tag'
+require 'jekyll_asset_pipeline/extensions/liquid/asset_tags/css_asset_tag'
+# rubocop:disable LineLength
+require 'jekyll_asset_pipeline/extensions/liquid/asset_tags/javascript_asset_tag'
+# rubocop:enable LineLength
+
+# Ruby extensions
+require 'jekyll_asset_pipeline/extensions/ruby/subclass_tracking'
+
+# Jekyll Asset Pipeline
+require 'jekyll_asset_pipeline/version'
+require 'jekyll_asset_pipeline/asset'
+require 'jekyll_asset_pipeline/converter'
+require 'jekyll_asset_pipeline/compressor'
+require 'jekyll_asset_pipeline/templates/template_helper'
+require 'jekyll_asset_pipeline/template'
+require 'jekyll_asset_pipeline/templates/javascript_tag_template'
+require 'jekyll_asset_pipeline/templates/css_tag_template'
+require 'jekyll_asset_pipeline/pipeline'
+
+module JekyllAssetPipeline
+  # Default configuration settings for Jekyll Asset Pipeline
+  # Strings used for keys to play nice when merging with _config.yml
+  #
+  # 'output_path'  Destination for bundle file (within the '_site' directory)
+  # 'display_path' Optional.  Override path to assets for output HTML refs
+  # 'staging_path' Destination for staged assets (within project root directory)
+  # 'bundle'       true = Bundle assets, false = Leave assets unbundled
+  # 'compress'     true = Minify assets, false = Leave assets unminified
+  # 'gzip'         true = Create gzip versions,
+  #                false = Do not create gzip versions
+  DEFAULTS = {
+    'output_path'   => 'assets',
+    'display_path'  => nil,
+    'staging_path'  => '.asset_pipeline',
+    'bundle'        => true,
+    'compress'      => true,
+    'gzip'          => false
+  }.freeze
+end

data/lib/jekyll_asset_pipeline/asset.rb

@@ -0,0 +1,12 @@
+module JekyllAssetPipeline
+  # Holds an asset (file)
+  class Asset
+    def initialize(content, filename, dirname = '.')
+      @content = content
+      @filename = filename
+      @dirname = dirname
+    end
+
+    attr_accessor :content, :filename, :dirname, :output_path
+  end
+end

data/lib/jekyll_asset_pipeline/compressor.rb

@@ -0,0 +1,30 @@
+module JekyllAssetPipeline
+  # Base class for asset compressors
+  # See https://github.com/matthodan/jekyll-asset-pipeline#asset-compression
+  class Compressor
+    extend JekyllAssetPipeline::SubclassTracking
+
+    def initialize(content)
+      @content = content
+      @compressed = compress
+    end
+
+    # Returns compressed content
+    attr_reader :compressed
+
+    # Filetype to process (e.g. '.js')
+    def self.filetype
+      ''
+    end
+
+    # Logic to compress assets
+    #
+    # Available instance variables:
+    # @content    Content to be compressed
+    #
+    # Returns compressed string
+    def compress
+      @content
+    end
+  end
+end

data/lib/jekyll_asset_pipeline/converter.rb

@@ -0,0 +1,40 @@
+module JekyllAssetPipeline
+  # Base class for asset converters
+  # See https://github.com/matthodan/jekyll-asset-pipeline#asset-preprocessing
+  class Converter
+    extend JekyllAssetPipeline::SubclassTracking
+
+    def initialize(asset)
+      @content = asset.content
+      @type = File.extname(asset.filename).downcase
+      @dirname = asset.dirname
+      @converted = convert
+    end
+
+    attr_reader :converted
+
+    # Filetype to process (e.g. '.coffee')
+    def self.filetype
+      ''
+    end
+
+    # Finds a converter class based on a filename
+    def self.klass(filename)
+      JekyllAssetPipeline::Converter.subclasses.select do |c|
+        c.filetype == File.extname(filename).downcase
+      end.last
+    end
+
+    # Logic to convert assets
+    #
+    # Available instance variables:
+    # @file       File to be converted
+    # @content    Contents of @file as a string
+    # @type       Filetype of file (e.g. '.coffee')
+    #
+    # Returns converted string
+    def convert
+      @content
+    end
+  end
+end

data/lib/jekyll_asset_pipeline/extensions/jekyll/site.rb

@@ -0,0 +1,7 @@
+module Jekyll
+  # Contains overrides for the needed Jekyll:Site methods
+  # The actual code is in JekyllAssetPipeline::JekyllSiteExtensions
+  class Site
+    include JekyllAssetPipeline::JekyllSiteExtensions
+  end
+end

data/lib/jekyll_asset_pipeline/extensions/jekyll/site_extensions.rb

@@ -0,0 +1,38 @@
+module JekyllAssetPipeline
+  # Contains overrides for the needed Jekyll:Site methods
+  # Included in Jekyll::Site
+  module JekyllSiteExtensions
+    def self.included(base)
+      base.class_eval do
+        # Store the original Jekyll::Site#cleanup method
+        old_cleanup_method = instance_method(:cleanup)
+
+        # Override Jekyll::Site#cleanup
+        define_method(:cleanup) do
+          # Run the Jekyll::Site#cleanup method
+          original_return_val = old_cleanup_method.bind(self).call
+
+          # Clear Jekyll Asset Pipeline cache
+          Pipeline.clear_cache
+
+          original_return_val
+        end
+
+        # Store the original Jekyll::Site#write method
+        old_write_method = instance_method(:write)
+
+        # Override Jekyll::Site#write
+        define_method(:write) do
+          # Run the Jekyll::Site#write method
+          original_return_value = old_write_method.bind(self).call
+
+          # Clear Jekyll Asset Pipeline staged assets
+          config = self.config['asset_pipeline'] || {}
+          Pipeline.remove_staged_assets(source, config)
+
+          original_return_value
+        end
+      end
+    end
+  end
+end

data/lib/jekyll_asset_pipeline/extensions/liquid/asset_tag.rb

@@ -0,0 +1,9 @@
+module JekyllAssetPipeline
+  # This is a Liquid tag block extension
+  # See documentation here:
+  # https://github.com/Shopify/liquid/wiki/liquid-for-programmers#create-your-own-tag-blocks
+  class AssetTag < ::Liquid::Block
+    extend JekyllAssetPipeline::LiquidBlockExtensions::ClassMethods
+    include JekyllAssetPipeline::LiquidBlockExtensions
+  end
+end

data/lib/jekyll_asset_pipeline/extensions/liquid/asset_tags/css_asset_tag.rb

@@ -0,0 +1,21 @@
+# This comment is needed, otherwise Rubocop complains because of the
+# register_tag below and a verbose comment is better than a :nodoc: :)
+module JekyllAssetPipeline
+  # css_asset_tag Liquid block
+  # See JekyllAssetPipeline::AssetTag and
+  # JekyllAssetPipeline::LiquidBlockExtensions
+  class CssAssetTag < JekyllAssetPipeline::AssetTag
+    def self.tag_name
+      'css_asset_tag'
+    end
+
+    def self.output_type
+      '.css'
+    end
+  end
+
+  # Register CssAssetTag tag with Liquid
+  ::Liquid::Template
+    .register_tag(JekyllAssetPipeline::CssAssetTag.tag_name,
+                  JekyllAssetPipeline::CssAssetTag)
+end

data/lib/jekyll_asset_pipeline/extensions/liquid/asset_tags/javascript_asset_tag.rb

@@ -0,0 +1,21 @@
+# This comment is needed, otherwise Rubocop complains because of the
+# register_tag below and a verbose comment is better than a :nodoc: :)
+module JekyllAssetPipeline
+  # javascript_asset_tag Liquid block
+  # See JekyllAssetPipeline::AssetTag and
+  # JekyllAssetPipeline::LiquidBlockExtensions
+  class JavaScriptAssetTag < JekyllAssetPipeline::AssetTag
+    def self.tag_name
+      'javascript_asset_tag'
+    end
+
+    def self.output_type
+      '.js'
+    end
+  end
+
+  # Register JavaScriptAssetTag tag with Liquid
+  ::Liquid::Template
+    .register_tag(JekyllAssetPipeline::JavaScriptAssetTag.tag_name,
+                  JekyllAssetPipeline::JavaScriptAssetTag)
+end

data/lib/jekyll_asset_pipeline/extensions/liquid/liquid_block_extensions.rb

@@ -0,0 +1,52 @@
+module JekyllAssetPipeline
+  # Helper module used by JekyllAssetPipeline::AssetTag as well as
+  # classed derived from it (Liquid tag block extensions)
+  # See documentation here:
+  # https://github.com/Shopify/liquid/wiki/liquid-for-programmers#create-your-own-tag-blocks
+  module LiquidBlockExtensions
+    # Unsurprisingly, class methods
+    module ClassMethods
+      def output_type
+        ''
+      end
+
+      def tag_name
+        ''
+      end
+    end
+
+    def render(context)
+      site = context.registers[:site]
+      config = site.config.fetch('asset_pipeline', {})
+
+      # Run Jekyll Asset Pipeline
+      pipeline, cached = run_pipeline(site, config)
+
+      return nil unless pipeline.is_a?(Pipeline)
+
+      # Prevent Jekyll from cleaning up saved assets if new pipeline
+      preserve_assets(site, config, pipeline) unless cached
+
+      # Return HTML tag pointing to asset
+      pipeline.html
+    end
+
+    private
+
+    def run_pipeline(site, config)
+      Pipeline.run(nodelist.first, @markup.strip, site.source, site.dest,
+                   self.class.tag_name, self.class.output_type, config)
+    end
+
+    def preserve_assets(site, config, pipeline)
+      pipeline.assets.each do |asset|
+        config = JekyllAssetPipeline::DEFAULTS.merge(config)
+        staging_path = File.expand_path(File.join(site.source,
+                                                  config['staging_path']))
+        site.static_files << Jekyll::StaticFile.new(site, staging_path,
+                                                    asset.output_path,
+                                                    asset.filename)
+      end
+    end
+  end
+end

data/lib/jekyll_asset_pipeline/extensions/ruby/subclass_tracking.rb

@@ -0,0 +1,15 @@
+module JekyllAssetPipeline
+  # Allows classes that extend this to return an array of their subclasses
+  module SubclassTracking
+    # Record subclasses of this class (this method is automatically called by
+    # ruby)
+    def inherited(base)
+      subclasses << base
+    end
+
+    # Return an array of classes that are subclasses of this object
+    def subclasses
+      @subclasses ||= []
+    end
+  end
+end

data/lib/jekyll_asset_pipeline/pipeline.rb

@@ -0,0 +1,250 @@
+module JekyllAssetPipeline
+  # The pipeline itself, the run method is where it all happens
+  # rubocop:disable ClassLength
+  class Pipeline
+    # rubocop:enable ClassLength
+    class << self
+      # Generate hash based on manifest
+      def hash(source, manifest, options = {})
+        options = DEFAULTS.merge(options)
+        begin
+          Digest::MD5.hexdigest(YAML.safe_load(manifest).map! do |path|
+            "#{path}#{File.mtime(File.join(source, path)).to_i}"
+          end.join.concat(options.to_s))
+        rescue StandardError => se
+          puts "Failed to generate hash from provided manifest: #{se.message}"
+          raise se
+        end
+      end
+
+      # Run the pipeline
+      # This is called from JekyllAssetPipeline::LiquidBlockExtensions.render
+      # or, to be more precise, from JekyllAssetPipeline::CssAssetTag.render and
+      # JekyllAssetPipeline::JavaScriptAssetTag.render
+      # rubocop:disable ParameterLists
+      def run(manifest, prefix, source, destination, tag, type, config)
+        # rubocop:enable ParameterLists
+        # Get hash for pipeline
+        hash = hash(source, manifest, config)
+
+        # Check if pipeline has been cached
+        return cache[hash], true if cache.key?(hash)
+
+        begin
+          puts "Processing '#{tag}' manifest '#{prefix}'"
+          pipeline = new(manifest, prefix, source, destination, type, config)
+          process_pipeline(hash, pipeline)
+        rescue StandardError => se
+          # Add exception to cache
+          cache[hash] = se
+
+          # Re-raise the exception
+          raise se
+        end
+      end
+
+      # Cache processed pipelines
+      def cache
+        @cache ||= {}
+      end
+
+      # Empty cache
+      def clear_cache
+        @cache = {}
+      end
+
+      # Remove staged assets
+      def remove_staged_assets(source, config)
+        config = DEFAULTS.merge(config)
+        staging_path = File.join(source, config['staging_path'])
+        FileUtils.rm_rf(staging_path)
+      end
+
+      # Add prefix to output
+      def puts(message)
+        $stdout.puts("Asset Pipeline: #{message}")
+      end
+
+      private
+
+      def process_pipeline(hash, pipeline)
+        pipeline.assets.each do |asset|
+          puts "Saved '#{asset.filename}' to " \
+            "'#{pipeline.destination}/#{asset.output_path}'"
+        end
+
+        # Add processed pipeline to cache
+        cache[hash] = pipeline
+
+        # Return newly processed pipeline and cached status
+        [pipeline, false]
+      end
+    end
+
+    # Initialize new pipeline
+    # rubocop:disable ParameterLists
+    def initialize(manifest, prefix, source, destination, type, options = {})
+      # rubocop:enable ParameterLists
+      @manifest = manifest
+      @prefix = prefix
+      @source = source
+      @destination = destination
+      @type = type
+      @options = JekyllAssetPipeline::DEFAULTS.merge(options)
+
+      process
+    end
+
+    attr_reader :assets, :html, :destination
+
+    private
+
+    # Process the pipeline
+    def process
+      collect
+      convert
+      bundle if @options['bundle']
+      compress if @options['compress']
+      gzip if @options['gzip']
+      save
+      markup
+    end
+
+    # Collect assets based on manifest
+    def collect
+      @assets = YAML.safe_load(@manifest).map! do |path|
+        full_path = File.join(@source, path)
+        File.open(File.join(@source, path)) do |file|
+          JekyllAssetPipeline::Asset.new(file.read, File.basename(path),
+                                         File.dirname(full_path))
+        end
+      end
+    rescue StandardError => se
+      puts 'Asset Pipeline: Failed to load assets from provided ' \
+           "manifest: #{se.message}"
+      raise se
+    end
+
+    # Convert assets based on the file extension if converter is defined
+    def convert
+      @assets.each do |asset|
+        # Convert asset multiple times if more than one converter is found
+        finished = false
+        while finished == false
+          # Find a converter to use
+          klass = JekyllAssetPipeline::Converter.klass(asset.filename)
+
+          # Convert asset if converter is found
+          if klass.nil?
+            finished = true
+          else
+            convert_asset(klass, asset)
+          end
+        end
+      end
+    end
+
+    # Convert an asset with a given converter class
+    def convert_asset(klass, asset)
+      # Convert asset content
+      converter = klass.new(asset)
+
+      # Replace asset content and filename
+      asset.content = converter.converted
+      asset.filename = File.basename(asset.filename, '.*')
+
+      # Add back the output extension if no extension left
+      if File.extname(asset.filename) == ''
+        asset.filename = "#{asset.filename}#{@type}"
+      end
+    rescue StandardError => se
+      puts "Asset Pipeline: Failed to convert '#{asset.filename}' " \
+           "with '#{klass}': #{se.message}"
+      raise se
+    end
+
+    # Bundle multiple assets into a single asset
+    def bundle
+      content = @assets.map(&:content).join("\n")
+
+      hash = JekyllAssetPipeline::Pipeline.hash(@source, @manifest, @options)
+      @assets = [
+        JekyllAssetPipeline::Asset.new(content, "#{@prefix}-#{hash}#{@type}")
+      ]
+    end
+
+    # Compress assets if compressor is defined
+    def compress
+      @assets.each do |asset|
+        # Find a compressor to use
+        klass = JekyllAssetPipeline::Compressor.subclasses.select do |c|
+          c.filetype == @type
+        end.last
+
+        break unless klass
+
+        begin
+          asset.content = klass.new(asset.content).compressed
+        rescue StandardError => se
+          puts "Asset Pipeline: Failed to compress '#{asset.filename}' " \
+               "with '#{klass}': #{se.message}"
+          raise se
+        end
+      end
+    end
+
+    # Create Gzip versions of assets
+    def gzip
+      @assets.map! do |asset|
+        gzip_content = Zlib::Deflate.deflate(asset.content)
+        [
+          asset,
+          JekyllAssetPipeline::Asset
+            .new(gzip_content, "#{asset.filename}.gz", asset.dirname)
+        ]
+      end.flatten!
+    end
+
+    # Save assets to file
+    def save
+      output_path = @options['output_path']
+      staging_path = @options['staging_path']
+
+      @assets.each do |asset|
+        directory = File.join(@source, staging_path, output_path)
+        write_asset_file(directory, asset)
+
+        # Store output path of saved file
+        asset.output_path = output_path
+      end
+    end
+
+    # Write asset file to disk
+    def write_asset_file(directory, asset)
+      FileUtils.mkpath(directory) unless File.directory?(directory)
+      begin
+        # Save file to disk
+        File.open(File.join(directory, asset.filename), 'w') do |file|
+          file.write(asset.content)
+        end
+      rescue StandardError => se
+        puts "Asset Pipeline: Failed to save '#{asset.filename}' to " \
+             "disk: #{se.message}"
+        raise se
+      end
+    end
+
+    # Generate html markup pointing to assets
+    def markup
+      # Use display_path if defined, otherwise use output_path in url
+      display_path = @options['display_path'] || @options['output_path']
+
+      @html = @assets.map do |asset|
+        klass = JekyllAssetPipeline::Template.klass(asset.filename)
+        html = klass.new(display_path, asset.filename).html unless klass.nil?
+
+        html
+      end.join
+    end
+  end
+end

data/lib/jekyll_asset_pipeline/template.rb

@@ -0,0 +1,42 @@
+module JekyllAssetPipeline
+  # Base class for the tag templates
+  # See https://github.com/matthodan/jekyll-asset-pipeline#templates
+  class Template
+    include JekyllAssetPipeline::TemplateHelper
+    extend JekyllAssetPipeline::SubclassTracking
+
+    def initialize(path, filename)
+      @path = path
+      @filename = filename
+    end
+
+    # Filetype to process (e.g. '.js')
+    def self.filetype
+      ''
+    end
+
+    # Priority of template (to override default templates)
+    def self.priority
+      0
+    end
+
+    # Finds a template class based on a filename
+    def self.klass(filename)
+      klasses = JekyllAssetPipeline::Template.subclasses.select do |t|
+        t.filetype == File.extname(filename).downcase
+      end
+      klasses.sort! { |x, y| x.priority <=> y.priority }.last
+    end
+
+    # HTML output to return
+    #
+    # Available instance variables:
+    # @filename       Name of bundle file
+    # @path           Path to bundle file
+    #
+    # Returns string
+    def html
+      "#{@path}/#{@filename}\n"
+    end
+  end
+end

data/lib/jekyll_asset_pipeline/templates/css_tag_template.rb

@@ -0,0 +1,17 @@
+module JekyllAssetPipeline
+  # Default output for CSS assets
+  class CssTagTemplate < JekyllAssetPipeline::Template
+    def self.filetype
+      '.css'
+    end
+
+    def self.priority
+      -1
+    end
+
+    def html
+      "<link href='#{output_path}/#{@filename}' " \
+        "rel='stylesheet' type='text/css' />"
+    end
+  end
+end

data/lib/jekyll_asset_pipeline/templates/javascript_tag_template.rb

@@ -0,0 +1,17 @@
+module JekyllAssetPipeline
+  # Default output for JavaScript assets
+  class JavaScriptTagTemplate < JekyllAssetPipeline::Template
+    def self.filetype
+      '.js'
+    end
+
+    def self.priority
+      -1
+    end
+
+    def html
+      "<script src='#{output_path}/#{@filename}' " \
+        "type='text/javascript'></script>"
+    end
+  end
+end

data/lib/jekyll_asset_pipeline/templates/template_helper.rb

@@ -0,0 +1,15 @@
+module JekyllAssetPipeline
+  # Contains helper methods used by the tag template classes
+  module TemplateHelper
+    def output_path
+      root_path? ? '' : "/#{@path}"
+    end
+
+    def root_path?
+      stripped_path = @path.to_s.strip
+      stripped_path.nil? ||
+        stripped_path.empty? ||
+        stripped_path == '/'
+    end
+  end
+end

data/lib/jekyll_asset_pipeline/version.rb

@@ -0,0 +1,3 @@
+module JekyllAssetPipeline
+  VERSION = '0.5.1'.freeze
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: jekyll_asset_pipeline
+version: !ruby/object:Gem::Version
+  version: 0.5.1
+platform: ruby
+authors:
+- Matt Hodan
+- Janos Rusiczki
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-12-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jekyll
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: liquid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+description: |2
+      Jekyll Asset Pipeline adds asset preprocessing (CoffeeScript, Sass,
+      Less, ERB, etc.) and asset compression / minification / gzip (Yahoo YUI
+      Compressor, Google Closure Compiler, etc.) to Jekyll.
+email:
+- matthew.c.hodan@gmail.com
+- janos.rusiczki@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/jekyll_asset_pipeline.rb
+- lib/jekyll_asset_pipeline/asset.rb
+- lib/jekyll_asset_pipeline/compressor.rb
+- lib/jekyll_asset_pipeline/converter.rb
+- lib/jekyll_asset_pipeline/extensions/jekyll/site.rb
+- lib/jekyll_asset_pipeline/extensions/jekyll/site_extensions.rb
+- lib/jekyll_asset_pipeline/extensions/liquid/asset_tag.rb
+- lib/jekyll_asset_pipeline/extensions/liquid/asset_tags/css_asset_tag.rb
+- lib/jekyll_asset_pipeline/extensions/liquid/asset_tags/javascript_asset_tag.rb
+- lib/jekyll_asset_pipeline/extensions/liquid/liquid_block_extensions.rb
+- lib/jekyll_asset_pipeline/extensions/ruby/subclass_tracking.rb
+- lib/jekyll_asset_pipeline/pipeline.rb
+- lib/jekyll_asset_pipeline/template.rb
+- lib/jekyll_asset_pipeline/templates/css_tag_template.rb
+- lib/jekyll_asset_pipeline/templates/javascript_tag_template.rb
+- lib/jekyll_asset_pipeline/templates/template_helper.rb
+- lib/jekyll_asset_pipeline/version.rb
+homepage: https://github.com/matthodan/jekyll-asset-pipeline
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: A powerful asset pipeline for Jekyll that bundles, converts, and minifies
+  CSS and JavaScript assets.
+test_files: []