darkroom 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ff7abd45467a1fd1e3f3ae707ad1ff04ff45c9e0a4f4a512fb24fc6bd794879
-  data.tar.gz: 03f15709d9310d94068f3706e02ac1d4998887cf3c5bb09f3463eb72875a1ae9
+  metadata.gz: ec78b55ac1e82e265e1f5546a929ed3b12ab72585bc448d5f3c3d06c8804ec10
+  data.tar.gz: 2df42517847826a826ebe32d90b8bbbe41fe242872e56db06672e5b5c1d4fb3b
 SHA512:
-  metadata.gz: bd87bd335cb7abb1e3bf26365d0dca2247b5d5450c82ded04d16709d97031bdcf2e4e59cf345c2f5a18218be05157ee2dc4c9f1d5ef27ed07ab433bf33a968aa
-  data.tar.gz: d1141e492dcedde15aca909de9354756d95db7ecf4b925421711589eeef96df973126e7d603ccde93ee6d078252ea56eba6d89c9c594eef00c9ff55a3fcb666c
+  metadata.gz: 49970a3c8e73e1a44f54ccca8bef6c31e55c56bd5c0b1a9194beef31ecc188ce6c54d225d02c68261e42f6c9a8fee15b160a492f0dd5bbba1be07097d7f6182f
+  data.tar.gz: 109f67f9c64b8443d11404af38d33f154f94a3acef3a041b66499c3cfade22ad3516d6abb55cbb48c42ed2592e2a46575e4c52c6b9745f147f0af9fb84fbda4b

data/CHANGELOG.md

@@ -0,0 +1,83 @@
+# Darkroom Changelog
+
+## Upcoming (Unreleased)
+
+* Nothing yet
+
+## 0.0.9 (2025 January 21)
+
+* **Remove deprecated delegate creation via hash and associated accessors**
+* **Remove deprecated `:minified_pattern` option**
+* **Remove deprecated `:internal_pattern` option and `Asset#internal?` method**
+* **Fix assets with error(s) not getting reprocessed until directly modified**
+* Add support for AVIF assets
+* Add support for animated PNG assets
+* Add support for GIF assets
+* Add support for WebP assets
+
+## 0.0.8 (2023 July 15)
+
+* **Fix issues with ensuring previous steps of asset processing**
+* **Fix ordering of JavaScript import statements in IIFE output**
+
+## 0.0.7 (2023 July 15)
+
+* **Add option to use IIFEs for JavaScript assets instead of concatenating**
+* Add line info to `ProcessingError#to_s` output for non-`AssetError` errors
+* Raise error in `Darkroom#dump` if present from last process run
+* Yield to parse handlers and accumulate errors in order of appearance
+* Add deprecation warning to `Asset#internal?`
+* **Add support for importing and referencing assets by relative path**
+* Escape quotes with HTML entities in reference content with UTF8 format
+* **Implement DSL for delegates and deprecate configuring via hash**
+* Move delegate registration back to `Darkroom` class
+* Rework asset processing code to reduce chances of asset dependency bugs
+* **Deprecate `:minified_pattern` and replace with more flexible `:minified`**
+* **Deprecate `:internal_pattern` and replace with more flexible `:entries`**
+* Skip exception raise in `Darkroom#process!` if processing was skipped
+* Allow compiled assets to be further processed as target content type
+* Ensure pristine files are never treated as internal
+* Move delegate registration and management to Asset class
+
+## 0.0.6 (2022 May 3)
+
+* Use [Terser](https://github.com/ahorek/terser-ruby) instead of
+  [UglifyJS](https://github.com/lautis/uglifier) for JavaScript minification
+* **Fix dependencies sometimes getting missed due to circular references**
+
+## 0.0.5 (2022 March 31)
+
+* Ensure load paths are absolute and fully normalized
+* **Ensure a dependency has been processed before fetching its dependencies**
+* **Remove deprecated `Asset.add_spec` and `Asset.spec` methods**
+
+## 0.0.4 (2021 August 3)
+
+* **Add ability to reference other asset paths and content within an asset**
+* Ensure `FileUtils` is loaded when dumping assets to disk
+* **Add `Asset#image?` for determining if an asset is an image**
+* **Add `Asset#font?` for determining if an asset is a font**
+* **Add `Asset#binary?` for determining if an asset is binary**
+* Ensure errors array always exists on `Darkroom` instances
+* Improve error class organization, naming, and messages
+* **Use text/javascript for content type of JavaScript and HTX files**
+* Disallow troublesome characters in asset paths
+* Add support for JSON assets
+
+## 0.0.3 (2021 March 27)
+
+* Fix and improve quote matching in dependency regexes
+* Use [SassC](https://github.com/sass/sassc-ruby) for minifying CSS since it is more up to date than
+  [CSSminify](https://github.com/matthiassiegel/cssminify)
+* Fix HTML spec to recognize .htm extensions in addition to .html
+
+## 0.0.2 (2021 March 25)
+
+* Improve output of compile and minify library load errors
+* **Rework how assets are processed so circular dependencies work properly**
+* **Add methods for getting subresource integrity string for an asset**
+* **Remove `Darkroom#asset_path!` and move its behavior to `#asset_path`**
+
+## 0.0.1 (2021 February 25)
+
+* Release initial gem

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2021-2022 Nate Pickens
+Copyright 2021-2025 Nate Pickens
 
 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

data/README.md

@@ -11,7 +11,10 @@ The following file types are supported out of the box, though support for others
 
 | Name       | Content Type     | Extension(s) |
 |------------|------------------|--------------|
+| APNG       | image/apng       | .apng        |
+| AVIF       | image/avif       | .avif        |
 | CSS        | text/css         | .css         |
+| GIF        | image/gif        | .gif         |
 | HTML       | text/html        | .htm, .html  |
 | HTX        | text/javascript  | .htx         |
 | ICO        | image/x-icon     | .ico         |
@@ -21,6 +24,7 @@ The following file types are supported out of the box, though support for others
 | PNG        | image/png        | .png         |
 | SVG        | image/svg+xml    | .svg         |
 | Text       | text/plain       | .txt         |
+| WebP       | image/webp       | .webp        |
 | WOFF       | font/woff        | .woff        |
 | WOFF2      | font/woff2       | .woff2       |
 
@@ -56,20 +60,22 @@ optional):
 
 ```ruby
 darkroom = Darkroom.new('app/assets', 'vendor/assets', '...',
-  hosts: [                             # Hosts to prepend to asset paths (useful in production
-    'https://cname1.cdn.com',          # when assets are served from a CDN with multiple
-    'https://cname2.cdn.com',          # cnames); hosts are chosen round-robin per thread
+  hosts: [                           # Hosts to prepend to asset paths (useful in production
+    'https://cname1.cdn.com',        #   when assets are served from a CDN with multiple
+    'https://cname2.cdn.com',        #   cnames); hosts are chosen round-robin per thread
     '...',
   ],
-  prefix: '/static',                   # Prefix to add to all asset paths
-  pristine: ['/google-verify.html'],   # Paths with no prefix or versioning (/favicon.ico,
-                                       # /mask-icon.svg, /humans.txt, and /robots.txt are
-                                       # included automatically)
-  minify: true,                        # Minify assets that can be minified
-  minified_pattern: /(\.|-)min\.\w+$/, # Files to skip minification on when minify: true
-  internal_pattern: /^\/components\//, # Files to disallow direct external access to (they can
-                                       # still be imported into other assets)
-  min_process_interval: 1,             # Minimum time that must elapse between process calls
+  prefix: '/static',                 # Prefix to add to all asset paths
+  pristine: ['/google-verify.html'], # Paths with no prefix or versioning (assets such as
+                                     #   /favicon.ico and /robots.txt are included
+                                     #   automatically)
+  entries: /^\/controllers\//,       # Assets that will be directly accessed (fewer means
+                                     #   better performance); can be a string, regex, or
+                                     #   array of such
+  minify: true,                      # Minify assets that can be minified
+  minified: /(\.|-)min\.\w+$/,       # Files to skip minification on when minify: true; can
+                                     #   be a string, regex, or array of such
+  min_process_interval: 1,           # Minimum time that must elapse between process calls
 )
 ```
 
@@ -98,85 +104,138 @@ To work with assets:
 
 ```ruby
 # A Darkroom instance has a few convenience helper methods.
-path = darkroom.asset_path('/js/app.js')           # => '/static/js/app-[fingerprint].js'
-integrity = darkroom.asset_integrity('/js/app.js') # => 'sha384-[hash]'
+path = darkroom.asset_path('/js/app.js')           # => "/static/js/app-[fingerprint].js"
+integrity = darkroom.asset_integrity('/js/app.js') # => "sha384-[hash]"
 
 # Retrieve the Asset object associated with a path.
 asset = darkroom.asset(path)
 
-# Prefix (if set on the Darkroom instance) is included in the unversioned and versioned paths.
-assest.path                     # => '/js/app.js'
-assest.path_unversioned         # => '/static/js/app.js'
-assest.path_versioned           # => '/static/js/app-[fingerprint].js'
+# Prefix (if set on the Darkroom instance) is included in the unversioned and versioned
+# paths.
+assest.path                     # => "/js/app.js"
+assest.path_unversioned         # => "/static/js/app.js"
+assest.path_versioned           # => "/static/js/app-[fingerprint].js"
 
-asset.content_type              # => 'text/javascript'
 asset.content                   # Content of processed /js/app.js file
 
-asset.headers                   # => {'Content-Type' => 'text/javascript',
-                                #     'Cache-Control' => 'public, max-age=31536000'}
-asset.headers(versioned: false) # => {'Content-Type' => 'text/javascript',
-                                #     'ETag' => '[fingerprint]'}
-
-asset.integrity                 # => 'sha384-[hash]'
-asset.integrity(:sha256)        # => 'sha256-[hash]'
-asset.integrity(:sha512)        # => 'sha512-[hash]'
+asset.content_type              # => "text/javascript"
+asset.binary?                   # => false
+asset.font?                     # => false
+asset.image?                    # => false
+asset.entry?                    # => true
+
+asset.error?                    # => true
+asset.errors                    # => [#<Darkroom::AssetError ...>, ...]
+
+asset.fingerprint               # => "[MD5 hash of asset content]"
+asset.headers                   # => {"Content-Type" => "text/javascript",
+                                #     "Cache-Control" => "public, max-age=31536000"}
+asset.headers(versioned: false) # => {"Content-Type" => "text/javascript",
+                                #     "ETag" => "[fingerprint]"}
+
+asset.integrity                 # => "sha384-[hash]"
+asset.integrity(:sha256)        # => "sha256-[hash]"
+asset.integrity(:sha384)        # => "sha384-[hash]"
+asset.integrity(:sha512)        # => "sha512-[hash]"
 ```
 
 ## Asset Bundling
 
 CSS and JavaScript assets specify their dependencies by way of each language's native import statement. Each
-import statement is replaced with content of the referenced asset. Example:
+import statement is replaced with the content of the imported asset. Example:
+
+```css
+/* Unprocessed /header.css */
+header { background: #f1f1f1; }
+```
+
+```css
+/* Unprocessed /app.css */
+@import '/header.css';
+
+body { background: #fff; }
+```
+
+```css
+/* Processed /app.css */
+header { background: #f1f1f1; }
+
+body { background: #fff; }
+```
+
+Imported assets can also contain import statements, and those assets are all included in the base asset.
+Imports can even be cyclical. If `asset-a.css` imports `asset-b.css` and vice-versa, each asset will simply
+contain the content of both of those assets (though order will be different as an asset's own content always
+comes after any imported assets' contents).
+
+By default, JavaScript files are concatenated in the same way that CSS files are. Example:
 
 ```javascript
 // Unprocessed /api.js
-function api() {
-  console.log('API called!')
-}
+function API() { console.log('API called!') }
+```
 
+```javascript
 // Unprocessed /app.js
 import '/api.js'
 
-api()
+API()
+```
 
+```javascript
 // Processed /app.js
-function api() {
-  console.log('API called!')
-}
+function API() { console.log('API called!') }
 
+API()
+```
 
-api()
+Alternatively, setting `Darkroom.javascript_iife = true` will cause JavaScript assets to be compiled to a
+series of IIFEs that provide the same encapsulation as native ES6 modules (indentation is not quite as
+pretty as shown here, but has been altered here for readability):
+
+```javascript
+// Unprocessed /api.js
+export function API() { console.log('API called!') }
 ```
 
-The same applies for CSS files. Example:
+```javascript
+// Unprocessed /app.js
+import {API} from '/api.js'
 
-```css
-/* Unprocessed /header.css */
-header {
-  background: #f1f1f1;
-}
+API()
+```
 
-/* Unprocessed /app.css */
-@import '/header.css';
+```javascript
+// Processed /app.js
+((...bundle) => {
+  const modules = {}
+  const setters = []
+  const $import = (name, setter) =>
+    modules[name] ? setter(modules[name]) : setters.push([setter, name])
 
-body {
-  background: #fff;
-}
+  for (const [name, def] of bundle)
+    modules[name] = def($import)
 
-/* Processed /app.css */
-header {
-  background: #f1f1f1;
-}
+  for (const [setter, name] of setters)
+    setter(modules[name])
+})(
+  ['/api.js', $import => {
+    function API() { console.log('API called!') }
 
+    return Object.seal({
+      API: API,
+    })
+  }],
 
-body {
-  background: #fff;
-}
-```
+  ['/app.js', $import => {
+    let API; $import('/api.js', m => API = m.API)
 
-Imported assets can also contain import statements, and those assets are all included in the base asset.
-Imports can even be cyclical. If `asset-a.css` imports `asset-b.css` and vice-versa, each asset will simply
-contain the content of both of those assets (though order will be different as an asset's own content always
-comes after any imported assets' contents).
+    API()
+
+    return Object.seal({})
+  }],
+)
+```
 
 ## Asset References
 
@@ -212,9 +271,11 @@ replaced appropriately.
 </head>
 
 <body>
-  <img src='/logo.svg?asset-content-displace'>
+  <img src='/logo.svg?asset-content=displace'>
 </body>
+```
 
+```html
 <!-- Result -->
 <head>
   <title>My App</title>
@@ -229,23 +290,234 @@ replaced appropriately.
 
 ## Extending
 
-Darkroom is extensible. Support for arbitrary file types can be added as follows (`content_type` is required
-but all other keyword arguments are optional):
+Darkroom is extensible. Support for arbitrary file types can be added by specifying one or more extensions
+and a content type:
 
 ```ruby
-# Simple type with no special behavior.
-Darkroom.register('.extension1', 'extension2', '...', 'content/type')
-
-# Complex type with special behavior.
-Darkroom.register('.extension1', 'extension2', '...',
-  content_type: 'content/type',         # HTTP MIME type string
-  import_regex: /import (?<path>.*)/,   # Regex for identifying imports for bundling
-  reference_regex: /ref=(?<path>.*)/,   # Regex for identifying references to other assets
-  compile_lib: 'some-compile-lib',      # Name of library required for compilation
-  compile: ->(path, content) { '...' }, # Lambda that returns compiled content
-  minify_lib: 'some-minify-lib',        # Name of library required for minification
-  minify: ->(content) { '...' },        # Lambda that returns minified content
-)
+Darkroom.register('.ext1', '.ext2', '...', 'content/type')
+```
+
+### DSL
+
+For more advanced functionality, the DSL can be used one of three ways. With a block:
+
+```ruby
+Darkroom.register('.ext1', '.ext2', '...') do
+  # ...
+end
+```
+
+Or with a class that extends `Darkroom::Delegate`:
+
+```ruby
+class MyDelegate < Darkroom::Delegate
+  # ...
+end
+
+Darkroom.register('.ext1', '.ext2', '...', MyDelegate)
+```
+
+Or with both:
+
+```ruby
+class MyDelegate < Darkroom::Delegate
+  # ...
+end
+
+Darkroom.register('.ext1', '.ext2', '...', MyDelegate) do
+  # Extend MyDelegate
+end
+```
+
+The DSL supports basic parsing via regular expressions, with special behavior for import statements and
+references. Compilation, finalization, and minification behavior can also be configured.
+
+#### Content Type
+
+```ruby
+Darkroom.register('.ext1', '.ext2', '...') do
+  content_type('content/type') # HTTP MIME type string.
+
+  # ...
+end
+```
+
+#### Imports
+
+Imports are references to other assets, identified via regex, which get prepended to an asset's own content.
+The regex requires a named component, `path`, as it is used internally to determine the asset being imported
+(leveraging `Asset::QUOTED_PATH_REGEX` within one's own regex is helpful).
+
+A block is optional, but can be used to accumulate parse data and/or override the default behavior of
+removing an import statement altogether by returning a string to replace it with.
+
+```ruby
+Darkroom.register('.ext1', '.ext2', '...') do
+  # ...
+
+  # The (optional) block is passed three keyword arguments:
+  #   parse_data: - Hash for storing data across calls to this and other parse handlers.
+  #   match:      - MatchData object from the match against the provided regex.
+  #   asset:      - Asset object of the asset being imported.
+  import(/import #{Asset::QUOTED_PATH_REGEX.source};/) do |parse_data:, match:, asset:|
+    parse_data[:imports] ||= []          # Accumulate and use arbitrary parse data.
+    parse_data[:imports] << match[:path] # Use the MatchData object of the regex match.
+
+    if asset.binary?                     # Access the Asset object of the imported asset.
+      error('Binary asset not allowed!') # Halt execution of the block and record an error.
+    end
+
+    # Return nil for default behavior (import statement is removed).
+    nil
+
+    # ...Or return a string as the replacement for the import statement.
+    "/* [#{asset.path}] */"
+  end
+end
+```
+
+#### References
+
+References are non-import references to other assets, identified via regex, which result in either the
+asset's path or content being inserted in place. The regex requires named components `quote`, `quoted`,
+`path`, `entity`, and `format`, as these are used internally to determine the asset being referenced and how
+it should be treated (leveraging `Asset::REFERENCE_REGEX` within one's own regex is helpful). See the [Asset
+References](#asset-references) section for more detail.
+
+* `quote` - The type of quote used (e.g. `'` or `"`)
+* `quoted` - The portion of text within the `quote`s
+* `path` - The path of the asset
+* `entity` - Either 'path' or 'content'
+* `format` - Format of the path or content
+  * If `entity` == 'path' - Either 'versioned' or 'unversioned'
+  * If `entity` == 'content' - One of 'base64', 'utf8', or 'displace'
+
+A block is optional, but can be used to accumulate parse data and/or override the default substitution
+behavior.
+
+```ruby
+Darkroom.register('.ext1', '.ext2', '...') do
+  # ...
+
+  reference_regex = /ref=#{Asset::REFERENCE_REGEX.source}/x
+
+  # The (optional) block is passed four keyword arguments:
+  #   parse_data: - Hash for storing data across calls to this and other parse handlers.
+  #   match:      - MatchData object from the match against the provided regex.
+  #   asset:      - Asset object of the asset being referenced.
+  #   format:     - Format of the reference (see Asset::REFERENCE_FORMATS).
+  reference(reference_regex) do |parse_data:, match:, asset:, format:|
+    parse_data[:refs] ||= []          # Accumulate and use arbitrary parse data.
+    parse_data[:refs] << match[:path] # Use the MatchData object of the regex match.
+
+    if format == 'base64'           # See Asset References section for format details.
+      error('Format must be utf8!') # Halt execution of the block and register an error.
+    end
+
+    # Return nil for default behavior (path or content is substituted based on format).
+    nil
+
+    # ...Or return a string to use in lieu of default substitution.
+    asset.content.gsub('#', '%23') if format == 'utf8'
+
+    # ...Or return nil or a string, a start index, and an end index of text to substitute.
+    ["[ref]#{asset.content.gsub('#', '%23')}[/ref]", match.begin(0), match.end(0)]
+  end
+end
+```
+
+#### Parsing
+
+More generalized parsing of any asset-specific text of interest can be performed with `parse` calls, which
+take a name, regex, and block that returns the substitution for the matched text.
+
+
+```ruby
+Darkroom.register('.ext1', '.ext2', '...') do
+  # ...
+
+  # The block is passed two keyword arguments:
+  #   parse_data: - Hash for storing data across calls to this and other parse handlers.
+  #   match:      - MatchData object from the match against the provided regex.
+  parse(:exports, /export (?<name>.+)/) do |parse_data:, match:|
+    parse_data[:exports] ||= []          # Accumulate and use arbitrary parse data.
+    parse_data[:exports] << match[:name] # Use the MatchData object of the regex match.
+
+    # Return nil for default behavior (matched text is removed).
+    nil
+
+    # ...Or return a string as the replacement for the matched text.
+    "exports.#{match[:name]} = "
+
+    # ...Or return a string, a start index, and an end index of text to substitute.
+    [match[:name].upcase, match.begin(:name), match.end(:name)]
+  end
+
+  # Any number of parse statements are allowed and are run in the order they are declared.
+  parse(:something_else, /.../) do |parse_data:, match:|
+    # ...
+  end
+end
+end
+```
+
+#### Compile
+
+Compilation allows for a library to require (optional), a delegate to use after compilation (optional), and
+a block that returns the compiled version of the asset's own content.
+
+```ruby
+Darkroom.register('.ext1', '.ext2', '...') do
+  # ...
+
+  # The block is passed three keyword arguments:
+  #   parse_data:  - Hash of data collected during parsing.
+  #   path:        - Path of the asset being compiled.
+  #   own_content: - Asset's own content (without imports).
+  compile(lib: 'compile_lib', delegate: SomeDelegate) do |parse_data:, path:, own_content:|
+    CompileLib.compile(own_content)
+  end
+end
+```
+
+#### Finalize
+
+Finalization happens once an asset is fully processed and compiled (though before minification). A library
+can be provided to require (optional) and the block should return the finalized version of the asset's
+compiled content.
+
+```ruby
+Darkroom.register('.ext1', '.ext2', '...') do
+  # ...
+
+  # The block is passed three keyword arguments:
+  #   parse_data: - Hash of data collected during parsing.
+  #   path:       - Path of the asset being finalized.
+  #   content:    - Asset's compiled content (with imports prepended).
+  finalize(lib: 'finalize_lib') do |parse_data:, path:, content:|
+    FinalizeLib.finalize(content)
+  end
+end
+```
+
+#### Minify
+
+Minification is the very last thing that happens to an asset's content, though it will only happen if
+minification is enabled on the Darkroom instance. A library can be provided to require (optional) and the
+block should return the minified version of the asset's finalized content.
+
+```ruby
+Darkroom.register('.ext1', '.ext2', '...') do
+  # ...
+
+  # The block is passed three keyword arguments:
+  #   parse_data: - Hash of data collected during parsing.
+  #   path:       - Path of the asset being finalized.
+  #   content:    - Asset's finalized content.
+  minify(lib: 'minify_lib') do |parse_data:, path:, content:|
+    MinifyLib.compress(content)
+  end
+end
 
 ```
 

data/VERSION

@@ -1 +1 @@
-0.0.8
+0.0.9

data/lib/darkroom/asset.rb

@@ -129,29 +129,19 @@ class Darkroom
       @entry
     end
 
-    ##
-    # DEPRECATED: use #entry? instead. Returns boolean indicating whether or not the asset is marked as
-    # internal.
-    #
-    def internal?
-      Darkroom.deprecated("#{self.class.name}#internal? is deprecated: use #entry? instead")
-
-      !entry?
-    end
-
     ##
     # Returns boolean indicating whether or not an error was encountered the last time the asset was
     # processed.
     #
     def error?
-      !@errors.empty?
+      @errors && !@errors.empty?
     end
 
     ##
     # Returns ProcessingError wrapper of all errors if any exist, or nil if there are none.
     #
     def error
-      @error ||= @errors.empty? ? nil : ProcessingError.new(@errors)
+      @error ||= error? ? ProcessingError.new(@errors) : nil
     end
 
     ##
@@ -261,7 +251,7 @@ class Darkroom
     # Returns high-level object info string.
     #
     def inspect
-      "#<#{self.class}: "\
+      "#<#{self.class} "\
         "@entry=#{@entry.inspect}, "\
         "@errors=#{@errors.inspect}, "\
         "@extension=#{@extension.inspect}, "\
@@ -286,7 +276,7 @@ class Darkroom
       @modified_key == @darkroom.process_key ? (return @modified) : @modified_key = @darkroom.process_key
 
       begin
-        @modified = !!@error
+        @modified = error?
         @modified ||= (@mtime != (@mtime = File.mtime(@file)))
         @modified ||= @intermediate_asset.modified? if @intermediate_asset
         @modified ||= dependencies.any? { |d| d.modified? }

data/lib/darkroom/darkroom.rb

@@ -41,10 +41,6 @@ class Darkroom
 
       delegate = Class.new(Delegate, &block)
       delegate.content_type(content_type) if content_type && !delegate.content_type
-    elsif delegate.kind_of?(Hash)
-      deprecated("#{self.name}.register with a Hash is deprecated: use the Delegate DSL inside a block "\
-        'instead')
-      delegate = Delegate.deprecated_from_hash(**delegate)
     elsif delegate && delegate < Delegate
       delegate = block ? Class.new(delegate, &block) : delegate
     end
@@ -90,34 +86,16 @@ class Darkroom
   # [minify:] Boolean specifying whether or not to minify assets.
   # [minified:] String, regex, or array of strings and regexes specifying paths of assets that are already
   #             minified and thus should be skipped for minification.
-  # [minified_pattern:] DEPRECATED: use +minified:+ instead. Regex used against asset paths to determine if
-  #                     they are already minified and should therefore be skipped over for minification.
-  # [internal_pattern:] DEPRECATED: use +entries:+ instead. Regex used against asset paths to determine if
-  #                     they should be marked as internal and therefore made inaccessible externally.
   # [min_process_interval:] Minimum time required between one run of asset processing and another.
   #
   def initialize(*load_paths, host: nil, hosts: nil, prefix: nil, pristine: nil, entries: nil,
-      minify: false, minified: DEFAULT_MINIFIED, minified_pattern: nil, internal_pattern: nil,
-      min_process_interval: MIN_PROCESS_INTERVAL)
+      minify: false, minified: DEFAULT_MINIFIED, min_process_interval: MIN_PROCESS_INTERVAL)
     @load_paths = load_paths.map { |load_path| File.expand_path(load_path) }
 
     @hosts = (Array(host) + Array(hosts)).map! { |host| host.sub(TRAILING_SLASHES, '') }
     @entries = Array(entries)
     @minify = minify
     @minified = Array(minified)
-    @internal_pattern = internal_pattern
-
-    if minified_pattern
-      self.class.deprecated("#{self.class.name} :minified_pattern is deprecated: use :minified instead "\
-        'and pass a string, regex, or array of strings and regexes')
-      @minified = [minified_pattern]
-    end
-
-    if @internal_pattern
-      self.class.deprecated("#{self.class.name} :internal_pattern is deprecated: use :entries to instead "\
-        'specify which assets are entry points (i.e. available externally) and pass a string, regex, or '\
-        'array of strings and regexes')
-    end
 
     @prefix = prefix&.sub(TRAILING_SLASHES, '')
     @prefix = nil if @prefix && @prefix.empty?
@@ -316,11 +294,10 @@ class Darkroom
   # Returns high-level object info string.
   #
   def inspect
-    "#<#{self.class}: "\
+    "#<#{self.class} "\
       "@entries=#{@entries.inspect}, "\
       "@errors=#{@errors.inspect}, "\
       "@hosts=#{@hosts.inspect}, "\
-      "@internal_pattern=#{@internal_pattern.inspect}, "\
       "@last_processed_at=#{@last_processed_at.inspect}, "\
       "@load_paths=#{@load_paths.inspect}, "\
       "@min_process_interval=#{@min_process_interval.inspect}, "\
@@ -342,8 +319,6 @@ class Darkroom
   def entry?(path)
     if @pristine.include?(path)
       true
-    elsif @internal_pattern && @entries.empty?
-      !path.match?(@internal_pattern)
     elsif @entries.empty?
       true
     else

data/lib/darkroom/delegate.rb

@@ -35,8 +35,8 @@ class Darkroom
     # [regex] Regex for finding import statements. Must contain a named component called +path+ (e.g.
     #         <tt>/^import (?<path>.*)/</tt>).
     # [&handler] Block for special handling of import statements (optional). Should
-    #            <tt>throw(:error, '...')</tt> on error. Passed three arguments:
-    #            * +parse_data:+ - Hash for storing data across calls to this and other parsing handlers.
+    #            <tt>throw(:error, '...')</tt> on error. Passed three keyword arguments:
+    #            * +parse_data:+ - Hash for storing data across calls to this and other parse handlers.
     #            * +match:+ - MatchData object from the match against +regex+.
     #            * +asset:+ - Asset object of the asset being imported.
     #            Return value is used as the substitution for the import statement, with optional second and
@@ -54,10 +54,10 @@ class Darkroom
     #         * +entity+ - Desired entity ('path' or 'content').
     #         * +format+ - Format to use (see Asset::REFERENCE_FORMATS).
     # [&handler] Block for special handling of references (optional). Should <tt>throw(:error, '...')</tt>
-    #            on error. Passed four arguments:
-    #            * +parse_data:+ - Hash for storing data across calls to this and other parsing handlers.
+    #            on error. Passed four keyword arguments:
+    #            * +parse_data:+ - Hash for storing data across calls to this and other parse handlers.
     #            * +match:+ - MatchData object from the match against +regex+.
-    #            * +asset:+ - Asset object of the asset being imported.
+    #            * +asset:+ - Asset object of the asset being referenced.
     #            * +format:+ - Format of the reference (see Asset::REFERENCE_FORMATS).
     #            Return value is used as the substitution for the reference, with optional second and third
     #            values as integers representing the start and end indexes of the match to replace.
@@ -73,8 +73,8 @@ class Darkroom
     #        subclassing another Delegate, can be used to override the parent class's regex and handler.
     # [regex] Regex to match against.
     # [&handler] Block for handling matches of the regex. Should <tt>throw(:error, '...')</tt>
-    #            on error. Passed two arguments:
-    #            * +parse_data:+ - Hash for storing data across calls to this and other parsing handlers.
+    #            on error. Passed two keyword arguments:
+    #            * +parse_data:+ - Hash for storing data across calls to this and other parse handlers.
     #            * +match:+ - MatchData object from the match against +regex+.
     #            Return value is used as the substitution for the reference, with optional second and third
     #            values as integers representing the start and end indexes of the match to replace.
@@ -90,10 +90,10 @@ class Darkroom
     # [lib:] Name of a library to +require+ that is needed by the handler (optional).
     # [delegate:] Another Delegate to be used after the asset is compiled (optional).
     # [&handler] Block to call that will return the compiled version of the asset's own content. Passed
-    #            three arguments when called:
-    #.           * +parse_data:+ - Hash of data collected during parsing.
-    #            * +path+ - Path of the asset being compiled.
-    #            * +own_content+ - Asset's own content.
+    #            three keyword arguments when called:
+    #            * +parse_data:+ - Hash of data collected during parsing.
+    #            * +path:+ - Path of the asset being compiled.
+    #            * +own_content:+ - Asset's own content (without imports).
     #            Asset's own content is set to the value returned.
     #
     def self.compile(lib: nil, delegate: nil, &handler)
@@ -106,11 +106,11 @@ class Darkroom
     # Configures finalize behavior.
     #
     # [lib:] Name of a library to +require+ that is needed by the handler (optional).
-    # [&handler] Block to call that will return the completed version of the asset's overall content. Passed
-    #            three arguments when called:
-    #.           * +parse_data:+ - Hash of data collected during parsing.
-    #            * +path+ - Path of the asset being finalized.
-    #            * +content+ - Asset's content (with imports prepended).
+    # [&handler] Block to call that will return the finalized version of the asset's compiled content (with
+    #            imports prepended). Passed three keyword arguments when called:
+    #            * +parse_data:+ - Hash of data collected during parsing.
+    #            * +path:+ - Path of the asset being finalized.
+    #            * +content:+ - Asset's compiled content (with imports prepended).
     #            Asset's content is set to the value returned.
     #
     def self.finalize(lib: nil, &handler)
@@ -122,11 +122,11 @@ class Darkroom
     # Configures minification.
     #
     # [lib:] Name of a library to +require+ that is needed by the handler (optional).
-    # [&handler] Block to call that will return the minified version of the asset's overall content. Passed
-    #            three arguments when called:
-    #.           * +parse_data:+ - Hash of data collected during parsing.
-    #            * +path+ - Path of the asset being finalized.
-    #            * +content+ - Finalized asset's content.
+    # [&handler] Block to call that will return the minified version of the asset's finalized content.
+    #            Passed three keyword arguments when called:
+    #            * +parse_data:+ - Hash of data collected during parsing.
+    #            * +path:+ - Path of the asset being minified.
+    #            * +content:+ - Asset's finalized content.
     #            Asset's minified content is set to the value returned.
     #
     def self.minify(lib: nil, &handler)
@@ -169,69 +169,5 @@ class Darkroom
         yield(kind, regex, handler)
       end
     end
-
-    ##
-    # DEPRECATED: subclass Delegate and use its DSL instead. Returns a subclass of Delegate configured using
-    # the supplied Hash.
-    #
-    def self.new(**params)
-      Darkroom.deprecated("#{self.name}::new is deprecated: use the DSL inside a child class or a block "\
-        'passed to Darkroom.register')
-
-      deprecated_from_hash(**params)
-    end
-
-    ##
-    # DEPRECATED: subclass Delegate and use its DSL instead. Returns a subclass of Delegate configured using
-    # the supplied Hash.
-    #
-    def self.deprecated_from_hash(content_type:, import_regex: nil, reference_regex: nil,
-        validate_reference: nil, reference_content: nil, compile_lib: nil, compile: nil, compiled: nil,
-        minify_lib: nil, minify: nil)
-      Class.new(Delegate) do
-        self.content_type(content_type)
-
-        @import_regex = import_regex
-        @reference_regex = reference_regex
-
-        self.import(import_regex) if import_regex
-
-        if validate_reference || reference_content
-          @validate_reference = validate_reference
-          @reference_content = reference_content
-
-          self.reference(reference_regex) do |parse_data:, match:, asset:, format:|
-            error_message = validate_reference&.call(asset, match, format)
-            error(error_message) if error_message
-
-            reference_content&.call(asset, match, format)
-          end
-        elsif reference_regex
-          self.reference(reference_regex)
-        end
-
-        if compile
-          self.compile(lib: compile_lib, delegate: compiled) do |parse_data:, path:, own_content:|
-            compile.call(path, own_content)
-          end
-        elsif compile_lib || compiled
-          self.compile(lib: compile_lib, delegate: compiled)
-        end
-
-        if minify
-          self.minify(lib: minify_lib) do |parse_data:, path:, content:|
-            minify.call(content)
-          end
-        end
-      end
-    end
-
-    ##
-    # DEPRECATED: subclass Delegate and use its DSL instead.
-    #
-    def self.import_regex() @import_regex end
-    def self.reference_regex() @reference_regex end
-    def self.validate_reference() @validate_reference end
-    def self.reference_content() @reference_content end
   end
 end

data/lib/darkroom/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Darkroom
-  VERSION = '0.0.8'
+  VERSION = '0.0.9'
 end

data/lib/darkroom.rb

@@ -10,7 +10,10 @@ require('darkroom/delegates/html')
 require('darkroom/delegates/htx')
 require('darkroom/delegates/javascript')
 
+Darkroom.register('.apng', 'image/apng')
+Darkroom.register('.avif', 'image/avif')
 Darkroom.register('.css', Darkroom::CSSDelegate)
+Darkroom.register('.gif', 'image/gif')
 Darkroom.register('.htm', '.html', Darkroom::HTMLDelegate)
 Darkroom.register('.htx', Darkroom::HTXDelegate)
 Darkroom.register('.ico', 'image/x-icon')
@@ -20,5 +23,6 @@ Darkroom.register('.json', 'application/json')
 Darkroom.register('.png', 'image/png')
 Darkroom.register('.svg', 'image/svg+xml')
 Darkroom.register('.txt', 'text/plain')
+Darkroom.register('.webp', 'image/webp')
 Darkroom.register('.woff', 'font/woff')
 Darkroom.register('.woff2', 'font/woff2')

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: darkroom
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Nate Pickens
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-07-16 00:00:00.000000000 Z
+date: 2025-01-21 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -28,22 +42,16 @@ dependencies:
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 5.11.2
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: '5.21'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 5.11.2
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: '5.21'
 description: Darkroom provides web asset compilation, bundling, and minification without
   any external tools, manifest files, or special comment syntax. CSS and JavaScript
   bundles are automatically generated based on import statements native to each language.
@@ -53,6 +61,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
 - README.md
 - VERSION
@@ -77,9 +86,10 @@ homepage: https://github.com/npickens/darkroom
 licenses:
 - MIT
 metadata:
-  allowed_push_host: https://rubygems.org
-  homepage_uri: https://github.com/npickens/darkroom
-  source_code_uri: https://github.com/npickens/darkroom
+  bug_tracker_uri: https://github.com/npickens/darkroom/issues
+  changelog_uri: https://github.com/npickens/darkroom/blob/master/CHANGELOG.md
+  documentation_uri: https://github.com/npickens/darkroom/blob/0.0.9/README.md
+  source_code_uri: https://github.com/npickens/darkroom/tree/0.0.9
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -93,9 +103,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 requirements: []
-rubygems_version: 3.4.15
+rubygems_version: 3.5.10
 signing_key:
 specification_version: 4
 summary: A fast, lightweight, and straightforward web asset management library.