plok 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8824645af9b5b16c2e3540eb298a43be8df6b0e1539d2274bf833d62a4ee2c9b
-  data.tar.gz: 53298ba35f0393728429121aeb7ace1ebafca3b744bb3f47e584478eea6ae6e3
+  metadata.gz: caeb408fa4077fd24c19a153f273eb83f21d1da02a601035838e054080b80f85
+  data.tar.gz: e9ebfd53e89fdb4adddfb9498e2c7411ce994caf53039e0136459e90dd4a838e
 SHA512:
-  metadata.gz: 54f0aec7e6af22ec5f1e9d988880ebf03e110a5c8f619169c1ad1a5a82188c11f9da0b28a71189cd9aac21824921223e035cc718d0c2de7e661812cc715d7576
-  data.tar.gz: 4a274b94c88692dadd40061cd90778a7c0c2d7c5d931ef0c123e2b1a6e13ead58331f60e26d3c8c14fdeb709a414b7d93d44be072e3b4b85b74710c8a2f959cd
+  metadata.gz: 728e58a7153d8bb7bc4e19fde5b676ebec49d671b93d724b0c895d261e07e77bd7c6c347bf97c0dbf6dbc80e9c510e0c3f0bdf161713cf38b407a758f3da6ad0
+  data.tar.gz: d14e3d051253c34406c8736d4785b2ea7a1fba11f9e1dc46302b4ace6965d56f599b847ea604838aef90822595b7a526bcf18958f1e86a395e6a39a0c186cb18

data/app/assets/javascripts/jquery-ui.autocomplete.html.js

@@ -0,0 +1,40 @@
+/*
+ * jQuery UI Autocomplete HTML Extension
+ *
+ * Copyright 2010, Scott González (http://scottgonzalez.com)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ *
+ * http://github.com/scottgonzalez/jquery-ui-extensions
+ */
+(function( $ ) {
+
+var proto = $.ui.autocomplete.prototype,
+  initSource = proto._initSource;
+
+function filter( array, term ) {
+  var matcher = new RegExp( $.ui.autocomplete.escapeRegex(term), "i" );
+  return $.grep( array, function(value) {
+    return matcher.test( $( "<div>" ).html( value.label || value.value || value ).text() );
+  });
+}
+
+$.extend( proto, {
+  _initSource: function() {
+    if ( this.options.html && $.isArray(this.options.source) ) {
+      this.source = function( request, response ) {
+        response( filter( this.options.source, request.term ) );
+      };
+    } else {
+      initSource.call( this );
+    }
+  },
+
+  _renderItem: function( ul, item) {
+    return $( "<li></li>" )
+      .data( "item.autocomplete", item )
+      .append( $( "<a></a>" )[ this.options.html ? "html" : "text" ]( item.label ) )
+      .appendTo( ul );
+  }
+});
+
+})( jQuery );

data/app/assets/javascripts/plok/searchable.js

@@ -0,0 +1,26 @@
+var search = search || {
+  init: function() {
+    this.target().autocomplete({
+      minLength: 2,
+      source: search.target().parents('form').attr('action'),
+      select: search.select,
+      html: true
+    }).on('keypress', this.keypress_listener);
+  },
+
+  keypress_listener: function(e) {
+    var code = (e.keyCode ? e.keyCode : e.which);
+    if(code == 13) return false;
+  },
+
+  select: function(event, ui) {
+    window.location = ui.item.value;
+    return false;
+  },
+
+  target: function() {
+    return $('#search input');
+  }
+};
+
+$(function(){ search.init(); });

data/app/assets/stylesheets/plok/_autocomplete.scss

@@ -0,0 +1,43 @@
+.ui-autocomplete {
+  width: 24rem !important;
+  padding: 0;
+  z-index: 9999;
+  filter: drop-shadow(5px 5px 5px #666);
+}
+
+// Shows up during autocompletion sometimes.
+.ui-helper-hidden-accessible {
+  display: none;
+}
+
+li.ui-menu-item {
+  list-style: none;
+  cursor: pointer;
+  border-bottom: 1px solid #ccc;
+  padding: 5px;
+
+  &:last-child {
+    border: none;
+    margin-bottom: 0;
+    padding-bottom: 0;
+  }
+
+  &:hover {
+    background-color: $primary;
+    color: white !important;
+  }
+
+  a.ui-menu-item-wrapper {
+    border: none;
+
+    &.ui-state-active {
+      background: none;
+      color: inherit;
+      text-decoration: none;
+
+      .text-muted {
+        color: white !important;
+      }
+    }
+  }
+}

data/app/models/concerns/plok/searchable.rb

@@ -0,0 +1,96 @@
+module Plok::Searchable
+  extend ActiveSupport::Concern
+
+  included do
+    has_many :search_indices, as: :searchable, dependent: :destroy
+
+    # The after_save block creates or saves indices for every indicated
+    # searchable field. Takes both translations and flexible content into
+    # account.
+    #
+    # Translation support was relatively painless, but FlexibleContent
+    # required more thought. See #save_flexible_content_indices!
+    after_save do
+      trigger_indices_save!
+    end
+
+    def trigger_indices_save!
+      self.class.searchable_fields_list.each do |key|
+        if key == :flexible_content
+          save_flexible_content_search_indices! && next
+        end
+
+        if respond_to?(:translatable?) && self.class.translatable_fields_list.include?(key)
+          save_translatable_search_index!(key) && next
+        end
+
+        save_search_index!(key)
+      end
+    end
+
+    # I save all ContentText#content values as indices linked to the parent
+    # object. The Plok::Search::Base#indices method already groups by
+    # searchable resource, so there are never any duplicates.
+    # Only additional matches for the searchable because it takes
+    # ContentText#content sources into account.
+    #
+    # ContentColumn and ContentText have after_{save,destroy} callbacks
+    # to help facilitate searchable management. Note that said code was
+    # initially present in this class, and it was such a mess that it became
+    # unpractical to maintain.
+    def save_flexible_content_search_indices!
+      content_rows.each do |row|
+        row.columns.each do |column|
+          next unless column.content.is_a?(ContentText)
+          key = "flexible_content:#{column.content_id}"
+          save_index!(key, value: column.content.content, locale: row.locale)
+        end
+      end
+    end
+
+    def save_index!(key, value: nil, locale: nil)
+      value = read_attribute(key) if value.blank? && respond_to?(key)
+      return if value.blank?
+
+      search_indices
+        .find_or_create_by!(name: key, locale: locale)
+        .update_column(value: value)
+    end
+
+    # This exists so we can use #save_search_index! as the main method
+    # to override, and then be able to call #save_index! in the overridden
+    # method to accommodate further defaults.
+    def save_search_index!(key)
+      value = read_attribute(key)
+      save_index!(key, value: value)
+    end
+
+    def save_translatable_search_index!(key)
+      # TODO: locales can't be hardcoded
+      %w(nl fr).each do |locale|
+        value = translation(locale.to_sym).send(key)
+        save_index!(key, value: value, locale: locale)
+      end
+    end
+
+    def searchable?
+      true
+    end
+  end
+
+  module ClassMethods
+    def searchable_field(key)
+      unless searchable_fields_list.include?(key.to_sym)
+        searchable_fields_list << key.to_sym
+      end
+    end
+
+    def searchable_fields(*args)
+      args.each { |key| searchable_field(key) }
+    end
+
+    def searchable_fields_list
+      @searchable_fields_list ||= []
+    end
+  end
+end

data/app/models/queued_task.rb

@@ -55,6 +55,13 @@ class QueuedTask < ActiveRecord::Base
     destroy
   end
 
+  # You want this separate from #unlock so the ensure block in #process! does
+  # not keep resetting attempts when it shouldn't. This should be called
+  # from the controller where you manually unlock tasks in your backend.
+  def reset_attempts!
+    update_column(:attempts, 0)
+  end
+
   def increase_attempts!
     update_column(:attempts, attempts + 1)
   end

data/app/models/search_index.rb

@@ -0,0 +1,5 @@
+class SearchIndex < ActiveRecord::Base
+  belongs_to :searchable, polymorphic: true
+
+  validates :name, presence: true
+end

data/app/models/search_module.rb

@@ -0,0 +1,11 @@
+class SearchModule < ActiveRecord::Base
+  scope :weighted, -> { order('weight DESC') }
+
+  validates :name, presence: true
+
+  def indices
+    SearchIndex
+      .joins('INNER JOIN search_modules ON search_indices.searchable_type = search_modules.name')
+      .where('search_modules.name = ?', name)
+  end
+end

data/config/initializers/module.rb

@@ -1,10 +1,3 @@
-def class_exists?(class_name)
-  klass = Module.const_get(class_name)
-  return klass.is_a?(Class)
-rescue NameError
-  return false
-end
-
 class Module
   def takes(*arg_names)
     define_method(:initialize) do |*arg_values|
@@ -15,6 +8,7 @@ class Module
         end
 
         instance_variable_set(:"@#{name}", value)
+        singleton_class.instance_eval { attr_reader name.to_sym }
       end
     end
   end

data/db/migrate/20220923162300_create_search_indices.rb

@@ -0,0 +1,19 @@
+# This migration originally comes from udongo_engine
+class CreateSearchIndices < ActiveRecord::Migration[6.1]
+  def change
+    return if table_exists?(:search_indices)
+
+    create_table :search_indices do |t|
+      t.string :searchable_type
+      t.integer :searchable_id
+      t.string :locale, index: true
+      t.string :name
+      t.text :value
+
+      t.timestamps
+    end
+
+    add_index :search_indices, [:searchable_type, :searchable_id]
+    add_index :search_indices, [:locale, :name]
+  end
+end

data/db/migrate/20220923164100_create_search_modules.rb

@@ -0,0 +1,16 @@
+# This migration originally comes from udongo_engine
+class CreateSearchModules < ActiveRecord::Migration[6.1]
+  def change
+    return if table_exists?(:search_modules)
+
+    create_table :search_modules do |t|
+      t.string :name
+      t.boolean :searchable
+      t.integer :weight
+
+      t.timestamps
+    end
+
+    add_index :search_modules, [:name, :searchable]
+  end
+end

data/lib/generators/plok/sidebar/templates/_menu_item.html.erb

@@ -2,13 +2,13 @@
 <% href ||= defined?(path) ? path : "#nav-#{name}" %>
 
 <%= content_tag :li, class: 'top-level' do %>
-  <%= link_to href, class: 'top-level-anchor link-light', data: { bs_toggle: ('collapse' unless defined?(path)) } do %>
+  <%= link_to href, class: 'top-level-anchor link-light', data: { bs_toggle: (defined?(href) ? 'tooltip' : 'collapse') }, title: lbl do %>
     <%= fa_icon icon, class: 'fa-fw' %>
     <%= content_tag :span, lbl, class: 'text' %>
   <% end %>
 
-  <% unless defined?(path) %>
-    <%= content_tag :div, id: "nav-#{name}", class: 'collapse' do %>
+  <% if defined?(path) %>
+    <%= content_tag :div, id: path, class: 'collapse' do %>
       <h4><%= lbl %></h4>
       <%= yield %>
     <% end %>

data/lib/plok/engine.rb

@@ -22,14 +22,14 @@ module Plok
     # Autoload classes from the lib dir
     config.autoload_paths << File.expand_path('../..', __FILE__)
 
-    def class_exists?(class_name)
+    def self.class_exists?(class_name)
       klass = Module.const_get(class_name.to_s)
       klass.is_a?(Class)
     rescue NameError
       return false
     end
 
-    def module_exists?(module_name)
+    def self.module_exists?(module_name)
       # By casting to a string and making a constant, we can assume module_name
       # can be either one without it being a problem.
       module_name.to_s.constantize.is_a?(Module)

data/lib/plok/search/backend.rb

@@ -0,0 +1,22 @@
+# Due to the load order of classes, Backend precedes the required Base class.
+require_relative 'base'
+
+module Plok::Search
+  # The goal of this class is to provide a manipulated version of the filtered
+  # index data that we can use in the result set of an autocomplete-triggered
+  # search query. See Plok::Search::Base for more information on how this
+  # search functionality is designed.
+  class Backend < Plok::Search::Base
+    # This translates the filtered indices into meaningful result objects.
+    # These require a { label: ... value: ... } to accommodate jquery-ui.
+    #
+    # Note that the result_object#url method is defined in
+    # Plok::Search::ResultObjects::Backend::Page.
+    def search
+      indices.map do |index|
+        result = result_object(index)
+        { label: result.build_html, value: result.url }
+      end
+    end
+  end
+end

data/lib/plok/search/base.rb

@@ -0,0 +1,71 @@
+module Plok::Search
+  # The goal of the Base class is to filter our indices on the given search
+  # term. Further manipulation of individual index data into a meaningful
+  # result set (think autocomplete results) is done by extending this class.
+  #
+  # Examples of class extensions could be:
+  # Plok::Search::Backend - included in Plok
+  # Plok::Search::Frontend
+  # Plok::Search::Api
+  #
+  # The primary benefit in having these namespaced search interfaces is to
+  # provide a way for the developer to have different result objects for
+  # each resource.
+  #
+  # Example #1: A search request for a specific Page instance in the frontend
+  # will typically return a link to said page. However, in search requests made
+  # in the backend for the same Page instance, you'd expect a link to a form in
+  # the backend Page module where you can edit the page's contents.
+  #
+  # Example #2: Some autocompletes in a frontend namespace might require an
+  # image or a price to be included in its body.
+  #
+  # However these result objects are structured are also up to the developer.
+  class Base
+    attr_reader :term, :controller
+
+    def initialize(term, controller: nil, namespace: nil)
+      @term = Plok::Search::Term.new(term, controller: controller)
+      @controller = controller
+      @namespace = namespace
+    end
+
+    def indices
+      # Having the searchmodules sorted by weight returns indices in the
+      # correct order.
+      @indices ||= SearchModule.weighted.inject([]) do |stack, m|
+        # The group happens to make sure we end up with just 1 copy of
+        # a searchable result. Otherwise matches from both an indexed
+        # Page#title and Page#description would be in the result set.
+        stack << m.indices
+                  .where(
+                    '(searchable_id = ? OR search_indices.value LIKE ?)',
+                    term.value,
+                    "%#{term.value}%"
+                  )
+                  .group([:searchable_type, :searchable_id])
+      end.flatten
+    end
+
+    def namespace
+      # This looks daft, but it gives us a foot in the door for when a frontend
+      # search is triggered in the backend.
+      return @namespace unless @namespace.nil?
+      return 'Frontend' if controller.nil?
+      controller.class.module_parent.to_s
+    end
+
+    # In order to provide a good result set in a search autocomplete, we have
+    # to translate the raw index to a class that makes an index adhere
+    # to a certain interface (that can include links).
+    def result_object(index)
+      klass = "Plok::Search::ResultObjects::#{namespace}::#{index.searchable_type}"
+      klass = 'Plok::Search::ResultObjects::Base' unless result_object_exists?(klass)
+      klass.constantize.new(index, search_context: self)
+    end
+
+    def result_object_exists?(name)
+      Plok::Engine.class_exists?(name) && name.constantize.method_defined?(:build_html)
+    end
+  end
+end

data/lib/plok/search/result_objects/base.rb

@@ -0,0 +1,74 @@
+module Plok
+  class InterfaceNotImplementedError < NoMethodError
+  end
+
+  class Search::ResultObjects::Base
+    attr_reader :index, :search_context
+
+    delegate :searchable, to: :index
+
+    def initialize(index, search_context: nil)
+      @index = index
+      @search_context = search_context
+    end
+
+    # Typically, an autocomplete requires 3 things:
+    #
+    # * A title indicating a resource name.
+    #   Examples: Page#title, Product#name,...
+    # * A truncated summary providing a glimpse of the resource's contents.
+    #   Examples: Page#subtitle, Product#description,...
+    # * A link to the resource.
+    #   Examples: edit_backend_page_path(37), product_path(37),...
+    #
+    # However, this seems very restrictive to me. If I narrow down the data
+    # a dev can use in an autocomplete, it severely reduces options he/she has
+    # in how the autocomplete results look like. Think of autocompletes in a
+    # shop that require images or prices to be included in their result bodies.
+    #
+    # This is why I chose to let ApplicationController.render work around the
+    # problem by letting the dev decide how the row should look.
+    #
+    def build_html
+      ApplicationController.render(partial: partial, locals: locals)
+    end
+
+    def hidden?
+      searchable.respond_to?(:visible?) && searchable.hidden?
+    end
+
+    def label
+      # We want to grab the name of the index from ContentText whenever
+      # we're dealing with FlexibleContent stuff.
+      if index.name.include?('flexible_content')
+        id = index.name.split(':')[1].to_i
+        return ContentText.find(id).content
+      end
+
+      searchable.send(index.name)
+    end
+
+    def locals
+      { "#{partial_target}": index.searchable, index: index }
+    end
+
+    def partial
+      "#{partial_path}/#{partial_target}"
+    end
+
+    def partial_path
+      "#{search_context.namespace.to_s.underscore}/search"
+    end
+
+    def partial_target
+      index.searchable_type.underscore
+    end
+
+    def unpublished?
+      searchable.respond_to?(:published?) && searchable.unpublished?
+    end
+
+    def url
+    end
+  end
+end

data/lib/plok/search/term.rb

@@ -0,0 +1,23 @@
+module Plok::Search
+  class Term
+    attr_reader :controller, :string
+
+    def initialize(string, controller: nil)
+      @string = string
+      @controller = controller
+    end
+
+    def locale
+      return controller.locale if controller.present?
+      :nl
+    end
+
+    def valid?
+      @string.present?
+    end
+
+    def value
+      string
+    end
+  end
+end

data/lib/plok/version.rb

@@ -1,3 +1,3 @@
 module Plok
-  VERSION = '1.0.0'
+  VERSION = '1.0.1'
 end

data/lib/tasks/plok_tasks.rake

@@ -1,4 +1,11 @@
-# desc "Explaining what the task does"
-# task :plok do
-#   # Task goes here
-# end
+namespace 'plok:search' do
+  desc 'Rebuild all search indices'
+  task rebuild_indices: :environment do
+    SearchIndex.destroy_all
+    SearchModule.where(searchable: true).each do |m|
+      puts "Rebuilding #{m.name} indices..."
+      m.name.constantize.all.each(&:trigger_indices_save!)
+    end
+    puts "Done."
+  end
+end

data/spec/factories/search_indices.rb

@@ -0,0 +1,6 @@
+FactoryBot.define do
+  factory :search_index do
+    locale { 'nl' }
+    name { 'foo' }
+  end
+end

data/spec/factories/search_modules.rb

@@ -0,0 +1,5 @@
+FactoryBot.define do
+  factory :search_module do
+    name { 'Page' }
+  end
+end

data/spec/support/fake_ar_model.rb

@@ -0,0 +1,95 @@
+# This exists so one is able to mock actual ActiveRecord model classes that are
+# not tied to a database. This is useful if you want to write tests for concerns
+# without tying them to project-specific models.
+#
+# * It allows you to not mock simple ActiveRecord DSL like find/find_by/where
+#   calls.
+# * Projects using Plok can also use this, provided they call
+#   Plok::Engine.load_spec_supports in their spec/rails_helper.rb file.
+# * Even if you're required to mock additional business logic onto your classes,
+#   you can just extend from Plok::FakeArModel to fill in gaps.
+#
+#   Example:
+#
+#     class Product < Plok::FakeArModel
+#       def visible?
+#         true
+#       end
+#
+#       def hidden?
+#         !visible?
+#       end
+#     end
+#
+class Plok::FakeArModel
+  extend  ActiveModel::Naming
+  extend  ActiveModel::Translation
+  include ActiveModel::Validations
+  include ActiveModel::Conversion
+  include ActiveModel::Dirty
+
+  def initialize(attributes = {})
+    attributes.each do |key, value|
+      instance_variable_set(:"@#{key}", value)
+      self.class.send(:attr_accessor, key)
+    end
+  end
+
+  def self.collection(list)
+    @collection = list.to_a.map { |values| new(values) }
+  end
+
+  def self.primary_key
+    :id
+  end
+
+  def self.polymorphic_name
+    :fake_ar_model
+  end
+
+  def self.current_scope
+  end
+
+  def self.find(id)
+    @collection.to_a.detect { |o| o.id == id }
+  end
+
+  def self.find_by(arguments)
+    where(arguments)&.first
+  end
+
+  def self.where(arguments = nil)
+    @collection.select do |o|
+      if arguments.is_a?(Hash)
+        !!arguments.detect { |k, v| o.send(k) == v }
+      elsif(arguments.is_a?(String))
+        # NOTE: This will require intensive tinkering if we ever need it,
+        # so lets leave it for now.
+        []
+      end
+    end
+  end
+
+  def destroyed?
+    false
+  end
+
+  def new_record?
+    true
+  end
+
+  def save(options = {})
+    true
+  end
+
+  def _read_attribute(a)
+    a
+  end
+
+  private
+
+  def collection
+    self.class.instance_variable_get(:@collection)&.to_a || []
+  end
+
+end

data/spec/support/plok/searchable.rb

@@ -0,0 +1,100 @@
+require 'rails_helper'
+
+shared_examples_for :searchable do
+  let(:klass) { described_class.to_s.underscore.to_sym }
+
+  describe 'after_save' do
+    context 'non-translatable model' do
+      before do
+        # Because this is a spec/support included through it_behaves_like,
+        # we have to mock the entry points of the data used in
+        # Plok::Searchable.
+        allow(described_class).to receive(:searchable_fields_list) { [:foo] }
+        if described_class.respond_to?(:translatable_fields_list)
+          allow(described_class).to receive(:translatable_fields_list) { [] }
+        end
+        described_class.define_method(:foo) { 'bar' }
+      end
+
+      it 'default' do
+        subject = build(klass)
+        allow(subject).to receive(:foo) { 'bar' }
+        expect(subject.search_indices).to eq []
+      end
+
+      # NOTE: See if you can dynamically test the creation of indices on save.
+    end
+
+    if described_class.respond_to?(:translatable_fields)
+      before do
+        allow(described_class).to receive(:searchable_fields_list) { [:foo] }
+      end
+
+      context 'translatable model' do
+        before do
+          described_class.translatable_fields :foo, :bar
+        end
+
+        let(:create_subject!) do
+          subject = build(klass)
+          %w(nl fr).each do |l|
+            t = subject.translation(l.to_sym)
+            t.foo = "baz #{l}"
+            t.bar = 'bak'
+          end
+          subject.save
+          subject
+        end
+
+        it 'does not copy translatable fields that are not in searchable fields' do
+          subject = create_subject!
+          expect(subject.search_indices.find_by(locale: :nl, name: 'bar')).to be nil
+        end
+      end
+    end
+
+    if described_class.respond_to?(:content_rows)
+      context 'model with flexible_content' do
+        let(:subject) { create(klass) }
+        let(:content) { create(:content_text, content: 'Lorem ipsum') }
+
+        before do
+          # Because this is a spec/support included through it_behaves_like,
+          # we have to mock the entry points of the data used in
+          # Plok::Searchable.
+          allow(described_class).to receive(:searchable_fields_list) { [:foo] }
+          allow_any_subject_of(described_class).to receive(:foo) { 'bar' }
+          allow_any_subject_of(Concerns::Storable::Collection).to receive(:foo) { 'bar' }
+
+          row = create(:content_row, locale: 'nl', rowable: subject)
+          row.columns << create(:content_column, content: content)
+          subject.content_rows << row
+        end
+
+        it 'saves index when updating searchable subject' do
+          subject.save!
+          key = "flexible_content:#{content.id}"
+          expect(subject.search_indices.find_by(locale: :nl, name: key).value).to eq 'Lorem ipsum'
+        end
+
+        it 'saves index when updating flexible content' do
+          subject.save!
+          content.content = 'Dolor sit amet'
+          content.save!
+          key = "flexible_content:#{content.id}"
+          expect(subject.search_indices.find_by(locale: :nl, name: key).value).to eq 'Dolor sit amet'
+        end
+      end
+    end
+  end
+
+  it '.respond_to?' do
+    expect(described_class).to respond_to(
+      :searchable_field, :searchable_fields, :searchable_fields_list
+    )
+  end
+
+  it '#respond_to?' do
+    expect(subject).to respond_to(:search_indices)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: plok
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Davy Hellemans
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-06-17 00:00:00.000000000 Z
+date: 2022-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -78,14 +78,20 @@ files:
 - MIT-LICENSE
 - Rakefile
 - app/assets/config/plok_manifest.js
+- app/assets/javascripts/jquery-ui.autocomplete.html.js
+- app/assets/javascripts/plok/searchable.js
 - app/assets/javascripts/plok/sidebar.js
+- app/assets/stylesheets/plok/_autocomplete.scss
 - app/assets/stylesheets/plok/_sidebar.scss
 - app/assets/stylesheets/plok/_sidebar_compact.scss
 - app/controllers/catch_all_controller.rb
 - app/controllers/plok/version_controller.rb
 - app/models/concerns/plok/loggable.rb
+- app/models/concerns/plok/searchable.rb
 - app/models/log.rb
 - app/models/queued_task.rb
+- app/models/search_index.rb
+- app/models/search_module.rb
 - config/initializers/module.rb
 - config/routes.rb
 - db/migrate/20211008130809_create_plok_logs.rb
@@ -96,6 +102,8 @@ files:
 - db/migrate/20211203103118_add_file_to_logs.rb
 - db/migrate/20220512141814_add_log_indexes_to_category_type_and_id.rb
 - db/migrate/20220512142356_add_index_to_queued_task_weight.rb
+- db/migrate/20220923162300_create_search_indices.rb
+- db/migrate/20220923164100_create_search_modules.rb
 - lib/generators/plok/sidebar/USAGE
 - lib/generators/plok/sidebar/sidebar_generator.rb
 - lib/generators/plok/sidebar/templates/_menu_item.html.erb
@@ -104,11 +112,19 @@ files:
 - lib/generators/plok/sidebar/templates/_wrapper.html.erb
 - lib/plok.rb
 - lib/plok/engine.rb
+- lib/plok/search/backend.rb
+- lib/plok/search/base.rb
+- lib/plok/search/result_objects/base.rb
+- lib/plok/search/term.rb
 - lib/plok/version.rb
 - lib/tasks/plok_tasks.rake
 - spec/factories/logs.rb
 - spec/factories/queued_tasks.rb
+- spec/factories/search_indices.rb
+- spec/factories/search_modules.rb
+- spec/support/fake_ar_model.rb
 - spec/support/plok/loggable.rb
+- spec/support/plok/searchable.rb
 homepage: https://plok.blimp.be
 licenses:
 - MIT