jekyll-scry-content 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f17d351b63efd2828cef59265a122db52a4311378b5e67ddf5b5e02331d3c714
+  data.tar.gz: b2ca31b11f7d3c3633ae342f5acfe033a71487b805f90c95d56b13c6a5a53686
+SHA512:
+  metadata.gz: 5cc856945eba6bff100e2877a9f7329f51f79e4d9061736ff55af120006b9bada3dee7240fda2e5db9908f95d16c5bafc45469f649ed069f9973b869dbf3b3ea
+  data.tar.gz: bb5a0c9b2fcb2140c4436725c837d69681f4fc473df6054745ef400b070194a9299922bd47b4f5ba5585bd2a9c09cf09616bc7f356927377d4a843828762d986

data/LICENSE

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

data/README.md

@@ -0,0 +1,92 @@
+# jekyll-scry-content
+
+Jekyll plugin that discovers **Scry content gems** (`scry-*`), stages their `content/` files into the site source as symlinks, and merges optional config files referenced from each gem's manifest.
+
+## Install
+
+```ruby
+group :jekyll_plugins do
+  gem "jekyll-scry-content", "~> 0.3"
+  # Content gems can live in this group or outside it; discovery does not care.
+  gem "scry-rpg-callouts", "~> 1.0"
+end
+
+gem "scry-seers-sanctum", "~> 3.2"
+```
+
+```yaml
+# _config.yml
+plugins:
+  - jekyll-scry-content
+
+scry_content:
+  enabled: true
+  only: []
+  exclude: []
+  warn_missing_ruleset: true   # default true
+  warn_missing_content: true   # default true
+```
+
+Pin **gemspec** versions in the Gemfile (`~> 3.2`). Manifest `version` is the product/edition string and may differ; the loader logs both.
+
+## Content gem shape
+
+```
+scry-example/
+├── lib/
+│   └── scry-example.rb       # no-op; so `require` works in :jekyll_plugins
+├── content/
+│   ├── manifest.yml          # schema_version: 1
+│   ├── docs/…
+│   └── assets/…
+└── *.gemspec                 # metadata["scry_content"] = "true"
+                              # add_dependency "jekyll-scry-content", "~> 0.3"
+```
+
+The `lib/` file must be named after the gem and should not `require` this plugin or call `register`. Discovery uses gemspec metadata.
+
+Content gems should `add_dependency "jekyll-scry-content", "~> 0.3"` now that this plugin is on RubyGems. Keep the loader in the host `:jekyll_plugins` group (and `plugins:` in `_config.yml`) so its hooks actually run — a transitive install alone does not register them.
+
+Site-owned files always win over gem symlinks. Staged paths are listed in `.gitignore` between `# BEGIN jekyll-scry-content` markers.
+
+## Manifest `schema_version`
+
+Supported: **1**. Missing `schema_version` warns and is treated as 1. An unsupported value fails the build. Excluded gems are not validated.
+
+## Config files
+
+A content gem can merge keys into the host site's config by pointing the manifest at a YAML file under `content/`. That file is loaded in memory only — it is **not** staged into the site source, and it must not be named `_config.yml` (Jekyll would treat that as site config).
+
+```yaml
+# content/manifest.yml
+kind: style
+config_file: config.yml
+```
+
+```yaml
+# content/config.yml
+callouts:
+  monster:
+    title: Monster
+    color: red
+```
+
+Later gems overlay earlier gems; values in the site `_config.yml` win on conflicts. This is how `scry-rpg-callouts` registers Just the Docs callouts.
+
+## Soft dependencies
+
+A content gem can declare other content it needs:
+
+```yaml
+requires:
+  rulesets: [ose]            # ids from ruleset gems (`provides` / ruleset `id`)
+  content: [rpg-callouts]    # content-gem id or gem name
+```
+
+Missing requirements warn by default (`warn_missing_ruleset` and `warn_missing_content` are `true` if omitted). Set either flag to `false` to silence that check. `missing_ruleset: error` still fails the build; `missing_ruleset: ignore` still disables ruleset warnings when `warn_missing_ruleset` is omitted.
+
+Rulesets should stay **host Gemfile** lines, not gemspec runtime dependencies, so a site can omit them.
+
+## Why symlinks?
+
+Plugins such as `jekyll-image-links` read map YAML from `site.source` at build time. Staging keeps those paths identical to in-repo adventures without vendoring files in the site repository.

data/lib/jekyll/scry_content/config.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module ScryContent
+    # Merges YAML from each gem's `config_file` into `site.config` in memory.
+    # Files are never staged into the site source, so Jekyll does not read them
+    # as `_config.yml`. Later gems overlay earlier gems; site `_config.yml` wins.
+    module Config
+      module_function
+
+      def merge!(site, manifests)
+        combined = {}
+        sources = []
+
+        manifests.each do |manifest|
+          fragment = manifest.config
+          next if fragment.empty?
+
+          combined = deep_merge(combined, fragment)
+          sources << manifest
+        end
+
+        return if combined.empty?
+
+        combined.each do |key, value|
+          site.config[key] = deep_merge(value, site.config[key])
+        end
+
+        Jekyll.logger.info(
+          "ScryContent:",
+          "merged config from #{sources.map(&:describe).join(', ')}"
+        )
+      end
+
+      def deep_merge(base, overlay)
+        return dup_value(base) if overlay.nil?
+        return dup_value(overlay) unless hash?(base) && hash?(overlay)
+
+        result = stringify_keys(base)
+        stringify_keys(overlay).each do |key, value|
+          result[key] = result.key?(key) ? deep_merge(result[key], value) : dup_value(value)
+        end
+        result
+      end
+
+      def hash?(value)
+        value.is_a?(Hash)
+      end
+
+      def stringify_keys(hash)
+        hash.each_with_object({}) do |(key, value), out|
+          out[key.to_s] = value
+        end
+      end
+
+      def dup_value(value)
+        case value
+        when Hash
+          value.each_with_object({}) { |(key, child), out| out[key.to_s] = dup_value(child) }
+        when Array
+          value.map { |child| dup_value(child) }
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/scry_content/discovery.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module ScryContent
+    module Discovery
+      module_function
+
+      @explicit = []
+
+      def register_explicit(gem_name:, manifest: "content/manifest.yml")
+        @explicit << { gem_name: gem_name.to_s, manifest: manifest.to_s }
+      end
+
+      def explicit_registrations
+        @explicit.dup
+      end
+
+      def reset_explicit!
+        @explicit = []
+      end
+
+      def discover(site)
+        config = site.config["scry_content"] || {}
+        return [] if config["enabled"] == false
+
+        manifests = []
+        seen_gems = {}
+
+        explicit_registrations.each do |entry|
+          spec = Gem.loaded_specs[entry[:gem_name]]
+          next unless spec
+
+          manifests << Manifest.load(
+            gem_name: entry[:gem_name],
+            gem_path: spec.full_gem_path,
+            manifest_rel: entry[:manifest]
+          )
+          seen_gems[entry[:gem_name]] = true
+        end
+
+        Gem.loaded_specs.each_value do |spec|
+          next if seen_gems[spec.name]
+          next unless spec.metadata["scry_content"].to_s == "true"
+
+          manifest_rel = spec.metadata["scry_content_manifest"].to_s
+          manifest_rel = "content/manifest.yml" if manifest_rel.empty?
+
+          manifests << Manifest.load(
+            gem_name: spec.name,
+            gem_path: spec.full_gem_path,
+            manifest_rel: manifest_rel
+          )
+        end
+
+        filtered = filter_manifests(manifests, config)
+        filtered.each(&:validate_schema!)
+        filtered
+      end
+
+      def filter_manifests(manifests, config)
+        only = Array(config["only"]).map(&:to_s).reject(&:empty?)
+        exclude = Array(config["exclude"]).map(&:to_s).reject(&:empty?)
+
+        filtered = manifests.select do |manifest|
+          next false if exclude.include?(manifest.id) || exclude.include?(manifest.gem_name)
+          next true if only.empty?
+
+          only.include?(manifest.id) || only.include?(manifest.gem_name)
+        end
+
+        dedupe_variants(filtered)
+      end
+
+      # Prefer full-art over placeholders when the same adventure id appears twice.
+      def dedupe_variants(manifests)
+        by_id = manifests.group_by(&:id)
+        chosen = []
+
+        by_id.each_value do |group|
+          if group.length == 1
+            chosen << group.first
+            next
+          end
+
+          winner = group.max_by(&:variant_priority)
+          losers = group.reject { |m| m.equal?(winner) }
+          Jekyll.logger.warn(
+            "ScryContent:",
+            "multiple gems for id=#{winner.id} (#{group.map(&:gem_name).join(', ')}); " \
+            "using #{winner.gem_name} (variant=#{winner.variant.inspect})"
+          )
+          losers.each do |loser|
+            Jekyll.logger.warn("ScryContent:", "skipping #{loser.gem_name}")
+          end
+          chosen << winner
+        end
+
+        chosen
+      end
+
+      def warn_missing_requirements!(manifests, config)
+        warn_missing_rulesets!(manifests, config)
+        warn_missing_content!(manifests, config)
+      end
+
+      def warn_missing_rulesets!(manifests, config)
+        error = config["missing_ruleset"].to_s == "error"
+        return unless error || warn_missing_ruleset?(config)
+
+        provided = manifests.flat_map(&:provides).uniq
+        manifests.each do |manifest|
+          missing = manifest.requires_rulesets - provided
+          next if missing.empty?
+
+          message = "#{manifest.gem_name} requires ruleset(s) #{missing.join(', ')} but none are loaded"
+          raise Jekyll::Errors::FatalException, "ScryContent: #{message}" if error
+
+          Jekyll.logger.warn("ScryContent:", message)
+        end
+      end
+
+      def warn_missing_content!(manifests, config)
+        return unless warn_flag?(config, "warn_missing_content")
+
+        loaded = manifests.flat_map { |manifest| [manifest.id, manifest.gem_name] + manifest.provides }.uniq
+        manifests.each do |manifest|
+          missing = manifest.requires_content.reject { |id| loaded.include?(id) }
+          next if missing.empty?
+
+          Jekyll.logger.warn(
+            "ScryContent:",
+            "#{manifest.gem_name} requires content gem(s) #{missing.join(', ')} but none are loaded"
+          )
+        end
+      end
+
+      # Defaults to true. `missing_ruleset: ignore` still disables when the new key is omitted.
+      def warn_missing_ruleset?(config)
+        return warn_flag?(config, "warn_missing_ruleset") if config.key?("warn_missing_ruleset")
+
+        config["missing_ruleset"].to_s != "ignore"
+      end
+
+      def warn_flag?(config, key)
+        return true unless config.key?(key)
+
+        value = config[key]
+        return false if value == false || value.nil?
+
+        !%w[false off ignore].include?(value.to_s.downcase)
+      end
+    end
+  end
+end

data/lib/jekyll/scry_content/hooks.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module ScryContent
+    module Hooks
+      module_function
+
+      def apply!(site)
+        config = site.config["scry_content"] || {}
+        return if config["enabled"] == false
+
+        manifests = Discovery.discover(site)
+        Discovery.warn_missing_requirements!(manifests, config)
+        Config.merge!(site, manifests)
+        Stager.new(site, manifests).stage!
+      end
+    end
+  end
+end
+
+# Stage on every build/reset so pages, assets, and map YAML are visible to
+# the reader and to plugins like jekyll-image-links (including `jekyll serve`).
+Jekyll::Hooks.register :site, :after_reset do |site|
+  Jekyll::ScryContent::Hooks.apply!(site)
+end

data/lib/jekyll/scry_content/manifest.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module ScryContent
+    class Manifest
+      SUPPORTED_SCHEMA_VERSIONS = [1].freeze
+      VARIANT_PRIORITY = {
+        "full-art" => 2,
+        "placeholders" => 1
+      }.freeze
+
+      attr_reader :gem_name, :gem_path, :data, :path
+
+      def self.load(gem_name:, gem_path:, manifest_rel:)
+        require "yaml"
+
+        path = File.join(gem_path, manifest_rel)
+        raise ArgumentError, "scry content manifest missing for #{gem_name}: #{path}" unless File.file?(path)
+
+        data = YAML.safe_load(File.read(path), permitted_classes: [Date, Time, Symbol], aliases: true)
+        raise ArgumentError, "scry content manifest must be a mapping: #{path}" unless data.is_a?(Hash)
+
+        new(gem_name: gem_name, gem_path: gem_path, path: path, data: data)
+      end
+
+      def initialize(gem_name:, gem_path:, path:, data:)
+        @gem_name = gem_name
+        @gem_path = gem_path
+        @path = path
+        @data = data
+      end
+
+      def id
+        data["id"] || gem_name
+      end
+
+      def kind
+        data["kind"] || "adventure"
+      end
+
+      def variant
+        data["variant"].to_s
+      end
+
+      def variant_priority
+        VARIANT_PRIORITY.fetch(variant, 0)
+      end
+
+      def title
+        data["title"] || id
+      end
+
+      # Integer from the manifest, or nil if omitted.
+      def schema_version
+        raw = data["schema_version"]
+        return nil if raw.nil? || (raw.respond_to?(:empty?) && raw.empty?)
+
+        Integer(raw)
+      rescue ArgumentError, TypeError
+        raise ArgumentError,
+              "#{gem_name}: schema_version must be an integer, got #{raw.inspect}"
+      end
+
+      # Gemspec / Bundler version (what a Gemfile pins).
+      def gem_version
+        spec = Gem.loaded_specs[gem_name]
+        spec&.version&.to_s
+      end
+
+      # Product / edition string from the manifest (may differ from gem_version).
+      def product_version
+        raw = data["version"]
+        return nil if raw.nil? || (raw.respond_to?(:empty?) && raw.empty?)
+
+        raw.to_s
+      end
+
+      # e.g. "scry-seers-sanctum 3.2.1 (product 3.2)"
+      def describe
+        label = gem_name.dup
+        label << " #{gem_version}" if gem_version && !gem_version.empty?
+        label << " (product #{product_version})" if product_version
+        label
+      end
+
+      def validate_schema!
+        version = schema_version
+        if version.nil?
+          Jekyll.logger.warn(
+            "ScryContent:",
+            "#{gem_name}: manifest has no schema_version; assuming #{SUPPORTED_SCHEMA_VERSIONS.max}"
+          )
+          return
+        end
+
+        return if SUPPORTED_SCHEMA_VERSIONS.include?(version)
+
+        raise Jekyll::Errors::FatalException,
+              "ScryContent: #{gem_name}: unsupported schema_version #{version} " \
+              "(jekyll-scry-content #{Jekyll::ScryContent::VERSION} supports " \
+              "#{SUPPORTED_SCHEMA_VERSIONS.join(', ')})"
+      end
+
+      def content_root
+        File.join(gem_path, "content")
+      end
+
+      def include_globs
+        globs = Array(data["include"]).map(&:to_s).reject(&:empty?)
+        globs.empty? ? ["docs/**", "assets/**"] : globs
+      end
+
+      def requires_rulesets
+        require_ids("rulesets")
+      end
+
+      def requires_content
+        require_ids("content")
+      end
+
+      def provides
+        list = Array(data["provides"]).map(&:to_s)
+        list << id if kind == "ruleset" && !list.include?(id)
+        list
+      end
+
+      def nav_order
+        nav = data["nav"]
+        return nil unless nav.is_a?(Hash)
+
+        nav["order"]
+      end
+
+      # Path relative to content/, or nil. Inline mappings are not allowed.
+      def config_file
+        raw = data["config_file"]
+        return nil if raw.nil? || (raw.respond_to?(:empty?) && raw.empty?)
+        if raw.is_a?(Hash) || raw.is_a?(Array)
+          raise ArgumentError,
+                "#{gem_name}: config_file must be a filename (e.g. config.yml), not inline settings"
+        end
+
+        rel = raw.to_s.sub(%r{\A\./}, "")
+        raise ArgumentError, "#{gem_name}: config_file is empty" if rel.empty?
+        if rel.start_with?("/", "~") || rel.split("/").include?("..")
+          raise ArgumentError, "#{gem_name}: config_file must be a path under content/"
+        end
+        if jekyll_config_basename?(File.basename(rel))
+          raise ArgumentError,
+                "#{gem_name}: config_file cannot be #{File.basename(rel)} " \
+                "(Jekyll reads that name as site config)"
+        end
+
+        rel
+      end
+
+      def config
+        rel = config_file
+        return {} unless rel
+
+        require "yaml"
+
+        path = File.join(content_root, rel)
+        unless File.file?(path)
+          raise ArgumentError, "#{gem_name}: config_file #{rel.inspect} not found at #{path}"
+        end
+
+        loaded = YAML.safe_load(File.read(path), permitted_classes: [Date, Time, Symbol], aliases: true)
+        unless loaded.is_a?(Hash)
+          raise ArgumentError, "#{gem_name}: config_file #{rel.inspect} must be a YAML mapping"
+        end
+
+        loaded
+      end
+
+      def skip_stage?(rel)
+        return true if rel == "manifest.yml"
+        return true if config_file && rel == config_file
+        return true if jekyll_config_basename?(File.basename(rel))
+
+        false
+      end
+
+      def jekyll_config_basename?(name)
+        %w[_config.yml _config.yaml _config.toml].include?(name.to_s.downcase)
+      end
+
+      private
+
+      def require_ids(key)
+        requires = data["requires"]
+        return [] unless requires.is_a?(Hash)
+
+        Array(requires[key]).map(&:to_s).reject(&:empty?)
+      end
+    end
+  end
+end

data/lib/jekyll/scry_content/stager.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+
+module Jekyll
+  module ScryContent
+    # Materializes content-gem files into the site source as symlinks so
+    # Jekyll and plugins (e.g. jekyll-image-links reading map YAML from
+    # site.source) see the same paths as in-repo content.
+    #
+    # Site-owned real files always win. Managed symlinks are refreshed each run.
+    class Stager
+      GITIGNORE_BEGIN = "# BEGIN jekyll-scry-content"
+      GITIGNORE_END = "# END jekyll-scry-content"
+      STATE_FILE = ".scry-staged"
+
+      def initialize(site, manifests)
+        @site = site
+        @manifests = manifests
+        @source = site.source
+      end
+
+      def stage!
+        desired = collect_desired_links
+        previous = read_state
+        stale = previous - desired.keys
+
+        stale.each { |rel| remove_managed!(rel) }
+
+        desired.each do |rel, target|
+          ensure_link!(rel, target)
+        end
+
+        write_state(desired.keys.sort)
+        update_gitignore!(desired.keys.sort)
+
+        return if desired.empty?
+
+        Jekyll.logger.info(
+          "ScryContent:",
+          "staged #{desired.length} path(s) from #{@manifests.map(&:describe).join(', ')}"
+        )
+      end
+
+      private
+
+      def expand_glob(glob)
+        # `docs/**` is easier to write in manifests; Ruby glob needs a filename.
+        glob.end_with?("/**") ? "#{glob}/*" : glob
+      end
+
+      def collect_desired_links
+        desired = {}
+
+        @manifests.each do |manifest|
+          root = Pathname.new(manifest.content_root)
+          next unless root.directory?
+
+          manifest.include_globs.each do |glob|
+            pattern = expand_glob(glob)
+            Dir.glob(root.join(pattern).to_s, File::FNM_DOTMATCH).each do |absolute|
+              next unless File.file?(absolute)
+
+              rel = Pathname.new(absolute).relative_path_from(root).to_s
+              next if manifest.skip_stage?(rel)
+
+              if desired.key?(rel) && desired[rel] != absolute
+                Jekyll.logger.warn(
+                  "ScryContent:",
+                  "path conflict for #{rel}; keeping #{desired[rel]}"
+                )
+                next
+              end
+
+              desired[rel] = absolute
+            end
+          end
+        end
+
+        desired
+      end
+
+      def ensure_link!(rel, target)
+        dest = File.join(@source, rel)
+
+        if File.exist?(dest) || File.symlink?(dest)
+          if managed_symlink?(dest)
+            current = File.expand_path(File.readlink(dest), File.dirname(dest))
+            return if current == File.expand_path(target)
+
+            File.unlink(dest)
+          else
+            Jekyll.logger.warn(
+              "ScryContent:",
+              "site file wins, skipping gem path #{rel}"
+            )
+            return
+          end
+        end
+
+        FileUtils.mkdir_p(File.dirname(dest))
+        File.symlink(target, dest)
+      end
+
+      def remove_managed!(rel)
+        dest = File.join(@source, rel)
+        # Paths recorded in .scry-staged were created by us; remove if still a symlink.
+        return unless File.symlink?(dest)
+
+        File.unlink(dest)
+        prune_empty_dirs!(File.dirname(dest))
+      end
+
+      def managed_symlink?(dest)
+        return false unless File.symlink?(dest)
+
+        target = begin
+          File.expand_path(File.readlink(dest), File.dirname(dest))
+        rescue Errno::ENOENT, Errno::EINVAL
+          return false
+        end
+
+        @manifests.any? do |manifest|
+          target.start_with?("#{manifest.content_root}/")
+        end
+      end
+
+      def prune_empty_dirs!(dir)
+        source_real = File.expand_path(@source)
+        current = File.expand_path(dir)
+
+        while current.start_with?(source_real) && current != source_real
+          begin
+            Dir.rmdir(current)
+          rescue Errno::ENOTEMPTY, Errno::ENOENT
+            break
+          end
+          current = File.dirname(current)
+        end
+      end
+
+      def state_path
+        File.join(@source, STATE_FILE)
+      end
+
+      def read_state
+        return [] unless File.file?(state_path)
+
+        File.read(state_path).lines.map(&:strip).reject(&:empty?)
+      end
+
+      def write_state(paths)
+        if paths.empty?
+          FileUtils.rm_f(state_path)
+          return
+        end
+
+        File.write(state_path, "#{paths.join("\n")}\n")
+      end
+
+      def update_gitignore!(paths)
+        gitignore = File.join(@source, ".gitignore")
+        return unless File.file?(gitignore) || !paths.empty?
+
+        File.write(gitignore, "") unless File.file?(gitignore)
+        original = File.read(gitignore)
+
+        block = [
+          GITIGNORE_BEGIN,
+          "# Symlinks staged from content gems — do not commit",
+          STATE_FILE,
+          *paths,
+          GITIGNORE_END
+        ].join("\n")
+
+        updated =
+          if paths.empty?
+            original.sub(
+              /\n*#{Regexp.escape(GITIGNORE_BEGIN)}.*?#{Regexp.escape(GITIGNORE_END)}\n*/m,
+              "\n"
+            )
+          elsif original.include?(GITIGNORE_BEGIN) && original.include?(GITIGNORE_END)
+            original.sub(
+              /#{Regexp.escape(GITIGNORE_BEGIN)}.*?#{Regexp.escape(GITIGNORE_END)}/m,
+              block
+            )
+          else
+            "#{original.rstrip}\n\n#{block}\n"
+          end
+
+        File.write(gitignore, updated) if updated != original
+      end
+    end
+  end
+end

data/lib/jekyll/scry_content/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module ScryContent
+    VERSION = "0.3.0"
+  end
+end

data/lib/jekyll/scry_content.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "jekyll"
+
+require_relative "scry_content/version"
+require_relative "scry_content/manifest"
+require_relative "scry_content/discovery"
+require_relative "scry_content/config"
+require_relative "scry_content/stager"
+require_relative "scry_content/hooks"
+
+module Jekyll
+  module ScryContent
+    class << self
+      def register(gem_name:, manifest: "content/manifest.yml")
+        Discovery.register_explicit(gem_name: gem_name, manifest: manifest)
+      end
+    end
+  end
+end

data/lib/jekyll-scry-content.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "jekyll"
+
+require_relative "jekyll/scry_content"
+
+# Entry point used when listed under `plugins:` / `group :jekyll_plugins`.
+Jekyll::ScryContent

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: jekyll-scry-content
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- directsun
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jekyll
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.8'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.8'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Discovers installed scry-* gems, stages their content into the site source,
+  and merges optional config. Pair with adventure, ruleset, and style content gems.
+email: []
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/jekyll-scry-content.rb
+- lib/jekyll/scry_content.rb
+- lib/jekyll/scry_content/config.rb
+- lib/jekyll/scry_content/discovery.rb
+- lib/jekyll/scry_content/hooks.rb
+- lib/jekyll/scry_content/manifest.rb
+- lib/jekyll/scry_content/stager.rb
+- lib/jekyll/scry_content/version.rb
+homepage: https://github.com/sunflowermans/jekyll-scry-content
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/sunflowermans/jekyll-scry-content
+  source_code_uri: https://github.com/sunflowermans/jekyll-scry-content
+  allowed_push_host: https://rubygems.org
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Jekyll plugin that loads Scry content gems (pages, assets, and config) into
+  a site.
+test_files: []