jekyll_draft 2.0.0 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5123990f175f9d09091e7f092a202b075067497e9b17dabf3eda397c48d9b11e
-  data.tar.gz: 80f3912e94858f6ccc373d2a155f0b6f907c79c13ea6bb8495837d019656508b
+  metadata.gz: b8b48bd7048b0c4eb3836226b81c8da703f6573e5a564bf5c9ef22733be35167
+  data.tar.gz: 0ebe1a2cbbea83bb3f47fb3e512203a6aebfde0248cff99266e74a66536c99d7
 SHA512:
-  metadata.gz: 406222aeae0160d0ff1ef9c5c5d5ad9af0a4f357541dd43742a58c229bc6094343960c215efd498cee33d37fb76457aac1e6d0d5183c4f16277cbf044f4c0f79
-  data.tar.gz: eed26a657a04c4907700ef805fb41d67b2ed4842058f12918d3231035c46b2c6fe7c17b065a3a8c625410401f5376c86d3db4d40f607baa7e8c89320f623d6f5
+  metadata.gz: 4383047a610783981f175d29ccc86212c9b76a571ef587d06d29b487c3895e3e73737559ceeea25f4d849fe3a1fd5c64994b035378095ad355948f0bffe032b5
+  data.tar.gz: d2b9ec0decefb9c1b238c498c5a36735b1033362ff327c3d06760c9d0ce6a4e26bd2f657758403664f0b8a04914e8ad9396bdf6f383cac031849a2534d4e89dd

data/CHANGELOG.md

@@ -1,9 +1,37 @@
 # Change Log
 
+## 2.0.2 / 2024-07-24
+
+* Compatible with `jekyll_plugin_support` v1.0.0
+
+
+## 2.0.1 / 2024-02-07
+
+* Added Jekyll block tags `if_secret` and `unless_secret`.
+* Added Jekyll inline tags: `unless_draft_only`, `else_if_secret` and `else_if_not_secret`.
+* Added Liquid filter: `is_secret`.
+* Added method `draft_only?` and `secret?` to API module `Jekyll::Draft`.
+
+
+## 2.0.1 / 2023-11-30
+
+* Jekyll block tags: `if_draft` and `unless_draft`.
+* Jekyll inline tags: `else_if_not_draft` and `else_if_draft`.
+* Jekyll inline tag `draft_html`.
+* Liquid filters:
+  * `is_draft`
+  * `draft_html`
+* Module `Jekyll::Draft` defines an API with the following methods:
+  * `draft?` returns a boolean indicating if the document passed to it is a draft.
+  * `draft_html` returns the same string the `draft_html` tag returns,
+    indicating if the document passed to it is a draft.
+
+
 ## 2.0.0 / 2023-11-29
 
-* Made into a Jekyll block tag, because the filter implementation had problems with infinite recursing Jekyll exerpts.
-  This was a complete rewrite, incompatible with previous version.
+* This version was published prematurely by accident.
+  It is broken, do not use it.
+* This is a complete rewrite, incompatible with previous versions.
 
 
 ## 1.1.2 / 2023-02-25

data/README.md

@@ -1,59 +1,379 @@
 # jekyll_draft [![Gem Version](https://badge.fury.io/rb/jekyll_draft.svg)](https://badge.fury.io/rb/jekyll_draft)
 
-This is a Jekyll plugin that provides two Liquid filters: `is_draft` and `draft_html`.
+Jekyll has various ways of specifying that a page or document is
+visible when the website is published in `production` mode.
+The Jekyll documentation is scattered and incomplete regarding this topic.
+This plugin’s filters provide a simple means for marking draft pages in `development` mode.
+
+A secret document is a special form of a draft document.
+Secrets are always drafts, but not the converse.
+
+`Jekyll_draft` provides the following:
+
+* Jekyll block tags: `if_draft` and `unless_draft`.
+* Jekyll block tags: `if_secret` and `unless_secret`.
+* Jekyll inline tags: `else_if_not_draft`, `else_if_draft`, `else_if_not_secret` and `else_if_secret`.
+  These are meant for use within `if_draft`, `unless_draft`, `if_secret` and `unless_secret`, respectively.
+  Both of them are identical; they are both provided so usage seems natural.
+* Jekyll inline tag `draft_html`, which generates HTML that indicates if the document
+  it is embedded within is a draft or a secret.
+* Liquid filters:
+  * `is_draft` returns a boolean indicating if the document passed to it is a draft.
+  * `is_secret` returns a boolean indicating if the document passed to it is a secret.
+  * `draft_html` returns the same string the `draft_html` tag returns,
+    indicating if the document passed to it is a draft.
+* Module `Jekyll::Draft` defines an API that your plugin can call.
+  It has the following methods:
+  * `draft?` returns a boolean indicating if the document passed to it is a draft or a secret.
+  * `draft_only?` returns a boolean indicating if the document passed to it is a draft and not a secret.
+  * `draft_html` returns the same string that `draft_html` tag returns;
+    the response indicates if the document passed to it is a draft.
+  * `root` returns the path to the root of the collection that the document passed to it is a member of.
+    This method is not functionally related to Jekyll draft documents;
+    it should be packaged separately ... maybe one day...
+  * `secret?` returns a boolean indicating if the document passed to it is a draft.
+
+The difference between the tag called `draft_html` and the filter of the same name
+is that the tag only works on the document that it is embedded in,
+while the filter works on any document passed to it.
+Both the tag and the filter call the same API methods defined in the `Jekyll::Draft` module.
+
+More information is available on [Mike Slinn’s website](https://www.mslinn.com/jekyll_plugins/jekyll_draft.html).
+
+
+## Front Matter
+
+To mark a blog as a draft, put it in the `_drafts` directory.
+
+To mark any other article as a draft, add the following to its front matter:
+
+```text
+published: false
+```
+
+To mark any article (including blog posts) as a secret, add the following to its front matter:
+
+```text
+secret: true
+```
+
+Secret documents are a type of draft document, so the above implies:
+
+```text
+published: false
+secret: true
+```
+
+
+## Demo
+
+The [demo](demo) subdirectory has working examples of this Jekyll plugin's functionality
+in a demonstration website.
+It can be used to debug the plugin or it can run freely.
+Please examine the <code>HTML</code> files in the demo to see how the plugin works.
+
+To run the demo freely from the command line, type:
+
+```console
+$ demo/_bin/debug -r
+```
 
-More information is available on my website about [my Jekyll plugins](https://www.mslinn.com/blog/2020/10/03/jekyll-plugins.html#draft).
+Now point your web browser to http://localhost:4444.
+You should see:
+
+![jekyll_draft demo](jekyll_draft_demo.png)
+
+When the demonstration is running, any time you modify the <code>.html</code> files,
+the demo website will regenerate.
+Each time you make a change, the website instantly regenerates.
+This helps the learning experience.
+
+Please play with the contents of the <code>.html</code> files,
+so you can learn how to write Jekyll pages that include this functionality.
 
 
 ## Installation
 
-Add the following to your CSS:
+### For Use In A Jekyll Website
+
+1. Add the CSS found in [`demo/assets/css/jekyll_draft.css`](demo/assets/css/jekyll_draft.css) to your Jekyll layout(s).
+
+2. Add the following to your Jekyll website's `Gemfile`, within the `jekyll_plugins` group:
+
+   ```ruby
+   group :jekyll_plugins do
+     gem 'jekyll_draft', '>2.0.0' # v2.0.0 was a dud, do not use it
+   end
+   ```
+
+3. Type:
+
+   ```shell
+   $ bundle
+   ```
+
+
+### For Use In a Gem
+
+1. Add the following to your gem&rsquo;s `.gemspec`:
+
+   ```ruby
+   spec.add_dependency 'jekyll_draft', '>2.0.0' # v2.0.0 was a dud, do not use it
+   ```
+
+2. Type:
+
+   ```shell
+   $ bundle
+   ```
+
+
+## Usage in a Web Page
 
-```css
-.jekyll_draft {
-  background-color: #fefeab;
-  padding-bottom: 2px;
-  padding-left: 0.5em;
-  padding-right: 0.5em;
-  padding-top: 2px;
-}
+### `if_draft`, `unless_draft`, `if_secret` and `unless_secret` Block Tags
+
+The `if_draft` and `if_secret` block tags acts as `if-then` or `if-then-else` programming constructs.
+
+The following generates `<p>This is a draft or a secret document!</p>`
+if the document it is embedded in is a draft, and the Jekyll website generation was performed in development mode:
+
+```html
+{% if_draft %}
+  <p>This is a draft or a secret document!</p>
+{% endif_draft %}
 ```
 
-Add this line to your Jekyll website's `Gemfile`, within the `jekyll_plugins` group:
+The following generates `<p>This is a draft document!</p>`
+if the document it is embedded in is a draft and not a secret, and the Jekyll website generation was performed in development mode:
 
-```ruby
-group :jekyll_plugins do
-  gem 'jekyll_draft'
-end
+```html
+{% if_draft_only %}
+  <p>This is a draft document!</p>
+{% endif_draft %}
 ```
 
-And then execute:
+The following generates `<p>This is a secret document!</p>`
+if the document it is embedded in is a secret, and the Jekyll website generation was performed in development mode:
 
-```shell
-$ bundle
+```html
+{% if_secret %}
+  <p>This is a secret document!</p>
+{% endif_draft %}
 ```
 
+The following enhances the previous example by also generating `<p>This is not a draft or a secret document!</p>`
+when in production mode:
 
-## Usage
+```html
+{% if_draft %}
+  <p>This is a draft or a secret document!</p>
+{% else_if_not_secret %}
+  <p>This is not a secret document, but might be a draft!</p>
+{% else_if_not_draft %}
+  <p>This is not a draft or a secret document!</p>
+{% endif_draft %}
+```
 
-### `is_draft`
+The `unless_draft`, `unless_draft_only` and `unless_secret` block tags acts as Ruby
+[unless-then](https://rubystyle.guide/#unless-for-negatives) or
+an [unless-then-else](https://rubystyle.guide/#no-else-with-unless) programming constructs.
 
-This filter detects if a page is invisible when published in  `production` mode,
-and either returns `true` or `false`.
+```html
+{% unless_draft %}
+  <p>This is not a draft or a secret document!</p>
+{% endunless_draft %}
+```
 
 ```html
-{{ page | is_draft }} => true
+{% unless_draft_only %}
+  <p>This is not a draft document, but might be a secret!</p>
+{% endunless_draft %}
 ```
 
-### `draft_html`
+```html
+{% unless_secret %}
+  <p>This is not a secret document, but might be a draft!</p>
+{% endunless_draft %}
+```
 
-This filter generates HTML to display if a page is invisible when published in `production` mode.
+This is how you can specify an `else` clause for `unless_draft`:
+
+```html
+{% unless_draft %}
+  <p>This is not a draft document!</p>
+{% else_if_draft %}
+  <p>This is a draft document!</p>
+{% endunless_draft %}
+```
+
+```html
+{% unless_draft %}
+  <p>This is not a draft document!</p>
+{% else_if_draft %}
+  <p>This is a draft or a secret document!</p>
+{% else_if_draft_only %}
+  <p>This is a draft document!</p>
+{% else_if_secret %}
+  <p>This is a secret document!</p>
+{% endunless_draft %}
+```
+
+You can use the keywords `else_if_draft` and `else_if_not_draft` interchangeably.
+They are actually made by registering the same code twice with different subclass names.
+Use the keyword that makes the most sense to you.
+
+
+### `draft_html` Inline Tag
+
+Here is an example of embedding the `draft_html` inline tag into an HTML document:
+
+```html
+  <p>Is this a draft document? Look here to see: {% draft_html %}</p>
+```
+
+By default, if the document is a draft or a secret, and the Jekyll website generation was performed in development mode,
+`draft_html` emits ` <i class='jekyll_draft>Draft</i>` or ` <i class='jekyll_secret>Secret</i>` ,
+otherwise it does not emit anything.
+
+You can change this behavior several ways:
+
+* Add the `published_output` parameter to specify the HTML that should be emitted if the document is not a draft or a secret,
+and the Jekyll website generation was performed in development mode.
+The default message will continue to be output for draft documents when the `published_output` parameter is used.
+
+  ```html
+  {% draft_html published_output="<p>Not a draft or a secret</p>" %}
+  ```
+
+* Add the `draft_output` parameter to specify the HTML that should be emitted if the document is a draft,
+the `secret_output` parameter to specify the HTML that should be emitted if the document is a secret,
+and the Jekyll website generation was performed in development mode:
+
+  ```html
+  {% draft_html
+    draft_output="<p>Is a draft</p>"
+  %}
+  {% draft_html
+    draft_output="<p>Is a draft</p>"
+    published_output="<p>Not a draft</p>"
+  %}
+  {% draft_html
+    secret_output="<p>Is a secret</p>"
+  %}
+  {% draft_html
+    draft_output="<p>Is a draft</p>"
+    published_output="<p>Not a draft or a secret</p>"
+    secret_output="<p>Is a secret</p>"
+  %}
+  ```
+
+* Add the `draft_class` parameter to specify the CSS class that should be added
+  to the emitted HTML if the document is a draft,
+  add the `secret_class` parameter to specify the CSS class that should be added
+  to the emitted HTML if the document is a secret,
+  and the Jekyll website generation was performed in development mode:
+
+  ```html
+  {% draft_html draft_class="my_draft_class" %}
+  {% draft_html
+    draft_class="my_draft_class"
+    published_output="<p>Not a draft or a secret</p>"
+  %}
+  {% draft_html draft_class="my_draft_class" secret_class="my_secret_class" %}
+  {% draft_html
+    draft_class="my_draft_class"
+    published_output="<p>Not a draft or a secret</p>"
+    secret_class="my_secret_class"
+  %}
+  ```
+
+* Add the `draft_style` parameter to specify the CSS class that should be added
+  to the emitted HTML if the document is a draft,
+  and the Jekyll website generation was performed in development mode:
+
+  ```html
+  {% draft_html draft_style="font-size: 24pt;" %}
+  {% draft_html secret_style="font-size: 24pt; color: red;" %}
+  {% draft_html
+    draft_class="my_draft_class"
+    draft_style="font-size: 24pt;"
+    secret_class="my_secret_class"
+    secret_style="font-size: 24pt; color: red;"
+  %}
+  {% draft_html
+    draft_class="my_draft_class"
+    draft_style="font-size: 24pt;"
+    published_output="<p>Not a draft or a secret</p>"
+    secret_class="my_secret_class"
+    secret_style="font-size: 24pt; color: red;"
+  %}
+  ```
+
+
+### Liquid Filters
+
+#### `draft_html`
+
+By default, the draft_html Liquid filter generates HTML if a page is invisible when published in `production` mode.
 If the page is not a draft then the empty string is returned.
-The generated HTML for draft pages is:<br>
-`" &lt;i class='jekyll_draft'>Draft&lt;/i>"`
+
+The optional parameters for the `draft_html` inline tag are not available for
+use with the `draft_html` filter.
+
+The default generated HTML for draft pages is:<br>
+`" <i class='jekyll_draft'>Draft</i>"`
+
+The default generated HTML for secret pages is:<br>
+`" <i class='jekyll_secret'>Secret</i>"`
+
+Invoke the filter like the following; the output depends on whether the document is a draft or a secret:
+
+```html
+{{ page | draft_html }} => " <i class='jekyll_draft'>Draft</i>"
+{{ page | draft_html }} => " <i class='jekyll_secret'>Secret</i>"
+```
+
+Here is a code snippet that shows the <code>draft_html</code> filter in use:
+
+```html
+{% assign docs = site.myCollection | sort: "order" %}
+<ol id="titles">
+{% for doc in docs %}
+  <li>
+    <a href="{{doc.url}}" class="title">{{doc.title}}</a>{{ doc | draft_html }}
+  </li>
+{% endfor %}
+</ol>
+```
+
+
+#### `is_draft`
+
+This filter detects if a page is invisible when published in `production` mode,
+and either returns `true` or `false`.
+
+```html
+{{ page | is_draft }} <!-- true for draft and secret documents in development mode -->
+```
+
+
+#### `is_draft_only`
+
+This filter detects if a page is invisible when published in `production` mode,
+and either returns `true` or `false`.
+
+```html
+{{ page | is_draft_only }} <!-- true for draft documents in development mode, but not secret documents -->
+```
+
+
+#### `is_secret`
+
+This filter detects if a page is invisible when published in `production` mode,
+and either returns `true` or `false`.
 
 ```html
-{{ page | draft_html }} => " <i class='bg_light_yellow' style='padding-left: 0.5em; padding-right: 0.5em;'>Draft</i>"
+{{ page | is_secret }} <!-- true for secret documents in development mode, but not draft documents -->
 ```
 
 
@@ -62,32 +382,50 @@ The generated HTML for draft pages is:<br>
 ```ruby
 require 'jekyll_draft'
 
-puts 'Found a draft' if Jekyll::Draft.is_draft post
+puts 'Found a draft or a secret' if Jekyll::Draft.is_draft post
 
-draft = Jekyll::Draft.draft_html post
+draft_or_secret = Jekyll::Draft.draft_html post
 ```
 
 
-## Demo
+## Usage in a Plugin
 
-The [`demo`](./demo) directory contains a demonstration website, which uses the plugin.
-To run, type:
+The methods in `lib/draft_html.rb` can be invoked by qualifying them with `Jekyll::Draft`.
+Here is a complete example of a Jekyll Support plugin that displays an indication of whether the page is a draft or not:
 
-```console
-$ demo/_bin/debug -r
-```
+```ruby
+require 'jekyll_plugin_support'
+
+module MyPluginTag
+  MyPluginError = JekyllSupport.define_error
+  PLUGIN_NAME = 'my_plugin'.freeze
+  VERSION = '0.1.0'.freeze
+
+  class MyPluginTag < JekyllSupport::JekyllTag
+    def render_impl
+      <<~HEREDOC
+        Draft or not? #{Jekyll::Draft.draft_html(@page)}
+      HEREDOC
+    end
+  end
+end
 
-Now point your web browser to http://localhost:4444
+Liquid::Template.register_tag(MyPluginTag::PLUGIN_NAME, MyPluginTag::MyPluginTag)
+PluginMetaLogger.instance.info { "Loaded #{MyPluginTag::PLUGIN_NAME} v#{MyPluginTag::VERSION} plugin." }
+```
 
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+### Setup
+
+After checking out the repo, run `bin/setup` to install dependencies.
+You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 Install development dependencies like this:
 
 ```shell
-$ BUNDLE_WITH="development" bundle
+$ BUNDLE_WITH=development bundle
 ```
 
 To install this gem onto your local machine, run:
@@ -96,39 +434,72 @@ To install this gem onto your local machine, run:
 $ bundle exec rake install
 ```
 
-To release a new version,
-
-  1. Update the version number in `version.rb`.
-  2. Commit all changes to git; if you don't the next step might fail with an unexplainable error message.
-  3. Run the following:
-
-     ```shell
-     $ bundle exec rake release
-     ```
+### Debugging The Demo
 
-     The above creates a git tag for the version, commits the created tag,
-     and pushes the new `.gem` file to [RubyGems.org](https://rubygems.org).
+Set breakpoints, then use the Visual Studio Code launch configuration called `Debug Demo`.
 
 
-### Debugging
+### Debugging From Another Jekyll Site
 
 Run `bin/attach` and pass the directory name of a Jekyll website that has a suitable script called `_bin/debug`.
 The `demo` subdirectory fits this description.
 
 ```console
 $ bin/attach demo
-Successfully uninstalled jekyll_draft-0.1.0
-jekyll_draft 0.1.0 built to pkg/jekyll_draft-0.1.0.gem.
-jekyll_draft (0.1.0) installed.
-Fast Debugger (ruby-debug-ide 0.7.3, debase 0.2.4.1, file filtering is supported) listens on 0.0.0.0:1234
+Successfully uninstalled jekyll_draft-1.1.2
+Successfully uninstalled jekyll_draft-2.0.0
+jekyll_draft 2.0.0 built to pkg/jekyll_draft-2.0.0.gem.
+jekyll_draft (2.0.0) installed.
+jekyll_draft 2.0.0 built to pkg/jekyll_draft-2.0.0.gem.
+jekyll_draft (2.0.0) installed.
+Fetching gem metadata from https://rubygems.org/..........
+Resolving dependencies...
+Bundle complete! 21 Gemfile dependencies, 104 gems now installed.
+Use `bundle info [gemname]` to see where a bundled gem is installed.
+
+
+INFO PluginMetaLogger: Loaded else_if_draft v0.1.0 plugin.
+INFO PluginMetaLogger: Loaded else_if_not_draft v0.1.0 plugin.
+INFO PluginMetaLogger: Loaded String and String, v2.0.0 plugin.
+INFO PluginMetaLogger: Loaded if_draft v2.0.0 plugin.
+INFO PluginMetaLogger: Loaded unless_draft v2.0.0 plugin.
+INFO PluginMetaLogger: Loaded String and String, v2.0.0 plugin.
+INFO PluginMetaLogger: Loaded exec v1.4.2 plugin.
+INFO PluginMetaLogger: Loaded noselect v1.4.2 plugin.
+INFO PluginMetaLogger: Loaded pre v1.4.2 plugin.
+INFO PluginMetaLogger: Loaded jekyll_pre v1.4.2 plugin.
+Configuration file: /mnt/f/work/jekyll/my_plugins/jekyll_draft/demo/_config.yml
+           Cleaner: Removing /mnt/f/work/jekyll/my_plugins/jekyll_draft/demo/_site...
+           Cleaner: Removing /mnt/f/work/jekyll/my_plugins/jekyll_draft/demo/.jekyll-metadata...
+           Cleaner: Removing /mnt/f/work/jekyll/my_plugins/jekyll_draft/demo/.jekyll-cache...
+           Cleaner: Nothing to do for .sass-cache.
+DEBUGGER: Debugger can attach via TCP/IP (127.0.0.1:45409)
+DEBUGGER: wait for debugger connection...
 ```
 
 Now attach to the debugger process.
-This git repo includes a [Visual Studio Code launcher](./.vscode/launch.json) for this purpose labeled `Listen for rdebug-ide`.
+This git repo includes a [Visual Studio Code launcher](.vscode/launch.json) for this purpose labeled `Attach rdbg`.
+It uses TCP/IP port 45409 to attach; you might need to modify that value.
 
 Now point your web browser to http://localhost:4444
 
 
+### Releasing A New Version
+
+To release a new version,
+
+  1. Update the version number in `version.rb`.
+  2. Commit all changes to git; if you don't the next step might fail with an unexplainable error message.
+  3. Run the following:
+
+     ```shell
+     $ bundle exec rake release
+     ```
+
+     The above creates a git tag for the version, commits the created tag,
+     and pushes the new `.gem` file to [RubyGems.org](https://rubygems.org).
+
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/mslinn/jekyll_draft.

data/jekyll_draft.gemspec

@@ -32,5 +32,5 @@ Gem::Specification.new do |spec| # rubocop:disable Metrics/BlockLength
   spec.version = DraftVersion::VERSION
 
   spec.add_dependency 'jekyll', '>= 3.5.0'
-  spec.add_dependency 'jekyll_plugin_support'
+  spec.add_dependency 'jekyll_plugin_support', '>=1.0.0'
 end

data/lib/draft.rb

@@ -1,29 +1,54 @@
+require 'jekyll_plugin_logger'
+
 # Define these methods outside of the JekyllDraft class so they can be invoked externally and tested more easily
-module Draft
-  # @return true by checking in this order:
-  #   - document is in _drafts directory, detectable by doc['draft']==true
-  #   - document front matter contains 'published: false'
-  def draft?(doc)
-    return true if doc.respond_to?(:draft) && doc.draft
-    return true if doc.key?('draft') && doc['draft'] # ignore !doc['draft']
-    return !doc['published'] if doc.key?('published')
-
-    false
-  rescue StandardError => e
-    @logger.error { e }
-    false
-  end
+module Jekyll
+  module Draft
+    @logger = PluginMetaLogger.instance.new_logger(self, PluginMetaLogger.instance.config)
 
-  # @param doc [Jekyll::Drops::DocumentDrop]
-  # @return HTML that indicates if a doc is a draft or not
-  def draft_html
-    return '' unless is_draft
+    # @return true by checking in this order:
+    #   - document is in _drafts directory, detectable by doc['draft']==true
+    #   - document front matter contains 'published: false'
+    def draft?(doc)
+      if doc.respond_to? :data
+        return !doc.data['published'] if doc.data.key? 'published'
+        return  doc.data['draft']     if doc.data.key? 'draft'
+      end
+      if doc.respond_to? :[]
+        return !doc['published'] if doc.key? 'published'
+        return  doc['draft']     if doc.key? 'draft'
+      end
 
-    " <i class='jekyll_draft'>Draft</i>"
-  rescue StandardError => e
-    @logger.error { e }
-    ''
-  end
+      return doc.draft if doc.respond_to? :draft
+
+      false
+    rescue StandardError => e
+      @logger.error { e }
+      false
+    end
+
+    # @param doc [Jekyll::Drops::DocumentDrop]
+    # @return HTML that indicates if a doc is a draft or not
+    def draft_html(doc)
+      return '' unless draft? doc
 
-  module_function :draft?, :draft_html
+      " <i class='jekyll_draft'>Draft</i>"
+    rescue StandardError => e
+      @logger.error { e.full_message }
+      ''
+    end
+
+    # @return path to root of the collection that doc is a member of
+    def root(doc, site)
+      return '/index.html' unless doc.respond_to?(:collection)
+
+      collection_name = doc.collection
+      docs = site.key?(collection_name) ? site[collection_name] : site.collections[collection_name].docs
+      index = docs.find { |d| d.url.end_with? 'index.html' }
+      return index.url if index
+
+      docs.min.url
+    end
+
+    module_function :draft?, :draft_html, :root
+  end
 end

data/lib/draft_html.rb

@@ -1,13 +1,27 @@
 require 'jekyll_plugin_support'
 
-class Else < JekyllSupport::JekyllTag
+class DraftHtml < JekyllSupport::JekyllTag
   VERSION = '0.1.0'.freeze
-  PLUGIN_NAME = 'else'.freeze
+  DRAFT_HTML = 'draft_html'.freeze unless defined? Else::VERSION
 
   def render_impl
-    " <i class='jekyll_draft'>Draft</i>" if Draft.draft?(@page)
+    is_draft = Jekyll::Draft.draft?(@page)
+
+    published_output = @helper.parameter_specified? 'published_output'
+    return published_output if !is_draft && published_output
+    return unless is_draft
+
+    draft_output = @helper.parameter_specified? 'draft_output'
+    return draft_output if draft_output
+
+    draft_class = @helper.parameter_specified? 'class'
+    dc = " #{draft_class}" if draft_class
+
+    draft_style = @helper.parameter_specified? 'style'
+    ds = " style='#{draft_style}'" if draft_style
+
+    " <i class='jekyll_draft#{dc}'#{ds}>Draft</i>"
   end
 
-  JekyllPluginHelper.register(self, PLUGIN_NAME)
-  PluginMetaLogger.instance.info { "Loaded #{PLUGIN_NAME.class} v#{DraftVersion::VERSION} plugin." }
+  ::JekyllSupport::JekyllPluginHelper.register(self, DRAFT_HTML)
 end

data/lib/else.rb

@@ -1,13 +1,19 @@
 require 'jekyll_plugin_support'
 
-class Else < JekyllSupport::JekyllTag
+class ElseBase < JekyllSupport::JekyllTag
   VERSION = '0.1.0'.freeze
-  PLUGIN_NAME = 'else'.freeze
+  ELSE_DRAFT = 'else_if_draft'.freeze
+  ELSE_NOT_DRAFT = 'else_if_not_draft'.freeze
 
   def render_impl
     RECORD_SEPARATOR
   end
+end
+
+class ElseDraft < ElseBase
+  ::JekyllSupport::JekyllPluginHelper.register(self, ELSE_DRAFT)
+end
 
-  JekyllPluginHelper.register(self, PLUGIN_NAME)
-  PluginMetaLogger.instance.info { "Loaded #{PLUGIN_NAME.class} v#{DraftVersion::VERSION} plugin." }
+class ElseNotDraft < ElseBase
+  ::JekyllSupport::JekyllPluginHelper.register(self, ELSE_NOT_DRAFT)
 end

data/lib/filters.rb

@@ -0,0 +1,21 @@
+require 'jekyll_plugin_logger'
+require 'yaml'
+
+# Jekyll filters that detect draft documents
+module Jekyll
+  module DraftFilter
+    def is_draft(doc) # rubocop:disable Naming/PredicateName
+      Draft.draft? doc
+    end
+
+    def draft_html(doc)
+      Draft.draft_html doc
+    end
+
+    def root(doc, site)
+      Draft.root(doc, site)
+    end
+  end
+
+  Liquid::Template.register_filter(DraftFilter)
+end

data/lib/if_draft.rb

@@ -1,17 +1,27 @@
 require 'jekyll_plugin_support'
 
-# Jekyll inline plugin that detects draft documents
-class JekyllDraft < JekyllSupport::JekyllBlock
-  PLUGIN_NAME = 'if_draft'.freeze
-  VERSION = DraftVersion::VERSION
+# Jekyll block tags that detect draft documents
+class DraftBase < JekyllSupport::JekyllBlock
+  IF_DRAFT     = 'if_draft'.freeze
+  UNLESS_DRAFT = 'unless_draft'.freeze
+  VERSION      = DraftVersion::VERSION.freeze
 
   def render_impl(content)
     true_value, false_value, extra = content.split(RECORD_SEPARATOR)
     raise DraftError, "Warning: More than one else clause detected" if extra
 
-    Draft.draft?(@page) ? true_value : false_value
+    if @tag_name == IF_DRAFT
+      return ::Jekyll::Draft.draft?(@page) ? true_value : false_value
+    end
+
+    ::Jekyll::Draft.draft?(@page) ? false_value : true_value
   end
+end
+
+class IfDraft < DraftBase
+  ::JekyllSupport::JekyllPluginHelper.register(self, IF_DRAFT)
+end
 
-  JekyllPluginHelper.register(self, PLUGIN_NAME)
-  PluginMetaLogger.instance.info { "Loaded #{PLUGIN_NAME.class} v#{DraftVersion::VERSION} plugin." }
+class UnlessDraft < DraftBase
+  ::JekyllSupport::JekyllPluginHelper.register(self, UNLESS_DRAFT)
 end

data/lib/jekyll_draft/version.rb

@@ -1,3 +1,3 @@
 module DraftVersion
-  VERSION = '2.0.0'.freeze
+  VERSION = '2.0.2'.freeze
 end

data/lib/jekyll_draft.rb

@@ -10,5 +10,7 @@ RECORD_SEPARATOR = "\u{241E}".freeze
 DraftError = JekyllSupport.define_error
 
 require_relative 'draft'
-require_relative 'else'
 require_relative 'if_draft'
+require_relative 'else'
+require_relative 'draft_html'
+require_relative 'filters'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jekyll_draft
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.2
 platform: ruby
 authors:
 - Mike Slinn
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-11-29 00:00:00.000000000 Z
+date: 2024-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jekyll
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.0.0
 description: 'This Jekyll filter detects draft documents.
 
   '
@@ -56,6 +56,7 @@ files:
 - lib/draft.rb
 - lib/draft_html.rb
 - lib/else.rb
+- lib/filters.rb
 - lib/if_draft.rb
 - lib/jekyll_draft.rb
 - lib/jekyll_draft/version.rb
@@ -91,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.5.16
 signing_key:
 specification_version: 4
 summary: This Jekyll filter detects draft documents.