plok 0.2.12 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4dd177c85c560cc54c99970b9f7bba447ac49b407edd4f92c3bf19eba003a4d6
-  data.tar.gz: 1567126c937dc4cdaa090c3617a091f63980da34d09452250d7d76518c48d80d
+  metadata.gz: caeb408fa4077fd24c19a153f273eb83f21d1da02a601035838e054080b80f85
+  data.tar.gz: e9ebfd53e89fdb4adddfb9498e2c7411ce994caf53039e0136459e90dd4a838e
 SHA512:
-  metadata.gz: 8d6f225251275ffe58c79f2b812647de21fd5b7522da704901bb23b30906f5137d7a4c5160ab4ef97be1ce4669c1b3258f9366279746171599ae17148d732f0d
-  data.tar.gz: e0043cc3f281b3e658b653823b0e338c78221b7f4797d8e51e3485206de84bdd02ed6b002b0e490f5609bc8e2322369ca5cdfbfcc30922ea990722a484d44cca
+  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/javascripts/plok/sidebar.js

@@ -0,0 +1,66 @@
+var sidebar = {
+  init: () => {
+    sidebar.bind_mouse_events();
+    $('#hamburger').on('click', sidebar.toggle_hamburger_click_listener)
+    $(document).on('click', sidebar.document_click_listener)
+  },
+
+  bind_mouse_events: () => {
+    $('.wrapper.compact ul li.top-level')
+      .on('mouseenter', sidebar.list_item_mouseenter_listener)
+      .on('mouseleave', sidebar.list_item_mouseleave_listener)
+  },
+
+  close_all_submenus: () => {
+    $('[id^="nav-"]').each((_i, item) => { $(item).removeClass('show') })
+    $('a.top-level-anchor').each((_i, item) => { $(item).removeClass('bg-secondary') })
+  },
+
+  document_click_listener: (e) => {
+    if($('.compact:visible').length == 0) return
+    if($(e.target).closest('.sidebar-menu').length === 0)
+      sidebar.close_all_submenus();
+  },
+
+  list_item_mouseenter_listener: (e) => {
+    sidebar.list_item_mouseleave_listener(e)
+
+    let anchor = $(e.target)
+    if(!anchor.hasClass('top-level-anchor')) return
+    anchor.addClass('bg-secondary')
+    $(anchor.attr('href')).addClass('show')
+  },
+
+  list_item_mouseleave_listener: (e) => {
+    let anchor = $(e.target)
+    if(!anchor.hasClass('top-level-anchor')) return
+    sidebar.close_all_submenus();
+  },
+
+  toggle_hamburger_click_listener: e => {
+    e.preventDefault()
+    $('.wrapper').toggleClass('compact')
+
+    $('[id^="nav-"]').each((index, item) => {
+      if($('.wrapper').hasClass('compact')) {
+        $(item).removeClass('show')
+      }
+    })
+
+    if($('.wrapper').hasClass('compact')) {
+      sidebar.bind_mouse_events()
+      $('.sidebar-menu').removeClass('overflow-auto')
+    } else {
+      sidebar.unbind_mouse_events()
+      $('.sidebar-menu').addClass('overflow-auto')
+    }
+  },
+
+  unbind_mouse_events: () => {
+    $('.wrapper ul li.top-level')
+      .off('mouseenter')
+      .off('mouseleave')
+  }
+}
+
+$(() => { sidebar.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/assets/stylesheets/plok/_sidebar.scss

@@ -0,0 +1,86 @@
+.sidebar-menu {
+  bottom: 0;
+  position: fixed;
+  top: 0;
+  width: var(--sidebar-width);
+  transition: .5s;
+  z-index: 10;
+
+  a.logo {
+    display: block;
+    letter-spacing: 0.1em;
+    line-height: 45px;
+    text-decoration: none;
+    text-transform: uppercase;
+  }
+
+  a.home-icon {
+    display: none !important;
+  }
+
+  ul {
+    list-style-type: none;
+    padding-left: 0;
+
+    li {
+      cursor: pointer;
+
+      a {
+        color: #fff; // $color-contrast-light from the Bootstrap gem.
+        display: block;
+        font-size: 1rem;
+        padding: 10px;
+        padding-left: var(--sidebar-menu-item-left-margin);
+        text-decoration: none !important;
+
+        &:hover {
+          background-color: #6c757d; // $secondary from the Bootstrap gem.
+        }
+      }
+
+      &.top-level {
+        letter-spacing: .05em;
+        position: relative;
+
+        .fa {
+          font-size: 14px;
+          width: var(--sidebar-icon-width);
+        }
+
+        .text {
+          cursor: default;
+          font-size: 0.8rem;
+          padding: 16px 0 12px 0;
+          pointer-events: none;
+          text-transform: uppercase;
+        }
+
+        div[id^=nav-] {
+          h4 {
+            display: none;
+          }
+
+          ul li {
+            position: relative;
+
+            &::before {
+              content: '\25A1';
+              font-size: 0.4rem;
+              left: calc(var(--sidebar-menu-item-left-margin) + 15px);
+              position: absolute;
+              top: 15px;
+            }
+
+            a {
+              font-size: 0.8rem;
+              padding-left: calc(var(--sidebar-menu-item-left-margin) + var(--sidebar-icon-width) + 10px);
+              text-transform: uppercase;
+            }
+          }
+        }
+
+      }
+    }
+  }
+
+}

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

@@ -0,0 +1,66 @@
+.wrapper.compact {
+  .content {
+    margin-left: var(--sidebar-compact-width);
+
+    @include media-breakpoint-down(md) {
+      margin-left: 0;
+    }
+  }
+
+  .sidebar-menu {
+    width: var(--sidebar-compact-width);
+
+    @include media-breakpoint-down(md) {
+      width: 0;
+    }
+
+    a.logo {
+      display: none !important;
+    }
+
+    a.home-icon {
+      display: block !important;
+    }
+
+    ul li.top-level {
+      > a { // The icons in the compact view.
+        padding: 10px 0;
+        text-align: center;
+      }
+
+      h4 {
+        cursor: default;
+        display: inline-block;
+        font-size: .9rem;
+        padding: 13px 0 0 5px;
+        vertical-align: middle;
+        text-transform: uppercase;
+      }
+
+      ul li {
+        &::before {
+          left: calc(var(--sidebar-icon-width) - 5px);
+        }
+
+        a {
+          padding-left: calc(var(--sidebar-icon-width) + 10px);
+
+          &:hover {
+            background-color: $primary;
+          }
+        }
+      }
+
+      .fa { font-size: 20px; }
+      .text { display: none; }
+
+      .collapse {
+        background-color: $secondary;
+        left: var(--sidebar-compact-width);
+        position: absolute;
+        top: 0;
+        width: 240px;
+      }
+    }
+  }
+}

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

@@ -0,0 +1,17 @@
+class Module
+  def takes(*arg_names)
+    define_method(:initialize) do |*arg_values|
+      arg_names.zip(arg_values).each do |name, value|
+        if name.is_a?(Hash)
+          name, default_value = name.to_a.flatten
+          value = default_value if value.blank?
+        end
+
+        instance_variable_set(:"@#{name}", value)
+        singleton_class.instance_eval { attr_reader name.to_sym }
+      end
+    end
+  end
+
+  alias_method :let, :define_method
+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/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Explain the generator
+
+Example:
+    bin/rails generate plok/sidebar
+
+    This will create:
+        what/will/it/create

data/lib/generators/plok/sidebar/sidebar_generator.rb

@@ -0,0 +1,114 @@
+require 'rails/generators/base'
+
+class Plok::SidebarGenerator < Rails::Generators::Base
+  source_root File.expand_path('templates', __dir__)
+  class_option :css_framework, type: :string, default: 'bs5'
+
+  def install
+    copy_sidebar_files('wrapper', 'menu_items', 'menu_item', 'offcanvas_menu')
+    add_scss_imports_to_application
+    add_js_imports_to_application
+    inject_wrapper_block_into_application_layout
+    say("\nAll done! Remember to reboot your server so the new assets can load.\n\n")
+  end
+
+  private
+
+  def add_js_imports_to_application
+    if application_file(:js)
+      unless file_contains?(application_file(:js), /\/\/= require plok\/sidebar/)
+        append_to_file application_file(:js), "//= require plok/sidebar"
+      end
+    else
+      say("\nWARNING: No suitable application.js file found.\n")
+      say("Please add the following import to your backend application.js file:\n\n")
+      say("//= require plok/sidebar\n\n")
+    end
+  end
+
+  def add_scss_imports_to_application
+    if application_file(:scss)
+      unless file_contains?(application_file(:scss), /@import 'plok\/sidebar'/)
+        append_to_file application_file(:scss), "@import 'plok/sidebar';\n"
+      end
+
+      unless file_contains?(application_file(:scss), /@import 'plok\/sidebar_compact'/)
+        append_to_file application_file(:scss), "@import 'plok/sidebar_compact';\n"
+      end
+    else
+      say("\nWARNING: No suitable application.scss file found.\n")
+      say("Please add the following imports to your backend application.scss file:\n\n")
+      say("@import 'plok/sidebar';\n")
+      say("@import 'plok/sidebar_compact';\n")
+    end
+  end
+
+  def inject_wrapper_block_into_application_layout
+    # The sidebar wrapper already exists, so stop here.
+    return if file_contains?(application_layout_file, /sidebar\/wrapper/)
+
+    # The wrapper is missing, but we *need* a suitable spot for a closing tag.
+    unless file_contains?(application_layout_file, /yield\(:javascripts_early\)/)
+      say("\nWARNING: The generator could not inject the sidebar wrapper.\n")
+      say("You will have to wrap your backend application markup in this block:\n\n")
+      say("# #{application_layout_file}\n")
+      say("<%= render 'backend/#{options.css_framework}/sidebar/wrapper', brand_name: '#{app_name}' do %>\n")
+      say("  # ...your backend application markup here...\n")
+      say("<% end %>\n")
+      return
+    end
+
+    gsub_file(
+      application_layout_file,
+      /<body(.*)>\n/,
+      "<body\\1>\n  <%= render 'backend/#{options.css_framework}/sidebar/wrapper', brand_name: '#{app_name}' do %>\n"
+    )
+
+    gsub_file(
+      application_layout_file,
+      /\n(.*)<%= yield\(:javascripts_early\) %>/,
+      "  <% end %>\n\n\\1<%= yield(:javascripts_early) %>"
+    )
+  end
+
+  def app_name
+    Rails.application.class.name.split('::').first
+  end
+
+  def copy_sidebar_files(*partials)
+    partials.each do |partial_name|
+      copy_file "_#{partial_name}.html.erb", sidebar_partial_path(partial_name)
+    end
+  end
+
+  def sidebar_partial_path(partial_name)
+    "app/views/backend/#{options.css_framework}/sidebar/_#{partial_name}.html.erb"
+  end
+
+  def file_contains?(file, content)
+    File.readlines(file).grep(content).any?
+  end
+
+  def application_layout_file
+    if File.exists?("app/views/layouts/backend/#{options.css_framework}/application.html.erb")
+      return "app/views/layouts/backend/#{options.css_framework}/application.html.erb"
+    end
+
+    if File.exists?('app/views/layouts/backend/application.html.erb')
+      return 'app/views/layouts/backend/application.html.erb'
+    end
+  end
+
+  def application_file(type)
+    namespace = 'stylesheets'
+    namespace = 'javascripts' if type.to_s == 'js'
+
+    if File.exists?("app/assets/#{namespace}/backend/#{options.css_framework}/application.#{type}")
+      return "app/assets/#{namespace}/backend/#{options.css_framework}/application.#{type}"
+    end
+
+    if File.exists?("app/assets/#{namespace}/backend/application.#{type}")
+      return "app/assets/#{namespace}/backend/application.#{type}"
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+<% lbl ||= t("b.#{name}") %>
+<% 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: (defined?(href) ? 'tooltip' : 'collapse') }, title: lbl do %>
+    <%= fa_icon icon, class: 'fa-fw' %>
+    <%= content_tag :span, lbl, class: 'text' %>
+  <% end %>
+
+  <% if defined?(path) %>
+    <%= content_tag :div, id: path, class: 'collapse' do %>
+      <h4><%= lbl %></h4>
+      <%= yield %>
+    <% end %>
+  <% end %>
+<% end %>

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

@@ -0,0 +1,9 @@
+<ul class="justify-content-center">
+  <%= render 'backend/bs5/sidebar/menu_item', name: 'admins', icon: 'user-secret-o' do %>
+    <ul>
+      <%= content_tag :li do %>
+        <%= link_to t('b.overview'), backend_admins_path %>
+      <% end %>
+    </ul>
+  <% end %>
+</ul>

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

@@ -0,0 +1,11 @@
+<div class="offcanvas offcanvas-start bg-dark text-light" tabindex="-1" id="navigation-offcanvas">
+  <div class="offcanvas-header">
+    <h5 class="offcanvas-title"><%= brand_name %></h5>
+    <button type="button" class="btn-close btn-close-white" data-bs-dismiss="offcanvas" aria-label="Close"></button>
+  </div>
+  <div class="offcanvas-body">
+    <div class="sidebar-menu position-static">
+      <%= render 'backend/bs5/sidebar/menu_items' %>
+    </div>
+  </div>
+</div>

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

@@ -0,0 +1,19 @@
+<div class="wrapper">
+  <div class="sidebar-menu text-light bg-dark overflow-auto">
+    <%= link_to backend_path, class: 'text-center navbar-brand logo text-light me-0' do %>
+      <%= brand_name %>
+    <% end %>
+
+    <%= link_to fa_icon(:'home'), backend_path, class: 'text-center navbar-brand home-icon text-light fs-2 me-0' %>
+
+    <nav class="mt-3">
+      <%= render 'backend/bs5/sidebar/menu_items' %>
+    </nav>
+  </div>
+
+  <div class="content">
+    <%= yield %>
+  </div>
+</div>
+
+<%= render 'backend/bs5/sidebar/offcanvas_menu', brand_name: brand_name %>

data/lib/plok/engine.rb

@@ -19,14 +19,17 @@ module Plok
       g.test_framework :rspec
     end
 
-    def class_exists?(class_name)
+    # Autoload classes from the lib dir
+    config.autoload_paths << File.expand_path('../..', __FILE__)
+
+    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 = '0.2.12'
+  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: 0.2.12
+  version: 1.0.1
 platform: ruby
 authors:
 - Davy Hellemans
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-12 00:00:00.000000000 Z
+date: 2022-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -78,12 +78,21 @@ 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
-- config/plok.yml
+- app/models/search_index.rb
+- app/models/search_module.rb
+- config/initializers/module.rb
 - config/routes.rb
 - db/migrate/20211008130809_create_plok_logs.rb
 - db/migrate/20211015141837_create_plok_queued_tasks.rb
@@ -93,13 +102,29 @@ 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
+- lib/generators/plok/sidebar/templates/_menu_items.html.erb
+- lib/generators/plok/sidebar/templates/_offcanvas_menu.html.erb
+- 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
@@ -120,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.28
+rubygems_version: 3.3.9
 signing_key: 
 specification_version: 4
 summary: CMS basics

data/config/plok.yml

@@ -1,9 +0,0 @@
-development:
-  modules:
-    - flexible_content
-    - snippets
-    - settings
-    - queued_tasks
-    - email_templates
-    - pages
-    - redirects