locomotivecms_search 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 322fa8e2aa6552b81a40320ac49becc17d6698ce9cb0a689ecca0671a00b95f9
+  data.tar.gz: aeb31eb4295cb698dd7dc3e78618cb8be1143ef31cbb36ac75972002e32f6a12
+SHA512:
+  metadata.gz: ab385d6593d2c96ef9b972c7acdcbc5281aa8228ea3e62f41b45163ba3274fa9fa9d0c8516c5667a78dc59ace41ddcf3f5551a9cd55bdc7cbe383c9063b216a7
+  data.tar.gz: 1bc33531693a5e874db99953006e143412163e80094633cd6944ac5a072a1805c9020b3e77d213903d202fbb67a2354bc35edb9c8b96f03bb530480c1e5cf596

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2018, NoCoffee.
+
+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,74 @@
+# Locomotive Search
+
+Locomotive Search is an add-on for Locomotive Engine enhancing it by indexing the content of any site.
+
+For now, only [Algolia](https://www.algolia.com) is supported.
+
+## Installation
+
+Add this line to your Rails app's Gemfile powering Locomotive Engine.
+
+```ruby
+gem 'locomotivecms_search'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Open your `config/application.rb` file of your Rails app and assign a backend like this:
+
+```ruby
+class MyApplication < Rails::Application
+  ...
+  config.x.locomotive_search_backend = :algolia
+  ...
+end
+```
+
+For a smooth user experience, any modification to a page or a content entry will trigger asynchronously the indexing of the related content. Behind the scene, we use Rails ActiveJob in order to process it asynchronously. Check out the [ActiveJob documentation](http://guides.rubyonrails.org/active_job_basics.html) to set it up.
+
+However, if you don't mind about the performance (or for testing purpose), you can "disable" ActiveJob by adding `config.active_job.queue_adapter = :inline` to your application.rb file.
+
+## Available backends
+
+### Algolia
+
+Each Locomotive site has to set the credentials required to access the Algolia API. This can be done by adding a new metafield namespace named `algolia` in the Wagon source of the site.
+
+In the `config/metafields_schema.yaml` file, add the following lines:
+
+```yaml
+algolia:
+  label: Algolia settings
+  fields:
+    application_id:
+      type: string
+    api_key:
+      type: string
+    reset:
+      type: boolean
+      hint: 'If switched on and after pressed the save button, re-index the content of the site '
+```
+
+Then, deploy your site and open the back-office of your Locomotive site. Go to the "Settings" section and fill in the `application_id` and `api_key` fields within the Algolia tab.
+
+If you want to force the re-indexing all of the content of the site, toggle on the `reset` field and save the site. This procedure will start by deleting all the existing Algolia indices.
+
+## How to contribute
+
+Locomotive is an open source project, we encourage contributions. If you have found a bug and want to contribute a fix, or have a new feature you would like to add, follow the steps below to get your patch into the project:
+
+- Install ruby, mongoDB
+- Clone the project <code>git clone git@github.com:locomotivecms/search.git</code>
+- Start mongodb if it is not already running
+- Create an Algolia account
+- Set the following env variables based on your Algolia account: `ALGOLIA_APPLICATION_ID` and `ALGOLIA_API_KEY` (or add a new file named .env.test at the root of the project)
+- Run the tests <code>bundle exec rspec</code>
+- Write your failing tests
+- Make the tests pass
+- [Create a GitHub pull request](http://help.github.com/send-pull-requests)
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,19 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Search'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'

data/app/decorators/locomotive/content_entry_decorator.rb

@@ -0,0 +1,5 @@
+Locomotive::ContentEntry.class_eval do
+  include Locomotive::Concerns::Search
+  include Locomotive::Concerns::ContentEntry::IndexContent
+end
+

data/app/decorators/locomotive/page_decorator.rb

@@ -0,0 +1,5 @@
+Locomotive::Page.class_eval do
+  include Locomotive::Concerns::Search
+  include Locomotive::Concerns::Page::IndexContent
+end
+

data/app/decorators/locomotive/site_decorator.rb

@@ -0,0 +1,4 @@
+Locomotive::Site.class_eval do
+  include Locomotive::Concerns::Site::BuildIndices
+end
+

data/app/jobs/locomotive/base_search_job.rb

@@ -0,0 +1,37 @@
+module Locomotive
+
+  class BaseSearchJob < ApplicationJob
+
+    queue_as :search
+
+    protected
+
+    def search_backend(site, locale)
+      Rails.configuration.x.locomotive_search_backend.create(site, locale)
+    end
+
+    def index_page(site, page, locale)
+      search_backend(site, locale)&.save_object(
+        type:       'page',
+        object_id:  page._id.to_s,
+        title:      page.title,
+        content:    page.content_to_index,
+        visible:    page.published?,
+        data:       page.data_to_index
+      )
+    end
+
+    def index_content_entry(site, entry, locale)
+      search_backend(entry.site, locale)&.save_object(
+        type:       entry.content_type.slug,
+        object_id:  entry._id.to_s,
+        title:      entry._label,
+        content:    entry.content_to_index,
+        visible:    entry.visible?,
+        data:       entry.data_to_index
+      )
+    end
+
+  end
+
+end

data/app/jobs/locomotive/search_delete_content_entry_index_job.rb

@@ -0,0 +1,18 @@
+module Locomotive
+
+  class SearchDeleteContentEntryIndexJob < BaseSearchJob
+
+    def perform(entry_id, locale)
+      ::Mongoid::Fields::I18n.with_locale(locale) do
+        entry = Locomotive::ContentEntry.find(entry_id)
+
+        search_backend(entry.site, locale)&.delete_object(
+          entry.content_type.slug,
+          entry_id
+        )
+      end
+    end
+
+  end
+
+end

data/app/jobs/locomotive/search_delete_page_index_job.rb

@@ -0,0 +1,15 @@
+module Locomotive
+
+  class SearchDeletePageIndexJob < BaseSearchJob
+
+    def perform(page_id, locale)
+      ::Mongoid::Fields::I18n.with_locale(locale) do
+        page = Locomotive::Page.find(page_id)
+
+        search_backend(page.site, locale)&.delete_object('page', page_id)
+      end
+    end
+
+  end
+
+end

data/app/jobs/locomotive/search_index_content_entry_job.rb

@@ -0,0 +1,15 @@
+module Locomotive
+
+  class SearchIndexContentEntryJob < BaseSearchJob
+
+    def perform(entry_id, locale)
+      ::Mongoid::Fields::I18n.with_locale(locale) do
+        entry = Locomotive::ContentEntry.find(entry_id)
+
+        index_content_entry(entry.site, entry, locale)
+      end
+    end
+
+  end
+
+end

data/app/jobs/locomotive/search_index_page_job.rb

@@ -0,0 +1,15 @@
+module Locomotive
+
+  class SearchIndexPageJob < BaseSearchJob
+
+    def perform(page_id, locale)
+      ::Mongoid::Fields::I18n.with_locale(locale) do
+        page = Locomotive::Page.find(page_id)
+
+        index_page(page.site, page, locale)
+      end
+    end
+
+  end
+
+end

data/app/jobs/locomotive/search_index_site_job.rb

@@ -0,0 +1,31 @@
+module Locomotive
+
+  class SearchIndexSiteJob < BaseSearchJob
+
+    def perform(site_id)
+      site = Locomotive::Site.find(site_id)
+
+      # first remove all the indices for this site
+      search_backend(site, nil)&.clear_all_indices
+
+      # index the content in each locale
+      site.each_locale do |locale|
+        # index all the pages (except the 404 one)
+        site.pages.each do |page|
+          next if page.not_found?
+          index_page(site, page, locale)
+        end
+
+        # index all the content entries
+        site.content_types.each do |content_type|
+          content_type.entries.each do |entry|
+            index_content_entry(site, entry, locale)
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/app/models/locomotive/concerns/content_entry/index_content.rb

@@ -0,0 +1,63 @@
+module Locomotive
+  module Concerns
+    module ContentEntry
+
+      module IndexContent
+
+        def content_to_index
+          self.custom_fields_basic_attributes.map do |(name, value)|
+            _name = name.gsub(/_id$/, '').gsub(/_url$/, '')
+
+            next if !value.is_a?(String) ||
+              name == _label_field_name.to_s || # no need to index the label (already searchable)
+              self.file_custom_fields.include?(_name)
+
+            sanitize_search_content(value)
+          end.compact.join(' ')
+        end
+
+        def data_to_index(parent = false)
+          data = default_data_to_index
+
+          data.merge!(self.custom_fields_basic_attributes) unless parent
+
+          # we also index the belongs_to relationships but we only keep
+          # the most important data: _label, _slug, _content_type and
+          # potentially their own belongs_to relationships (recursive)
+          self.belongs_to_custom_fields.each do |name|
+            data[name] = send(name.to_sym)&.data_to_index(true)
+          end
+
+          data
+        end
+
+        private
+
+        def index_content
+          Locomotive::SearchIndexContentEntryJob.perform_later(
+            self._id.to_s,
+            ::Mongoid::Fields::I18n.locale.to_s
+          )
+        end
+
+        def unindex_content
+          Locomotive::SearchDeleteContentEntryIndexJob.perform_later(
+            self._id.to_s,
+            ::Mongoid::Fields::I18n.locale.to_s
+          )
+        end
+
+        def default_data_to_index
+          {
+            '_content_type' => self.content_type.slug,
+            '_slug'         => self._slug,
+            '_label'        => self._label
+          }
+        end
+
+      end
+
+    end
+  end
+end
+

data/app/models/locomotive/concerns/page/index_content.rb

@@ -0,0 +1,50 @@
+module Locomotive
+  module Concerns
+    module Page
+
+      module IndexContent
+
+        def content_to_index
+          self.editable_elements.where(_type: 'Locomotive::EditableText').map do |element|
+            sanitize_search_content(element.content)
+          end.join(' ')
+        end
+
+        def data_to_index
+          {
+            title:      self.title,
+            slug:       self.slug,
+            fullpath:   self.fullpath
+          }
+        end
+
+        private
+
+        def index_content
+          # don't index the 404 error page
+          return if self.not_found?
+
+          # don't block the server app
+          Locomotive::SearchIndexPageJob.perform_later(
+            self._id.to_s,
+            ::Mongoid::Fields::I18n.locale.to_s
+          )
+        end
+
+        def unindex_content
+          # don't index the 404 error page
+          return if self.not_found?
+
+          # don't block the server app
+          Locomotive::SearchDeletePageIndexJob.perform_later(
+            self._id.to_s,
+            ::Mongoid::Fields::I18n.locale.to_s
+          )
+        end
+
+      end
+
+    end
+  end
+end
+

data/app/models/locomotive/concerns/search.rb

@@ -0,0 +1,26 @@
+module Locomotive
+  module Concerns
+    module Search
+
+      extend ActiveSupport::Concern
+
+      included do
+
+        after_save      :index_content,   if: :search_enabled?
+        after_destroy   :unindex_content, if: :search_enabled?
+
+      end
+
+      private
+
+      def search_enabled?
+        Rails.configuration.x.locomotive_search_backend.enabled_for?(self.site)
+      end
+
+      def sanitize_search_content(text)
+        ::ActionController::Base.helpers.strip_tags(text)
+      end
+
+    end
+  end
+end

data/app/models/locomotive/concerns/site/build_indices.rb

@@ -0,0 +1,43 @@
+module Locomotive
+  module Concerns
+    module Site
+
+      module BuildIndices
+
+        extend ActiveSupport::Concern
+
+        included do
+
+          after_validation  :check_for_building_search_indices
+          before_save       :search_reset_done!,    if: :building_search_indices?
+          after_save        :build_search_indices,  if: :building_search_indices?
+
+        end
+
+        private
+
+        def building_search_indices?
+          !!@building_search_indices
+        end
+
+        def check_for_building_search_indices
+          @building_search_indices = search_reset?
+        end
+
+        def build_search_indices
+          Locomotive::SearchIndexSiteJob.perform_later(self._id.to_s)
+        end
+
+        def search_reset?
+          Rails.configuration.x.locomotive_search_backend.reset_for?(self)
+        end
+
+        def search_reset_done!
+          Rails.configuration.x.locomotive_search_backend.reset_done!(self)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/search/backend/algolia.rb

@@ -0,0 +1,89 @@
+require 'algoliasearch'
+
+module Locomotive
+  module Search
+    module Backend
+
+      class Algolia
+
+        attr :site, :locale, :client
+
+        def initialize(site, locale)
+          @site, @locale = site, locale
+
+          if site.metafields['algolia']
+            credentials  = site.metafields['algolia'].slice('application_id', 'api_key').symbolize_keys
+            @client      = ::Algolia::Client.new(credentials)
+          end
+        end
+
+        # Add the object to 2 indices:
+        # - global: in order to perform a global search among all the entities: page, content entries
+        # - object: in order to perform a local search among the pages or a content type
+        #
+        # Names of the indices:
+        # - global: locomotive-<Rails env>-<site handle>-<locale>
+        # - object: locomotive-<Rails env>-<site handle>-<locale>-<type: page or a content type>
+        #
+        def save_object(type: nil, object_id: nil, title: nil, content: nil, visible: true, data: {})
+          base_object = { objectID: object_id, visible: visible, type: type }
+          object      = { title: title, content: content, data: data }.merge(base_object)
+
+          object_index(type).save_objects([data.merge(base_object)])
+          global_index.save_objects([object])
+        end
+
+        def delete_object(type, object_id)
+          object_type_index(type).delete_object(object_id)
+          global_index.delete_object(object_id)
+        end
+
+        def clear_all_indices
+          client.list_indexes['items'].each do |index_attributes|
+            name = index_attributes['name']
+
+            next unless name =~ /^#{self.base_index_name}-/
+
+            ::Algolia::Index.new(name, self.client).clear_index
+          end
+        end
+
+        def valid?
+          @client.present?
+        end
+
+        def global_index
+          name = [base_index_name, self.locale].join('-')
+          ::Algolia::Index.new(name, self.client)
+        end
+
+        def object_index(type)
+          name = [base_index_name, self.locale, type].join('-')
+          ::Algolia::Index.new(name, self.client)
+        end
+
+        def base_index_name
+          ['locomotive', Rails.env, self.site.handle].join('-')
+        end
+
+        def self.enabled_for?(site)
+          site.metafields.present? &&
+          site.metafields['algolia'].present? &&
+          site.metafields['algolia']['application_id'].present? &&
+          site.metafields['algolia']['api_key'].present?
+        end
+
+        def self.reset_for?(site)
+          enabled_for?(site) &&
+          [1, '1', true].include?(site.metafields['algolia']['reset'])
+        end
+
+        def self.reset_done!(site)
+          site.metafields['algolia']['reset'] = false
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/search/backend_factory.rb

@@ -0,0 +1,52 @@
+module Locomotive
+  module Search
+
+    class BackendFactory
+
+      attr_reader :klass
+
+      def initialize(name_or_klass)
+        if name_or_klass.is_a?(Symbol) || name_or_klass.is_a?(String)
+          begin
+            require_relative "./backend/#{name_or_klass}"
+            @klass = "Locomotive::Search::Backend::#{name_or_klass.to_s.camelize}".constantize
+          rescue LoadError
+            raise UnknownBackendError.new("'#{name_or_klass}' is not a valid backend")
+          end
+        else
+          @klass = name_or_klass
+        end
+      end
+
+      def create(site, locale)
+        return nil unless self.setup?
+
+        backend = self.klass.new(site, locale)
+        backend.valid? ? backend : nil
+      end
+
+      def name
+        return nil unless self.setup?
+
+        self.klass.name.demodulize.underscore
+      end
+
+      def setup?
+        self.klass.present?
+      end
+
+      def enabled_for?(site)
+        self.setup? && self.klass.enabled_for?(site)
+      end
+
+      def reset_for?(site)
+        self.setup? && self.klass.reset_for?(site)
+      end
+
+      def reset_done!(site)
+        self.setup? && self.klass.reset_done!(site)
+      end
+
+    end
+  end
+end

data/lib/locomotive/search/engine.rb

@@ -0,0 +1,21 @@
+module Locomotive
+  module Search
+    class Engine < ::Rails::Engine
+
+      initializer 'locomotive.search.backend' do |app|
+        if backend_name = app.config.x.locomotive_search_backend
+          app.config.x.locomotive_search_backend = BackendFactory.new(backend_name)
+        end
+      end
+
+      # Allow the pkugin to change the behavior of Locomotive controllers and
+      # models in a clean way.
+      config.to_prepare do
+        Dir.glob(Engine.root + 'app/decorators/**/*_decorator*.rb').each do |c|
+          require_dependency(c)
+        end
+      end
+
+    end
+  end
+end

data/lib/locomotive/search/errors.rb

@@ -0,0 +1,5 @@
+module Locomotive::Search
+
+  class UnknownBackendError < StandardError; end
+
+end

data/lib/locomotive/search/version.rb

@@ -0,0 +1,5 @@
+module Locomotive
+  module Search
+    VERSION = '0.1.0'
+  end
+end

data/lib/locomotivecms_search.rb

@@ -0,0 +1,7 @@
+require 'locomotive/search/errors'
+require 'locomotive/search/backend_factory'
+require 'locomotive/search/engine'
+
+module Locomotive::Search
+  # Your code goes here...
+end

data/lib/tasks/locomotive/search_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :search do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: locomotivecms_search
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Didier Lafforgue
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-04-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.1.6
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.1.6
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: algoliasearch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.19'
+description: 'The LocomotiveCMS search automatically indexes the content of each site.
+  Search engine supported: Algolia'
+email:
+- didier@nocoffee.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/decorators/locomotive/content_entry_decorator.rb
+- app/decorators/locomotive/page_decorator.rb
+- app/decorators/locomotive/site_decorator.rb
+- app/jobs/locomotive/base_search_job.rb
+- app/jobs/locomotive/search_delete_content_entry_index_job.rb
+- app/jobs/locomotive/search_delete_page_index_job.rb
+- app/jobs/locomotive/search_index_content_entry_job.rb
+- app/jobs/locomotive/search_index_page_job.rb
+- app/jobs/locomotive/search_index_site_job.rb
+- app/models/locomotive/concerns/content_entry/index_content.rb
+- app/models/locomotive/concerns/page/index_content.rb
+- app/models/locomotive/concerns/search.rb
+- app/models/locomotive/concerns/site/build_indices.rb
+- lib/locomotive/search/backend/algolia.rb
+- lib/locomotive/search/backend_factory.rb
+- lib/locomotive/search/engine.rb
+- lib/locomotive/search/errors.rb
+- lib/locomotive/search/version.rb
+- lib/locomotivecms_search.rb
+- lib/tasks/locomotive/search_tasks.rake
+homepage: https://www.locomotivecms.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: The LocomotiveCMS search enables advanced search functionalities for each
+  site
+test_files: []