jekyll-asset-post-processor 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a792371c4737b731abbb720b92425965ccce1f1841969db9c1113cfc18a551b
-  data.tar.gz: a536f5d13e043a833e75e3bf35fa74dcbc2c20c9a0e66e9f55f2447812a24b41
+  metadata.gz: 49fd94c0bbcf82ad730f511c352fd415c77b61299e68fe53da97d6d39b07039d
+  data.tar.gz: 9563eb740ee7c01f0b1dfcec82c2930fe9b2bfe610268690cb0b9998e2ac5b2a
 SHA512:
-  metadata.gz: 1c5187e72e50fe89cc483f2785eeb865ea81e91e1671fffc965da1229f008e9e9a7a7dc145c3e02aa0cf160f1a3ae544f40452ffe02b7851f17eea335986328f
-  data.tar.gz: 44ce6da1ee7ba522a40b8eb611a4b7e137228986fdbf5fcb9b62da897415a5e752753c83685201551c73b6ea6a51da6ceaecdf2ded5ac02f20fcafb23603205c
+  metadata.gz: '093a6bed1e6d402113a49b1a082c53fbf0ed6ca3ee146e59dfc9db3315ca18b30f1cd4020f6e450c94253ade32fcb84a151bf1ec707cc6229fce8c637fc2a70d'
+  data.tar.gz: b6598cbf5f9a36102db08623d58b674909e9af320d8eb49f70c9ba13bf2516e1d7f81235a951caf70c0fae3fc73ef673e8a4500e29fb5b88d7007d36d160ba2a

data/ACKNOWLEDGEMENTS

@@ -1,23 +1,23 @@
-matthodan/jekyll-asset-pipeline - https://github.com/matthodan/jekyll-asset-pipeline
-
-(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
+matthodan/jekyll-asset-pipeline - https://github.com/matthodan/jekyll-asset-pipeline
+
+(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/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2022 Darcy Supply Ltd.
-
-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
+MIT License
+
+Copyright (c) 2022 Darcy Supply Ltd.
+
+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

@@ -1,85 +1,85 @@
-# jekyll-asset-post-processor
-Process then suffix your Jekyll assets with cache busting version hashes
-
-## How It Works
-
-`jekyll-asset-post-processor` takes a given asset, renders/processes it, suffixes a version hash based on it's contents and name, and then bundles it in your website's final build. It was built for cache busting with these core concepts in mind:
-
-- Work with all assets: CSS, JS, images, videos, etc.
-- Produce a version hash that's consistent across environments and is Git friendly.
-- The ability to import assets within HTML and Sass files.
-- Simple to setup and use, matching Jekyll's simplicity.
-- No inline templates: you handle the code, the plugin handles the assets.
-- Fully compatible with `jekyll serve`.
-- Extendable with custom processors.
-
-Used in production at [darcysupply.com](https://darcysupply.com).
-
-## Usage
-
-A single tag imports an asset, which in turn returns the new relative path to the bundled asset.
- `{% process_asset _assets/css/style.scss %}` = `/assets/css/style-cdb523590dafe38b9df14dde169125a4.css`
-
-The tag can be used in any HTML or Sass file and even supports Liquid variables, filters, and tags. An asset is only rendered and bundled once, meaning you can include an asset more than once across multiple files without conflicts.
-
-### HTML
-
-Because Liquid variables are supported, you can pass a page provided variable as the input asset.
-
-```html
-<link rel="stylesheet" href="{% process_asset {{ page.stylesheet }} %}">
-```
-
-### Sass / SCSS
-
-Sass files are parsed with Liquid, rendered with `sassc`, and then minified.
-
-Sass files inherit the static Liquid variables from the page that imported it. In cases where a file is imported more than once, the variables present will be from the first page that imported it.
-
-```css
-.app-glyph {
-    background-image: url("{% process_asset _assets/img/app-icon.png %} ")
-}
-```
-
-### Version Hashing
-
-The module creates an MD5 digest hash based on the final rendered contents of the file. This makes the version hash consistent across environments, especially since Git doesn't preserve modification dates, and means on CDN deploy the only new assets that get updated are the ones that have changed.
-
-## Setup
-
-1. Add `gem "jekyll-asset-post-processor"` to your Gemfile and run `bundle install`.
-2. Add `jekyll-asset-post-processor` to plugins in `_config.yml`
-```yaml
-plugins:
-    - jekyll-asset-post-processor
-```
-
-## Config
-
-`jekyll-asset-post-processor` can be further configured in your Jekyll `_config.yml`.
-
-```yaml
-asset-post-processor:
-    - staging_path: "_staging"
-    - destination_path: "assets"
-```
-
-|Name|Description|Default|
-|-|-|-|
-|`staging_path`|The temporary directory where bundled assets are stored before being moved to the final build. The plugin will automatically add this file to Jekyll's excluded list, you should also add it to your `.gitignore` if necessary.|`_staging`|
-|`destination_path`|The root directory in the site's final build (`_site`) where the bundled assets should be stored.|`assets`|
-
-## Custom Processors
-
-You can write your own processor for a specified file extension, [find full documentation](https://github.com/darcysupply/jekyll-asset-post-processor/blob/main/lib/processor.rb) within the class definition. [The Sass processor](https://github.com/darcysupply/jekyll-asset-post-processor/blob/main/lib/processors/scss.rb) is a fully working, in-production example.
-
-## Acknowledgements
-
-Parts of the Jekyll code and architectural choices come from [jekyll-asset-pipeline](https://github.com/matthodan/jekyll-asset-pipeline), thanks to Matt Hodan and other contributors of the project.
-
-## About
-
-![Darcy logo](https://raw.githubusercontent.com/darcysupply/jekyll-asset-post-processor/main/.github/darcy.png)
-
+# jekyll-asset-post-processor
+Process then suffix your Jekyll assets with cache busting version hashes
+
+## How It Works
+
+`jekyll-asset-post-processor` takes a given asset, renders/processes it, suffixes a version hash based on it's contents and name, and then bundles it in your website's final build. It was built for cache busting with these core concepts in mind:
+
+- Work with all assets: CSS, JS, images, videos, etc.
+- Produce a version hash that's consistent across environments and is Git friendly.
+- The ability to import assets within HTML and Sass files.
+- Simple to setup and use, matching Jekyll's simplicity.
+- No inline templates: you handle the code, the plugin handles the assets.
+- Fully compatible with `jekyll serve`.
+- Extendable with custom processors.
+
+Used in production at [darcysupply.com](https://darcysupply.com).
+
+## Usage
+
+A single tag imports an asset, which in turn returns the new relative path to the bundled asset.
+ `{% process_asset _assets/css/style.scss %}` = `/assets/css/style-cdb523590dafe38b9df14dde169125a4.css`
+
+The tag can be used in any HTML or Sass file and even supports Liquid variables, filters, and tags. An asset is only rendered and bundled once, meaning you can include an asset more than once across multiple files without conflicts.
+
+### HTML
+
+Because Liquid variables are supported, you can pass a page provided variable as the input asset.
+
+```html
+<link rel="stylesheet" href="{% process_asset {{ page.stylesheet }} %}">
+```
+
+### Sass / SCSS
+
+Sass files are rendered with `sassc`, parsed with Liquid, and then minified.
+
+Sass files inherit the static Liquid variables from the page that imported it. In cases where a file is imported more than once, the variables present will be from the first page that imported it. Processing is supported in all Sass imported stylesheets too.
+
+```css
+.app-glyph {
+    background-image: url("{% process_asset _assets/img/app-icon.png %} ")
+}
+```
+
+### Version Hashing
+
+The module creates an MD5 digest hash based on the final rendered contents of the file. This makes the version hash consistent across environments, especially since Git doesn't preserve modification dates, and means on CDN deploy the only new assets that get updated are the ones that have changed.
+
+## Setup
+
+1. Add `gem "jekyll-asset-post-processor"` to your Gemfile and run `bundle install`.
+2. Add `jekyll-asset-post-processor` to plugins in `_config.yml`
+```yaml
+plugins:
+    - jekyll-asset-post-processor
+```
+
+## Config
+
+`jekyll-asset-post-processor` can be further configured in your Jekyll `_config.yml`.
+
+```yaml
+asset-post-processor:
+    - staging_path: "_staging"
+    - destination_path: "assets"
+```
+
+|Name|Description|Default|
+|-|-|-|
+|`staging_path`|The temporary directory where bundled assets are stored before being moved to the final build. The plugin will automatically add this file to Jekyll's excluded list, you should also add it to your `.gitignore` if necessary.|`_staging`|
+|`destination_path`|The root directory in the site's final build (`_site`) where the bundled assets should be stored.|`assets`|
+
+## Custom Processors
+
+You can write your own processor for a specified file extension, [find full documentation](https://github.com/darcysupply/jekyll-asset-post-processor/blob/main/lib/processor.rb) within the class definition. [The Sass processor](https://github.com/darcysupply/jekyll-asset-post-processor/blob/main/lib/processors/scss.rb) is a fully working, in-production example.
+
+## Acknowledgements
+
+Parts of the Jekyll code and architectural choices come from [jekyll-asset-pipeline](https://github.com/matthodan/jekyll-asset-pipeline), thanks to Matt Hodan and other contributors of the project.
+
+## About
+
+![Darcy logo](https://raw.githubusercontent.com/darcysupply/jekyll-asset-post-processor/main/.github/darcy.png)
+
 `jekyll-asset-post-processor` is maintained by Darcy. We make apps, come [check us out](https://darcysupply.com).

data/lib/cache.rb

@@ -1,11 +1,11 @@
-module JekyllAssetPostProcessor
-    # Return the cache and create it if not present.
-    def self.cache
-        @cache ||= {}
-    end
-
-    # Clear the cache.
-    def self.clear_cache
-        @cache = {}
-    end
+module JekyllAssetPostProcessor
+    # Return the cache and create it if not present.
+    def self.cache
+        @cache ||= {}
+    end
+
+    # Clear the cache.
+    def self.clear_cache
+        @cache = {}
+    end
 end

data/lib/config.rb

@@ -1,16 +1,16 @@
-module JekyllAssetPostProcessor
-    DEFAULTS = {
-        'staging_path' => '_staging',
-        'destination_path' => 'assets'
-    }
-
-    def self.config_staging_path(jekyll_config)
-        config = jekyll_config['asset-post-processor'] || [{}]
-        return config[0]['staging_path'] || DEFAULTS['staging_path']
-    end
-
-    def self.config_destination_path(jekyll_config)
-        config = jekyll_config['asset-post-processor'] || [{}]
-        config[0]['destination_path'] || DEFAULTS['destination_path']
-    end
+module JekyllAssetPostProcessor
+    DEFAULTS = {
+        'staging_path' => '_staging',
+        'destination_path' => 'assets'
+    }
+
+    def self.config_staging_path(jekyll_config)
+        config = jekyll_config['asset-post-processor'] || [{}]
+        return config[0]['staging_path'] || DEFAULTS['staging_path']
+    end
+
+    def self.config_destination_path(jekyll_config)
+        config = jekyll_config['asset-post-processor'] || [{}]
+        config[0]['destination_path'] || DEFAULTS['destination_path']
+    end
 end

data/lib/extensions/jekyll.rb

@@ -1,42 +1,42 @@
-# This trick comes directly from jekyll-asset-pipeline. All credit and thanks to Matt Hodan and contributors.
-# https://github.com/matthodan/jekyll-asset-pipeline
-module JekyllSiteExtension
-    def self.included(base)
-        base.class_eval do
-            base_cleanup = instance_method(:cleanup)
-            define_method(:cleanup) do
-                return_value = base_cleanup.bind(self).call
-                JekyllAssetPostProcessor::clear_cache
-                return_value
-            end
-
-            # No longer removing staged assets as re-generating un-changed staged assets
-            # causes infinite loops when serving.
-            
-            # base_write = instance_method(:write)
-            # define_method(:write) do
-            #     return_value = base_write.bind(self).call
-            #     JekyllAssetPostProcessor::remove_staged_assets(self.config)
-            #     return_value
-            # end
-        end
-    end
-end
-
-module Jekyll
-    class Site
-        include JekyllSiteExtension
-    end
-end
-
-# Add the staging directory to the serve based 
-require 'jekyll-watch'
-module Jekyll
-    module Watcher
-        alias_method :old_custom_excludes, :custom_excludes
-        def custom_excludes(options)
-            options['exclude'] << JekyllAssetPostProcessor::config_staging_path(options)
-            old_custom_excludes(options)
-        end
-    end
+# This trick comes directly from jekyll-asset-pipeline. All credit and thanks to Matt Hodan and contributors.
+# https://github.com/matthodan/jekyll-asset-pipeline
+module JekyllSiteExtension
+    def self.included(base)
+        base.class_eval do
+            base_cleanup = instance_method(:cleanup)
+            define_method(:cleanup) do
+                return_value = base_cleanup.bind(self).call
+                JekyllAssetPostProcessor::clear_cache
+                return_value
+            end
+
+            # No longer removing staged assets as re-generating un-changed staged assets
+            # causes infinite loops when serving.
+            
+            # base_write = instance_method(:write)
+            # define_method(:write) do
+            #     return_value = base_write.bind(self).call
+            #     JekyllAssetPostProcessor::remove_staged_assets(self.config)
+            #     return_value
+            # end
+        end
+    end
+end
+
+module Jekyll
+    class Site
+        include JekyllSiteExtension
+    end
+end
+
+# Add the staging directory to the serve based 
+require 'jekyll-watch'
+module Jekyll
+    module Watcher
+        alias_method :old_custom_excludes, :custom_excludes
+        def custom_excludes(options)
+            options['exclude'] << JekyllAssetPostProcessor::config_staging_path(options)
+            old_custom_excludes(options)
+        end
+    end
 end

data/lib/hash.rb

@@ -1,14 +1,14 @@
-module JekyllAssetPostProcessor
-    # Generate a hash to be used in the internal cache to avoid processing
-    # a file more than once per build.
-    def self.cache_hash(file_path)
-        mtime = File.mtime(File.join(file_path))
-        Digest::MD5.hexdigest(file_path + mtime.to_s)
-    end
-
-    # Generate a hash to be used in the final file name. Generated from
-    # the final rendered file contents.
-    def self.file_hash(file_path, content)
-        Digest::MD5.hexdigest(content)
-    end
+module JekyllAssetPostProcessor
+    # Generate a hash to be used in the internal cache to avoid processing
+    # a file more than once per build.
+    def self.cache_hash(file_path)
+        mtime = File.mtime(File.join(file_path))
+        Digest::MD5.hexdigest(file_path + mtime.to_s)
+    end
+
+    # Generate a hash to be used in the final file name. Generated from
+    # the final rendered file contents.
+    def self.file_hash(file_path, content)
+        Digest::MD5.hexdigest(content)
+    end
 end

data/lib/jekyll-asset-post-processor.rb

@@ -1,16 +1,16 @@
-require 'digest/md5'
-require 'fileutils'
-require 'time'
-
-require 'jekyll'
-require 'sassc'
-
-require 'cache'
-require 'config'
-require 'hash'
-require 'processor'
-require 'process'
-require 'processors/scss'
-require 'liquid/process_asset_tag'
-
-require 'extensions/jekyll.rb'
+require 'digest/md5'
+require 'fileutils'
+require 'time'
+
+require 'jekyll'
+require 'sassc'
+
+require 'cache'
+require 'config'
+require 'hash'
+require 'processor'
+require 'process'
+require 'processors/scss'
+require 'liquid/process_asset_tag'
+
+require 'extensions/jekyll.rb'

data/lib/liquid/process_asset_tag.rb

@@ -1,22 +1,22 @@
-module JekyllAssetPostProcessor
-
-    class ProcessAssetTag < Liquid::Tag
-        def initialize(tag_name, args, token)
-            super
-            @args = args.strip
-        end
-
-        def render(context)
-            template = Liquid::Template.parse(@args)
-            stylesheet_path = template.render(context)
-            
-            if stylesheet_path.length == 0
-                raise 'No asset given to process'
-            end
-
-            JekyllAssetPostProcessor::process(context, stylesheet_path)
-        end
-    end
-    Liquid::Template.register_tag('process_asset', ProcessAssetTag)
-
+module JekyllAssetPostProcessor
+
+    class ProcessAssetTag < Liquid::Tag
+        def initialize(tag_name, args, token)
+            super
+            @args = args.strip
+        end
+
+        def render(context)
+            template = Liquid::Template.parse(@args)
+            stylesheet_path = template.render(context)
+            
+            if stylesheet_path.length == 0
+                raise 'No asset given to process'
+            end
+
+            JekyllAssetPostProcessor::process(context, stylesheet_path)
+        end
+    end
+    Liquid::Template.register_tag('process_asset', ProcessAssetTag)
+
 end

data/lib/process.rb

@@ -1,106 +1,106 @@
-module JekyllAssetPostProcessor
-    def self.remove_staged_assets(jekyll_config)
-        staging_path = File.join(config_staging_path(jekyll_config))
-        FileUtils.rm_rf(staging_path)
-    end
-
-    # Register a new asset with Jekyll from the staging directory in order
-    # to be moved into the final build directory.
-    def self.new_jekyll_asset(site, staging_path, output_path, filename)
-        site.static_files << Jekyll::StaticFile.new(site, staging_path, output_path, filename)
-    end
-
-    def self.processors
-        @processors ||= {}
-    end
-
-    def self.register_processor(extension, processor)
-        processors[extension] = processor
-    end
-
-    # Process a single asset file.
-    def self.process(context, file_path)
-        site = context.registers[:site]
-        jekyll_config = site.config
-
-        generated_cache_hash = cache_hash(file_path)
-        return cache[generated_cache_hash] if cache.key?(generated_cache_hash)
-
-        source = site.source
-        path = File.join(source, file_path)
-        basename = File.basename(path)
-        filename = File.basename(path, '.*')
-        extension = File.extname(basename)
-
-        # generate the destination path, by default insert into assets directory
-        staging_path = config_staging_path(jekyll_config)
-        destination_path = config_destination_path(jekyll_config)
-
-        split_path = file_path.split('/')
-        if split_path.length > 2
-            destination_path += '/' + split_path[1..-2].join('/')
-        end
-        
-        generated_file_hash = nil
-        new_extension = extension
-        rendered = nil
-
-        rendered = nil
-        rendered_binary = nil
-        if processors.key?(extension)
-            processor = processors[extension].new(filename, extension, file_path)
-            new_extension = processor.new_extension
-
-            new_contents = nil
-            File.open(path, 'r') do |file|
-                new_contents = processor.process(file.read, context)
-            end
-            if new_contents.nil?
-                File.open(path, 'rb') do |file|
-                    new_binary_contents = processor.process_binary(file.read, context)
-                    if new_binary_contents.nil?
-                        raise "Processor for #{extension} doesn't override process or process_binary"
-                    else
-                        rendered_binary = new_binary_contents
-                        generated_file_hash = file_hash(file_path, rendered_binary)
-                    end
-                end
-            else
-                rendered = new_contents
-                generated_file_hash = file_hash(file_path, rendered)
-            end
-        else
-            File.open(path, 'rb') do |file|
-                generated_file_hash = file_hash(file_path, file.read)
-            end
-        end
-
-
-        generated_filename = "#{filename}-#{generated_file_hash}#{new_extension}"
-        staging_destination = File.join(source, staging_path, destination_path)
-
-        FileUtils.mkpath(staging_destination) unless File.directory?(staging_destination)
-        generated_staging_path = File.join(staging_destination, generated_filename)
-        if !File.file?(generated_staging_path)
-            if !rendered.nil?
-                File.open(generated_staging_path, 'w') do |file|
-                    file.write(rendered)
-                end
-            elsif !rendered_binary.nil?
-                File.open(generated_staging_path, 'wb') do |file|
-                    file.write(rendered_binary)
-                end
-            else
-                FileUtils.cp(path, File.join(staging_destination, generated_filename))
-            end
-        end
-        
-        new_jekyll_asset(site, staging_path, destination_path, generated_filename)
-
-        generated_asset_site_path = '/' + File.join(destination_path, generated_filename)
-        cache[cache_hash(file_path)] = generated_asset_site_path
-        return generated_asset_site_path
-
-    end
-
+module JekyllAssetPostProcessor
+    def self.remove_staged_assets(jekyll_config)
+        staging_path = File.join(config_staging_path(jekyll_config))
+        FileUtils.rm_rf(staging_path)
+    end
+
+    # Register a new asset with Jekyll from the staging directory in order
+    # to be moved into the final build directory.
+    def self.new_jekyll_asset(site, staging_path, output_path, filename)
+        site.static_files << Jekyll::StaticFile.new(site, staging_path, output_path, filename)
+    end
+
+    def self.processors
+        @processors ||= {}
+    end
+
+    def self.register_processor(extension, processor)
+        processors[extension] = processor
+    end
+
+    # Process a single asset file.
+    def self.process(context, file_path)
+        site = context.registers[:site]
+        jekyll_config = site.config
+
+        generated_cache_hash = cache_hash(file_path)
+        return cache[generated_cache_hash] if cache.key?(generated_cache_hash)
+
+        source = site.source
+        path = File.join(source, file_path)
+        basename = File.basename(path)
+        filename = File.basename(path, '.*')
+        extension = File.extname(basename)
+
+        # generate the destination path, by default insert into assets directory
+        staging_path = config_staging_path(jekyll_config)
+        destination_path = config_destination_path(jekyll_config)
+
+        split_path = file_path.split('/')
+        if split_path.length > 2
+            destination_path += '/' + split_path[1..-2].join('/')
+        end
+        
+        generated_file_hash = nil
+        new_extension = extension
+        rendered = nil
+
+        rendered = nil
+        rendered_binary = nil
+        if processors.key?(extension)
+            processor = processors[extension].new(filename, extension, file_path)
+            new_extension = processor.new_extension
+
+            new_contents = nil
+            File.open(path, 'r') do |file|
+                new_contents = processor.process(file.read, context)
+            end
+            if new_contents.nil?
+                File.open(path, 'rb') do |file|
+                    new_binary_contents = processor.process_binary(file.read, context)
+                    if new_binary_contents.nil?
+                        raise "Processor for #{extension} doesn't override process or process_binary"
+                    else
+                        rendered_binary = new_binary_contents
+                        generated_file_hash = file_hash(file_path, rendered_binary)
+                    end
+                end
+            else
+                rendered = new_contents
+                generated_file_hash = file_hash(file_path, rendered)
+            end
+        else
+            File.open(path, 'rb') do |file|
+                generated_file_hash = file_hash(file_path, file.read)
+            end
+        end
+
+
+        generated_filename = "#{filename}-#{generated_file_hash}#{new_extension}"
+        staging_destination = File.join(source, staging_path, destination_path)
+
+        FileUtils.mkpath(staging_destination) unless File.directory?(staging_destination)
+        generated_staging_path = File.join(staging_destination, generated_filename)
+        if !File.file?(generated_staging_path)
+            if !rendered.nil?
+                File.open(generated_staging_path, 'w') do |file|
+                    file.write(rendered)
+                end
+            elsif !rendered_binary.nil?
+                File.open(generated_staging_path, 'wb') do |file|
+                    file.write(rendered_binary)
+                end
+            else
+                FileUtils.cp(path, File.join(staging_destination, generated_filename))
+            end
+        end
+        
+        new_jekyll_asset(site, staging_path, destination_path, generated_filename)
+
+        generated_asset_site_path = '/' + File.join(destination_path, generated_filename)
+        cache[cache_hash(file_path)] = generated_asset_site_path
+        return generated_asset_site_path
+
+    end
+
 end

data/lib/processor.rb

@@ -1,54 +1,54 @@
-module JekyllAssetPostProcessor
-
-    # Subclass any processors with JekyllAssetPostProcessor::Processor.
-    #
-    # To register your processor:
-    #     `JekyllAssetPostProcessor::register_processor('.ext', processor)`
-    class Processor
-        # If overriding you are required to call `super`.
-        def initialize(filename, extension, source_path)
-            # Filename stripped of the extension.
-            @filename = filename
-            # Extension, containing the prefix '.'.
-            @extension = extension
-            # The source path directly given from {% process_asset %}
-            @source_path = source_path
-        end
-
-        # Optional to override, default behavior is using the original extension.
-        def new_extension
-            @extension
-        end
-
-        # Process the string value of the file, useful for text based files like
-        # JS and CSS.
-        #
-        # You are given the Liquid context as the second arguument which can
-        # be used like `Liquid::Template.parse(contents).render(liquid_context)`.
-        # The string contents argument given is pre-Liquid rendering, you must
-        # render Liquid content yourself as shown before.
-        #
-        # You must override either this or `process_binary`. See also `process_binary`.
-        def process(contents, liquid_context)
-            nil
-        end
-
-        # Process the binary value of the file, useful for binary files like 
-        # images and videos.
-        #
-        # You are given the Liquid context as the second argument. Rendering
-        # the content may be less useful as Liquid only works with strings,
-        # however you can get the page and site variables like so:
-        #     page = liquid_context.registers[:page]
-        #     site = liquid_context.registers[:site]
-        #     page_title = site[:title]
-        #
-        # You must override either this or `process`. See also `process`.
-        def process_binary(contents, liquid_context)
-            nil
-        end
-    end
-
-    # See lib/processors/scss.rb for an example of a processor.
-
+module JekyllAssetPostProcessor
+
+    # Subclass any processors with JekyllAssetPostProcessor::Processor.
+    #
+    # To register your processor:
+    #     `JekyllAssetPostProcessor::register_processor('.ext', processor)`
+    class Processor
+        # If overriding you are required to call `super`.
+        def initialize(filename, extension, source_path)
+            # Filename stripped of the extension.
+            @filename = filename
+            # Extension, containing the prefix '.'.
+            @extension = extension
+            # The source path directly given from {% process_asset %}
+            @source_path = source_path
+        end
+
+        # Optional to override, default behavior is using the original extension.
+        def new_extension
+            @extension
+        end
+
+        # Process the string value of the file, useful for text based files like
+        # JS and CSS.
+        #
+        # You are given the Liquid context as the second arguument which can
+        # be used like `Liquid::Template.parse(contents).render(liquid_context)`.
+        # The string contents argument given is pre-Liquid rendering, you must
+        # render Liquid content yourself as shown before.
+        #
+        # You must override either this or `process_binary`. See also `process_binary`.
+        def process(contents, liquid_context)
+            nil
+        end
+
+        # Process the binary value of the file, useful for binary files like 
+        # images and videos.
+        #
+        # You are given the Liquid context as the second argument. Rendering
+        # the content may be less useful as Liquid only works with strings,
+        # however you can get the page and site variables like so:
+        #     page = liquid_context.registers[:page]
+        #     site = liquid_context.registers[:site]
+        #     page_title = site[:title]
+        #
+        # You must override either this or `process`. See also `process`.
+        def process_binary(contents, liquid_context)
+            nil
+        end
+    end
+
+    # See lib/processors/scss.rb for an example of a processor.
+
 end

data/lib/processors/scss.rb

@@ -1,19 +1,19 @@
-# See lib/processor.rb for full documentation.
-
-module JekyllAssetPostProcessor
-    
-    class SassProcessor < JekyllAssetPostProcessor::Processor
-
-        def new_extension
-            '.css'
-        end
-
-        def process(contents, liquid_context)
-            template = Liquid::Template.parse(contents)
-            SassC::Engine.new(template.render(liquid_context), syntax: :scss, style: :compressed).render
-        end
-
-    end
-    JekyllAssetPostProcessor::register_processor('.scss', SassProcessor)
-
+# See lib/processor.rb for full documentation.
+
+module JekyllAssetPostProcessor
+    
+    class SassProcessor < JekyllAssetPostProcessor::Processor
+
+        def new_extension
+            '.css'
+        end
+
+        def process(contents, liquid_context)
+            sass = SassC::Engine.new(contents, syntax: :scss, style: :compressed).render
+            Liquid::Template.parse(sass).render(liquid_context)
+        end
+
+    end
+    JekyllAssetPostProcessor::register_processor('.scss', SassProcessor)
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-asset-post-processor
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Darcy Supply Ltd.
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-05 00:00:00.000000000 Z
+date: 2023-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jekyll
@@ -110,7 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
 summary: Process then suffix your Jekyll assets with cache busting version hashes