jekyll-client-search 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b07a5519cf45012ce0d198cedfe93e1e93e939ed9d9221386af87c10854f0cf4
-  data.tar.gz: 630a3dd0f345e4e263c8228ac3a565610b435723860dac1125e86bf780d072b1
+  metadata.gz: 770d678df814030f4576214a39a7faca03f14d889cc284c5976486bc7c22f331
+  data.tar.gz: 2eaf824353f2b981ec1c538c3a84b938198960d1092110b6efceb181311ce2ea
 SHA512:
-  metadata.gz: 0d53f70fa2e1f37facfebe56ebf3384f3d5c376672e08f93cc5a3a761b03a294843b0cf236cbda9ffa7a7ace87261683a525f3a5e12e9da61592946cc878024a
-  data.tar.gz: 458dc19c9c0ad2b6c017057694b1af2103d918f16584205ec7c144a5e696fcb0d5609508fa414a7cb91facccf39a75dcd0c1c3e8c8a8e67bac8d1a09665419b5
+  metadata.gz: 44e285f7238df3e68523839fb80bdc3f67c25883e3311753b8b67d460a160dcb7e1b9c3c23c9066e04dc57b7d2e951924ebfc55ba205b4913e882b764e0fbff3
+  data.tar.gz: e9b48c426a74311b235b33eda93d119ba3864be6d64175640de6971521461226baf5f8c5e88e89a47889beea28feae22833d3ec49a8cf461064e8e7101fab1fc

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## Unreleased
+
+## 0.2.0 — 2026-08-27
+
+### Added
+- Generic `passthrough_fields` config option: external plugins declare which document `data` fields to forward into the search index (e.g. `file_type`, `icon_url`, `icon_set` from jekyll-documents)
+- Field renaming in `passthrough_fields`: entries can be strings (same name) or hashes (`{source => target}`) for integration with other search conventions
+- `icon_field` config option (default: `"icon_url"`): tells the browser runtime which field to render as an `<img>` icon before the result title; set to `null` to disable
+- Search index now includes `source` (collection label: `posts`, `pages`, etc.) — always present, set by the generator
+- Result `<article>` elements carry `data-source`, `data-categories`, `data-tags`, plus `data-*` for all passthrough fields (snake_case → data-kebab-case) for CSS-based result customization
+
+### Fixed
+- Allow whitespace in script/style end tags in `DocumentBuilder#clean` (`</script\s*>` instead of `</script>`) — CodeQL: bad HTML filtering regexp
+- Fix polynomial ReDoS in `SearchTag` and `RelatedTag` syntax regexes — strip markup before matching, remove leading/trailing `\s*` patterns that caused O(n²) backtracking (CodeQL: polynomial regex on uncontrolled data)
+
+### Changed
+- Simplified release workflow to tag-push trigger (`push: tags: v*`) — no manual `gh release create` needed
+- Switched to RubyGems trusted publishing (`rubygems/release-gem@v1` with OIDC)
+- Centralized version in `version.rb` as single source of truth — removed `version` field from `package.json`
+- Added `rake version:bump` and `rake version:check_changelog` tasks
+- Added CHANGELOG gate to release workflow (fails if entry missing for the version)
+- Added `npm audit` and `npm outdated` (non-blocking) to CI
+- Replaced pre-commit hook with rubocop-only (fast); added pre-push hook (rubocop + rspec)
+- Dropped reek from quality stack (KISS — marginal value on a small gem)
+- Aligned AGENTS.md to the open convention; added CLAUDE.md and .windsurfrules pointer files
+
 ## 0.1.0 — 2026-08-25
 
 - Add a pluggable search engine architecture with a base runtime and adapters.

data/README.developer.md

@@ -20,6 +20,57 @@ Both test suites pass with only the committed Wikipedia fixtures and the
 committed baseline JSON artifacts. No network access or external services
 are required for the default test run.
 
+## Quality checks and git hooks
+
+The project uses a focused quality stack: RuboCop (style), bundler-audit
+(security), RSpec (Ruby tests), and `npm test` (JavaScript tests). This
+covers the actionable ground without the maintenance burden of additional
+code-smell tools on a small focused gem.
+
+### Rake tasks
+
+| Task | What it runs |
+| --- | --- |
+| `rake` (default) | `rake quality` — all checks below |
+| `rake quality` | rubocop + bundler-audit + rspec + npm test |
+| `rake quick` | rubocop + rspec (fast pre-push subset) |
+| `rake rubocop` | RuboCop style check |
+| `rake rubocop_fix` | RuboCop auto-fix |
+| `rake bundler_audit` | `bundle-audit check --update` security scan |
+| `rake spec` | RSpec test suite |
+| `rake npm_test` | JavaScript test suite (`npm test`) |
+| `rake ci` | rspec + rubocop + syntax checks + npm test + gem build |
+
+### Git hooks
+
+Git hooks are not committed to the repository. Install them locally after
+cloning:
+
+```bash
+bin/install-hooks.sh
+```
+
+This installs two hooks:
+
+| Hook | What it runs | When |
+| --- | --- | --- |
+| `pre-commit` | `rubocop` only (~2s) | Before each commit |
+| `pre-push` | `rubocop + rspec` (~15s) | Before each push |
+
+The pre-commit hook is intentionally fast (style only) to avoid bypassing
+with `--no-verify`. The full test suite runs on pre-push and in CI. Skip
+either with `git commit --no-verify` or `git push --no-verify`.
+
+### CI checks
+
+The [CI workflow](.github/workflows/ci.yml) runs on every push and pull
+request across Ruby 3.2/3.3/3.4 and Node 22/24:
+
+- `bundle exec rake ci` (rspec, rubocop, syntax checks, npm test, gem build)
+- `bundle exec bundle-audit check --update` (Ruby dependency security)
+- `npm audit --audit-level=high` (JavaScript dependency security)
+- `npm outdated` (non-blocking — warns about outdated npm packages)
+
 ## Build-time related articles
 
 The optional related-analysis pass writes `search-relations.json` separately
@@ -202,3 +253,152 @@ bundle exec rspec --tag ollama_integration
 The CI pipeline runs `bundle exec rspec` and `npm test` without arXiv
 fixtures or Ollama. The committed baseline JSON and semantic embeddings
 ensure all tests pass in CI without external dependencies.
+
+## Releasing
+
+Releases are published to RubyGems.org via the
+[`release.yml`](.github/workflows/release.yml) GitHub Actions workflow,
+which triggers automatically when a GitHub Release is published. The
+workflow uses RubyGems trusted publishing (OIDC) — no API key is stored
+in the repository.
+
+### Prerequisites (one-time setup)
+
+Trusted publishing must be configured on rubygems.org for the gem before
+the first release:
+
+1. Log into <https://rubygems.org> and open the gem's page.
+2. Go to **Settings → Trusted Publishers → Add trusted publisher**.
+3. Enter:
+   - **Repository**: `gundestrup/jekyll-client-search`
+   - **Workflow filename**: `release.yml`
+   - **Environment**: `release`
+
+If the gem has never been published before, rubygems.org may require a
+one-time manual `gem push` with an API key to create the gem name before
+a trusted publisher can be attached. After that, all subsequent releases
+use trusted publishing automatically.
+
+### Version bumping
+
+The version lives in [`lib/jekyll/client_search/version.rb`](lib/jekyll/client_search/version.rb)
+and follows [Semantic Versioning](https://semver.org/). The gemspec reads
+from this file — it is the **single source of truth**. No other file
+stores the version (`package.json` is `private: true` and has no version
+field). Use the rake task to bump it:
+
+```bash
+bundle exec rake "version:bump[patch]"   # 0.1.0 -> 0.1.1  (bug fixes)
+bundle exec rake "version:bump[minor]"   # 0.1.0 -> 0.2.0  (new features, backwards compatible)
+bundle exec rake "version:bump[major]"   # 0.1.0 -> 1.0.0  (incompatible API changes)
+```
+
+The rake task only edits `version.rb`. It does not commit, tag, or update
+the changelog — those are manual steps in the release checklist below.
+
+You can verify that the CHANGELOG has an entry for the current version:
+
+```bash
+bundle exec rake version:check_changelog
+```
+
+This check also runs in the release workflow — the publish will fail if
+`CHANGELOG.md` has no `## X.Y.Z` entry matching the version being released.
+
+### Release checklist
+
+1. **Ensure the working tree is clean** and on `main`:
+
+   ```bash
+   git status
+   ```
+
+2. **Ensure all 80 fixture posts are present** (needed for Ollama
+   integration tests and baseline regeneration):
+
+   ```bash
+   ruby spec/fixtures/download_arxiv.rb
+   ```
+
+   Requires `pdftotext` (`brew install poppler` on macOS). Skip if the
+   arXiv posts are already present and unchanged.
+
+3. **Run the full test suite locally**, including Ollama integration tests:
+
+   ```bash
+   bundle exec rspec
+   OLLAMA_INTEGRATION=1 bundle exec rspec spec/ollama_integration_spec.rb
+   OLLAMA_INTEGRATION=1 bundle exec rspec spec/llm_injection_spec.rb
+   bundle exec rubocop
+   npm test
+   npm run lint
+   gem build jekyll-client-search.gemspec
+   ```
+
+   The Ollama integration tests require a running [Ollama](https://ollama.ai/)
+   server with the `embeddinggemma:300m` model pulled (`ollama pull
+   embeddinggemma:300m`). Do not publish a release until the Ollama
+   integration tests pass locally — they are skipped by default and will
+   not block CI, so they must be run manually before each release.
+
+4. **Bump the version** (see above) and update the `## Unreleased` or new
+   `## X.Y.Z — YYYY-MM-DD` section at the top of
+   [`CHANGELOG.md`](CHANGELOG.md) with a user-facing summary of changes.
+
+5. **Commit the version bump and changelog**:
+
+   ```bash
+   git add lib/jekyll/client_search/version.rb CHANGELOG.md
+   git commit -m "Release X.Y.Z: <short summary>"
+   ```
+
+6. **Tag the release** with an annotated tag:
+
+   ```bash
+   git tag -a vX.Y.Z -m "Release X.Y.Z
+
+   <one-line summary of notable changes>"
+   ```
+
+7. **Push `main` and the tag** to GitHub — pushing the tag triggers the
+   release workflow automatically:
+
+   ```bash
+   git push origin main
+   git push origin vX.Y.Z
+   ```
+
+   No manual `gh release create` is needed. The workflow builds the gem,
+   attaches it to a GitHub release, and publishes to RubyGems.
+
+8. **Watch the workflow** and verify the gem appears on RubyGems:
+
+   ```bash
+   gh run watch --workflow=release.yml
+   gem list jekyll-client-search --remote --exact
+   ```
+
+9. **Verify the integration site** builds cleanly against the published
+   gem (update the path dependency to the released version in
+   `../gundestrup.dk` and run `bundle exec jekyll build`).
+
+### What the release workflow does
+
+The [`release.yml`](.github/workflows/release.yml) workflow, triggered by
+pushing a `v*` tag:
+
+1. Checks out the repository at the release tag (`persist-credentials: false`).
+2. Sets up Ruby 3.4.10.
+3. Verifies the tag name matches `v<gem version>` (fails on mismatch).
+4. Verifies `CHANGELOG.md` has a `## X.Y.Z` entry for the version
+   (`rake version:check_changelog` — fails if missing).
+5. Builds the gem (`gem build`).
+6. Creates a GitHub Release and attaches the `.gem` file as a downloadable
+   asset (`softprops/action-gh-release@v2`).
+7. Publishes the gem to RubyGems.org using trusted publishing
+   (`rubygems/release-gem@v1` with OIDC).
+
+CI already validates tests on every push — the release workflow does not
+re-run the test suite. It only builds and publishes. The workflow runs in
+the `release` environment, which must match the environment name
+configured on the trusted publisher.

data/README.md

@@ -27,6 +27,7 @@ and vector similarity.
 - [The search form](#the-search-form)
 - [Rake tasks](#rake-tasks)
 - [Configuration reference](#configuration-reference)
+- [Indexing custom collections](#indexing-custom-collections)
 - [Architecture](#architecture)
 - [Embeddings and incremental indexing](#embeddings-and-incremental-indexing)
 - [Related articles reference](#related-articles-reference)
@@ -215,6 +216,89 @@ client_search:
 For manual `<script>` setup (engine-specific HTML), see
 [Browser usage reference](#browser-usage-reference).
 
+### Customizing search results with CSS
+
+Each search result is rendered as an `<article>` with data attributes that
+expose the document's metadata for CSS-based styling:
+
+| Attribute | Value | Source |
+| --- | --- | --- |
+| `data-source` | Collection label (`posts`, `pages`, `documents`, …) | Generator (always present) |
+| `data-categories` | Space-separated categories | Front matter |
+| `data-tags` | Space-separated tags | Front matter |
+| `data-*` | Any passthrough field (e.g. `data-file-type`, `data-icon-set`) | Config-driven |
+
+**Passthrough fields:** External plugins can expose their data in search
+results by listing field names in `passthrough_fields`. Each listed field is
+forwarded from the document's front matter / data into the search index and
+rendered as a `data-*` attribute on the result `<article>` (field names are
+converted from `snake_case` to `data-kebab-case`).
+
+**Field renaming:** Entries can be strings (same name) or hashes (rename
+`{source => target}`) for integration with other search conventions:
+
+```yaml
+client_search:
+  passthrough_fields:
+    - file_type: doctype      # index as "doctype" instead of "file_type"
+    - icon_url: thumbnail     # index as "thumbnail" instead of "icon_url"
+    - icon_set                # stays as "icon_set"
+  icon_field: thumbnail       # must match the target name
+```
+
+**Auto-injection:** When jekyll-documents is installed and `documents` is
+in the search collections, `file_type`, `icon_url`, and `icon_set` are
+auto-injected into `passthrough_fields` — no manual config needed.
+
+**Icon rendering:** When the configured `icon_field` (default: `"icon_url"`)
+is present in a result, an `<img class="client-search-result-icon">` is
+rendered before the title. Set `icon_field: null` to disable.
+
+**Default icon sizing:** Icons are sized to `1em` (matching the heading's
+font size) with `vertical-align: middle` and a small right margin — they
+auto-scale with the text. The inline styles are self-contained (no CSS
+dependency), so they work with any framework (Bulma, Bootstrap, Tailwind).
+
+Override with CSS:
+
+```css
+/* Make icons larger */
+.client-search-result-icon { width: 1.5em; height: 1.5em; }
+
+/* Fixed pixel sizes (if jekyll-documents' documents.css is included) */
+.client-search-result-icon.icon-x2 { width: 32px; height: 32px; }
+
+/* Theme-aware sizing using jekyll-documents' icon_set */
+.client-search-result[data-icon-set="color"] .client-search-result-icon { width: 1.5em; }
+.client-search-result[data-icon-set="ultra-minimal"] .client-search-result-icon { width: 1em; }
+```
+
+**CSS examples:**
+
+```css
+/* Show a different border color for posts vs pages */
+.client-search-result[data-source="posts"]  { border-left: 3px solid #3273dc; }
+.client-search-result[data-source="pages"]  { border-left: 3px solid #48c774; }
+
+/* Add a badge showing the file type via CSS (no icon_url needed) */
+.client-search-result[data-file-type="pdf"]::before {
+  content: "PDF";
+  background: #ff0000;
+  color: white;
+  padding: 0 0.3em;
+  font-size: 0.7em;
+  margin-right: 0.3em;
+}
+
+/* Show categories as tags */
+.client-search-result[data-categories~="travel"] .title::after {
+  content: " ✈";
+}
+```
+
+This enables per-source icons, file-type badges, category indicators, and
+tag-based styling — all through CSS, with no JavaScript changes needed.
+
 ## Rake tasks
 
 The gem ships reference layouts and includes that you can copy into your
@@ -343,6 +427,47 @@ Each document in the index contains:
 }
 ```
 
+## Indexing custom collections
+
+By default only `posts` are indexed. Add any Jekyll collection to the
+`collections` list to include it in the search index:
+
+```yaml
+client_search:
+  collections:
+    - posts
+    - documents
+```
+
+Each document in the index contains `id`, `title`, `url`, `excerpt`,
+`content`, `categories`, `tags`, and normalized date fields. Collections
+from other plugins work as long as their documents expose these fields.
+
+### Integration with jekyll-documents
+
+[jekyll-documents](https://github.com/gundestrup/jekyll-documents) turns
+files in `assets/documents/` into a browsable `documents` collection with
+titles, categories, and searchable content baked in at build time. To
+include uploaded documents in search results alongside posts:
+
+```yaml
+# _config.yml
+plugins:
+  - jekyll-documents
+  - jekyll-client-search
+
+client_search:
+  collections:
+    - posts
+    - documents
+  related:
+    enabled: true
+```
+
+No additional configuration is needed — `jekyll-documents` bakes
+`categories` (plural array) and searchable `content` into each document
+so the `DocumentBuilder` can index them directly.
+
 ## Architecture
 
 The plugin uses a base runtime + adapter architecture where the base owns

data/assets/client-search-base.js

@@ -58,6 +58,12 @@
                 return;
             }
 
+            var coreFields = [
+                "id", "title", "url", "excerpt", "content",
+                "categories", "tags", "categoriesText", "tagsText",
+                "date", "date_timestamp", "embedding"
+            ];
+
             function normalize(entry) {
                 var id = entry.id || entry.url;
                 if (!id) {
@@ -78,9 +84,20 @@
                     categoriesText: categories.join(" "),
                     tagsText: tags.join(" ")
                 };
+                if (entry.source) {
+                    normalized.source = entry.source;
+                }
                 if (Array.isArray(entry.embedding) && entry.embedding.length > 0) {
                     normalized.embedding = entry.embedding;
                 }
+                Object.keys(entry).forEach(function (key) {
+                    if (coreFields.indexOf(key) === -1 && key !== "source" && !(key in normalized)) {
+                        var value = entry[key];
+                        if (value !== null && value !== undefined && value !== "") {
+                            normalized[key] = value;
+                        }
+                    }
+                });
                 return normalized;
             }
 
@@ -143,17 +160,52 @@
                 var url = safeUrl(entry.url);
 
                 article.className = "box client-search-result";
+                if (entry.source) {
+                    article.dataset.source = entry.source;
+                }
+                if (entry.categories.length) {
+                    article.dataset.categories = entry.categories.join(" ");
+                }
+                if (entry.tags.length) {
+                    article.dataset.tags = entry.tags.join(" ");
+                }
+                Object.keys(entry).forEach(function (key) {
+                    if (coreFields.indexOf(key) !== -1 || key === "source") {
+                        return;
+                    }
+                    var value = entry[key];
+                    if (typeof value === "string" || typeof value === "number") {
+                        article.dataset[toCamelCase(key)] = String(value);
+                    }
+                });
                 heading.className = "title is-4";
                 titleLink.href = url;
                 titleLink.textContent = entry.title;
+                heading.appendChild(titleLink);
+                var iconField = options.iconField;
+                if (iconField && entry[iconField]) {
+                    var icon = document.createElement("img");
+                    icon.className = "client-search-result-icon";
+                    icon.src = safeUrl(entry[iconField]);
+                    icon.alt = entry.file_type || entry.source || "";
+                    icon.loading = "lazy";
+                    icon.style.width = "1em";
+                    icon.style.height = "1em";
+                    icon.style.verticalAlign = "middle";
+                    icon.style.marginRight = "0.3em";
+                    heading.insertBefore(icon, titleLink);
+                }
                 excerpt.textContent = entry.excerpt;
                 readMore.href = url;
                 readMore.textContent = "Read more";
-                heading.appendChild(titleLink);
                 article.append(heading, excerpt, readMore);
                 return article;
             }
 
+            function toCamelCase(key) {
+                return key.replace(/_([a-z])/g, function (_, char) { return char.toUpperCase(); });
+            }
+
             function sortMatches(matches) {
                 var sortControl = document.querySelector(options.sortControl);
                 var sortOrder = sortControl ? sortControl.value : options.sort;

data/lib/jekyll/client_search/configuration.rb

@@ -23,6 +23,8 @@ module Jekyll
         "collections" => ["posts"],
         "include_pages" => false,
         "copy_runtime" => true,
+        "passthrough_fields" => [],
+        "icon_field" => "icon_url",
         "embedding" => {
           "enabled" => false,
           "model" => "embeddinggemma:300m",
@@ -111,11 +113,7 @@ module Jekyll
       end
 
       def collections
-        Array(@values["collections"])
-          .compact
-          .map(&:to_s)
-          .reject(&:empty?)
-          .uniq
+        Array(@values["collections"]).compact.map(&:to_s).reject(&:empty?).uniq
       end
 
       def include_pages?
@@ -126,6 +124,31 @@ module Jekyll
         @values["copy_runtime"] != false
       end
 
+      def passthrough_fields
+        Array(@values["passthrough_fields"]).compact.each_with_object([]) do |e, f|
+          e.is_a?(Hash) ? add_hash_fields(e, f) : add_string_field(e, f)
+        end.uniq
+      end
+
+      def add_hash_fields(hash, fields)
+        hash.each do |s, t|
+          fields << [s.to_s, t.to_s] unless s.to_s.empty? || t.to_s.empty?
+        end
+      end
+
+      def add_string_field(entry, fields)
+        fields << [entry.to_s, entry.to_s] unless entry.to_s.empty?
+      end
+
+      def icon_field
+        v = @values["icon_field"]
+        v.nil? || v == false ? nil : v.to_s
+      end
+
+      def runtime_icon_field
+        icon_field if passthrough_fields.map(&:last).include?(icon_field)
+      end
+
       private
 
       def validate_query_embedder!

data/lib/jekyll/client_search/document_builder.rb

@@ -5,11 +5,21 @@ module Jekyll
     # Normalizes Jekyll documents and pages into the flat hash shape that the
     # search index JSON emits.
     class DocumentBuilder
-      def from_document(document)
+      def from_document(document, source: nil, passthrough_fields: [])
         url = document.url.to_s
         return if url.empty?
 
         data = document.data
+        core_fields(document, data, url)
+          .compact
+          .merge("source" => source)
+          .merge(passthrough(data, passthrough_fields))
+          .compact
+      end
+
+      private
+
+      def core_fields(document, data, url)
         {
           "id" => url,
           "title" => clean(data["title"] || "Untitled"),
@@ -20,10 +30,18 @@ module Jekyll
           "tags" => normalize_list(data["tags"]),
           "date" => normalized_date(document),
           "date_timestamp" => normalized_timestamp(document)
-        }.compact
+        }
       end
 
-      private
+      def passthrough(data, fields)
+        fields.each_with_object({}) do |(source, target), result|
+          value = data[source]
+          next if value.nil?
+          next if value.is_a?(String) && value.empty?
+
+          result[target] = value
+        end
+      end
 
       def excerpt_for(document)
         document.excerpt if document.respond_to?(:excerpt)
@@ -49,8 +67,8 @@ module Jekyll
 
       def clean(value)
         cleaned = value.to_s
-                       .gsub(%r{<script\b[^>]*>.*?</script>}mi, " ")
-                       .gsub(%r{<style\b[^>]*>.*?</style>}mi, " ")
+                       .gsub(%r{<script\b[^>]*>.*?</script\s*>}mi, " ")
+                       .gsub(%r{<style\b[^>]*>.*?</style\s*>}mi, " ")
                        .gsub(/\{%.*?%\}/m, " ")
                        .gsub(/\{\{.*?\}\}/m, " ")
                        .gsub(/!\[[^\]]*\]\([^)]*\)/, " ")

data/lib/jekyll/client_search/generator.rb

@@ -90,19 +90,23 @@ module Jekyll
       end
 
       def collection_documents(site, configuration, builder)
+        fields = configuration.passthrough_fields
         configuration.collections.flat_map do |label|
           collection = label == "posts" ? site.posts : site.collections[label]
           next [] unless collection
 
-          collection.docs.filter_map { |document| builder.from_document(document) }
+          collection.docs.filter_map do |document|
+            builder.from_document(document, source: label, passthrough_fields: fields)
+          end
         end
       end
 
       def page_documents(site, builder, configuration)
+        fields = configuration.passthrough_fields
         site.pages
             .reject { |page| page.url == "/#{configuration.output}" }
             .select { |page| page.data["title"] }
-            .filter_map { |page| builder.from_document(page) }
+            .filter_map { |page| builder.from_document(page, source: "pages", passthrough_fields: fields) }
       end
 
       def add_runtime_asset(site, configuration)

data/lib/jekyll/client_search/related_tag.rb

@@ -12,11 +12,11 @@ module Jekyll
     # When +related.enabled+ is false the tag renders nothing, so it is safe
     # to leave in a layout even when the feature is off.
     class RelatedTag < Liquid::Tag
-      SYNTAX = /\A\s*(sort:(\w+))?\s*(no_scripts)?\s*\z/
+      SYNTAX = /\A(sort:(\w+))?\s*(no_scripts)?\z/
 
       def initialize(tag_name, markup, tokens)
         super
-        @markup = markup.to_s
+        @markup = markup.to_s.strip
         unless (match = @markup.match(SYNTAX))
           raise Liquid::SyntaxError,
                 "related_articles: invalid syntax. Use {% related_articles %}, " \

data/lib/jekyll/client_search/runtime_config_page.rb

@@ -12,6 +12,7 @@ module Jekyll
           "liveSearch" => configuration.live_search_config
         }
         defaults["relatedUrl"] = index_url(site, configuration.related_output) if configuration.related_enabled?
+        defaults["iconField"] = configuration.runtime_icon_field if configuration.runtime_icon_field
         json = JSON.generate(defaults)
         self.content = "window.clientSearchConfig = (function (generated, existing) {" \
                        "var liveSearch = Object.assign({}, generated.liveSearch, existing.liveSearch || {});" \

data/lib/jekyll/client_search/search_tag.rb

@@ -12,11 +12,11 @@ module Jekyll
     #
     # When client_search is disabled the tag renders nothing.
     class SearchTag < Liquid::Tag
-      SYNTAX = /\A\s*(scripts_only|no_scripts)?\s*\z/
+      SYNTAX = /\A(scripts_only|no_scripts)?\z/
 
       def initialize(tag_name, markup, tokens)
         super
-        @markup = markup.to_s
+        @markup = markup.to_s.strip
         unless (match = @markup.match(SYNTAX))
           raise Liquid::SyntaxError,
                 "search_form: invalid syntax. Use {% search_form %}, " \

data/lib/jekyll/client_search/version.rb

@@ -2,6 +2,6 @@
 
 module Jekyll
   module ClientSearch
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-client-search
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Svend Gundestrup