mini-smart-box 0.0.1

data/elasticsearch-rails-8.0.1/lib/rails/templates/search_controller_test.rb

@@ -0,0 +1,148 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+require 'test_helper'
+
+class SearchControllerTest < ActionController::TestCase
+  setup do
+    travel_to Time.new(2015, 03, 16, 10, 00, 00, 0)
+
+    Article.delete_all
+
+    articles = [
+      { title: 'Article One', abstract: 'One', content: 'One', published_on: 1.day.ago, category_title: 'One', author_first_name: 'John', author_last_name: 'Smith' },
+      { title: 'Article One Another', abstract: '', content: '', published_on: 2.days.ago, category_title: 'One', author_first_name: 'John', author_last_name: 'Smith' },
+      { title: 'Article One Two', abstract: '', content: '', published_on: 10.days.ago, category_title: 'Two', author_first_name: 'Mary', author_last_name: 'Smith' },
+      { title: 'Article Two', abstract: '', content: '', published_on: 12.days.ago, category_title: 'Two', author_first_name: 'Mary', author_last_name: 'Smith' },
+      { title: 'Article Three', abstract: '', content: '', published_on: 12.days.ago, category_title: 'Three', author_first_name: 'Alice', author_last_name: 'Smith' }
+    ]
+
+    articles.each do |a|
+      article = Article.create! \
+        title:    a[:title],
+        abstract: a[:abstract],
+        content:  a[:content],
+        published_on: a[:published_on]
+
+      article.categories << Category.find_or_create_by!(title: a[:category_title])
+
+      article.authors << Author.find_or_create_by!(first_name: a[:author_first_name], last_name: a[:author_last_name])
+
+      article.save!
+    end
+
+    Article.find_by_title('Article Three').comments.create body: 'One'
+
+    Sidekiq::Worker.clear_all
+
+    Article.__elasticsearch__.import force: true
+    Article.__elasticsearch__.refresh_index!
+  end
+
+  test "should return search results" do
+    get :index, params: { q: 'one' }
+    assert_response :success
+    assert_equal 3, assigns(:articles).size
+  end
+
+  test "should return search results in comments" do
+    get :index, params: { q: 'one', comments: 'y' }
+    assert_response :success
+
+    assert_equal 4, assigns(:articles).size
+  end
+
+  test "should return highlighted snippets" do
+    get :index, params: { q: 'one' }
+    assert_response :success
+    assert_match %r{<em class="label label-highlight">One</em>}, assigns(:articles).first.highlight.title.first
+  end
+
+  test "should return suggestions" do
+    get :index, params: { q: 'one' }
+    assert_response :success
+
+    suggestions = assigns(:articles).response.suggestions
+
+    assert_equal 'one', suggestions['suggest_title'][0]['text']
+  end
+
+  test "should return facets" do
+    get :index, params: { q: 'one' }
+    assert_response :success
+
+    aggregations = assigns(:articles).response.response['aggregations']
+
+    assert_equal 2, aggregations['categories']['categories']['buckets'].size
+    assert_equal 2, aggregations['authors']['authors']['buckets'].size
+    assert_equal 2, aggregations['published']['published']['buckets'].size
+
+    assert_equal 'One', aggregations['categories']['categories']['buckets'][0]['key']
+    assert_equal 'John Smith', aggregations['authors']['authors']['buckets'][0]['key']
+    assert_equal 1425254400000, aggregations['published']['published']['buckets'][0]['key']
+  end
+
+  test "should sort on the published date" do
+    get :index, params: { q: 'one', s: 'published_on' }
+    assert_response :success
+
+    assert_equal 3, assigns(:articles).size
+    assert_equal '2015-03-15', assigns(:articles)[0].published_on
+    assert_equal '2015-03-14', assigns(:articles)[1].published_on
+    assert_equal '2015-03-06', assigns(:articles)[2].published_on
+  end
+
+  test "should sort on the published date when no query is provided" do
+    get :index, params: { q: '' }
+    assert_response :success
+
+    assert_equal 5, assigns(:articles).size
+    assert_equal '2015-03-15', assigns(:articles)[0].published_on
+    assert_equal '2015-03-14', assigns(:articles)[1].published_on
+    assert_equal '2015-03-06', assigns(:articles)[2].published_on
+  end
+
+  test "should filter search results and the author and published date facets when user selects a category" do
+    get :index, params: { q: 'one', c: 'One' }
+    assert_response :success
+
+    assert_equal 2, assigns(:articles).size
+
+    aggregations = assigns(:articles).response.response['aggregations']
+
+    assert_equal 1, aggregations['authors']['authors']['buckets'].size
+    assert_equal 1, aggregations['published']['published']['buckets'].size
+
+    # Do NOT filter the category facet
+    assert_equal 2, aggregations['categories']['categories']['buckets'].size
+  end
+
+  test "should filter search results and the category and published date facets when user selects a category" do
+    get :index, params: { q: 'one', a: 'Mary Smith' }
+    assert_response :success
+
+    assert_equal 1, assigns(:articles).size
+
+    aggregations = assigns(:articles).response.response['aggregations']
+
+    assert_equal 1, aggregations['categories']['categories']['buckets'].size
+    assert_equal 1, aggregations['published']['published']['buckets'].size
+
+    # Do NOT filter the authors facet
+    assert_equal 2, aggregations['authors']['authors']['buckets'].size
+  end
+end

data/elasticsearch-rails-8.0.1/lib/rails/templates/searchable.dsl.rb

@@ -0,0 +1,234 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+module Searchable
+  extend ActiveSupport::Concern
+
+  included do
+    include Elasticsearch::Model
+
+    # Customize the index name
+    #
+    index_name [Rails.application.engine_name, Rails.env].join('_')
+
+    # Set up index configuration and mapping
+    #
+    settings index: { number_of_shards: 1, number_of_replicas: 0 } do
+      mapping do
+        indexes :title, type: 'text' do
+          indexes :title,     analyzer: 'snowball'
+          indexes :tokenized, analyzer: 'simple'
+        end
+
+        indexes :content, type: 'text'  do
+          indexes :content,   analyzer: 'snowball'
+          indexes :tokenized, analyzer: 'simple'
+        end
+
+        indexes :published_on, type: 'date'
+
+        indexes :authors do
+          indexes :full_name, type: 'text' do
+            indexes :full_name
+            indexes :raw, type: 'keyword'
+          end
+        end
+
+        indexes :categories, type: 'keyword'
+
+        indexes :comments, type: 'nested' do
+          indexes :body, analyzer: 'snowball'
+          indexes :stars
+          indexes :pick
+          indexes :user, type: 'keyword'
+          indexes :user_location, type: 'text' do
+            indexes :user_location
+            indexes :raw, type: 'keyword'
+          end
+        end
+      end
+    end
+
+    # Set up callbacks for updating the index on model changes
+    #
+    after_commit lambda { Indexer.perform_async(:index,  self.class.to_s, self.id) }, on: :create
+    after_commit lambda { Indexer.perform_async(:update, self.class.to_s, self.id) }, on: :update
+    after_commit lambda { Indexer.perform_async(:delete, self.class.to_s, self.id) }, on: :destroy
+    after_touch  lambda { Indexer.perform_async(:update, self.class.to_s, self.id) }
+
+    # Customize the JSON serialization for Elasticsearch
+    #
+    def as_indexed_json(options={})
+      hash = self.as_json(
+        include: { authors:    { methods: [:full_name], only: [:full_name] },
+                   comments:   { only: [:body, :stars, :pick, :user, :user_location] }
+                 })
+      hash['categories'] = self.categories.map(&:title)
+      hash
+    end
+
+    # Return documents matching the user's query, include highlights and aggregations in response,
+    # and implement a "cross" faceted navigation
+    #
+    # @param q [String] The user query
+    # @return [Elasticsearch::Model::Response::Response]
+    #
+    def self.search(q, options={})
+      @search_definition = Elasticsearch::DSL::Search.search do
+        query do
+
+          # If a user query is present...
+          #
+          unless q.blank?
+            bool do
+
+              # ... search in `title`, `abstract` and `content`, boosting `title`
+              #
+              should do
+                multi_match do
+                  query    q
+                  fields   ['title^10', 'abstract^2', 'content']
+                  operator 'and'
+                end
+              end
+
+              # ... search in comment body if user checked the comments checkbox
+              #
+              if q.present? && options[:comments]
+                should do
+                  nested do
+                    path :comments
+                    query do
+                      multi_match do
+                        query q
+                        fields   'comments.body'
+                        operator 'and'
+                      end
+                    end
+                  end
+                end
+              end
+            end
+
+          # ... otherwise, just return all articles
+          else
+            match_all
+          end
+        end
+
+        # Filter the search results based on user selection
+        #
+        post_filter do
+          bool do
+            must { term categories: options[:category] } if options[:category]
+            must { match_all } if options.keys.none? { |k| [:c, :a, :w].include? k }
+            must { term 'authors.full_name.raw' => options[:author] } if options[:author]
+            must { range published_on: { gte: options[:published_week], lte: "#{options[:published_week]}||+1w" } } if options[:published_week]
+          end
+        end
+
+        # Return top categories for faceted navigation
+        #
+        aggregation :categories do
+          # Filter the aggregation with any selected `author` and `published_week`
+          #
+          f = Elasticsearch::DSL::Search::Filters::Bool.new
+          f.must { match_all }
+          f.must { term 'authors.full_name.raw' => options[:author] } if options[:author]
+          f.must { range published_on: { gte: options[:published_week], lte: "#{options[:published_week]}||+1w" } } if options[:published_week]
+
+          filter f.to_hash do
+            aggregation :categories do
+              terms field: 'categories'
+            end
+          end
+        end
+
+        # Return top authors for faceted navigation
+        #
+        aggregation :authors do
+          # Filter the aggregation with any selected `category` and `published_week`
+          #
+          f = Elasticsearch::DSL::Search::Filters::Bool.new
+          f.must { match_all }
+          f.must { term categories: options[:category] } if options[:category]
+          f.must { range published_on: { gte: options[:published_week], lte: "#{options[:published_week]}||+1w" } } if options[:published_week]
+
+          filter f do
+            aggregation :authors do
+              terms field: 'authors.full_name.raw'
+            end
+          end
+        end
+
+        # Return the published date ranges for faceted navigation
+        #
+        aggregation :published do
+          # Filter the aggregation with any selected `author` and `category`
+          #
+          f = Elasticsearch::DSL::Search::Filters::Bool.new
+          f.must { match_all }
+          f.must { term 'authors.full_name.raw' => options[:author] } if options[:author]
+          f.must { term categories: options[:category] } if options[:category]
+
+          filter f do
+            aggregation :published do
+              date_histogram do
+                field    'published_on'
+                interval 'week'
+              end
+            end
+          end
+        end
+
+        # Highlight the snippets in results
+        #
+        highlight do
+          fields title:    { number_of_fragments: 0 },
+                 abstract: { number_of_fragments: 0 },
+                 content:  { fragment_size: 50 }
+
+          field  'comments.body', fragment_size: 50 if q.present? && options[:comments]
+
+          pre_tags  '<em class="label label-highlight">'
+          post_tags '</em>'
+        end
+
+        case
+          # By default, sort by relevance, but when a specific sort option is present, use it ...
+          #
+          when options[:sort]
+            sort options[:sort].to_sym => 'desc'
+            track_scores true
+          #
+          # ... when there's no user query, sort on published date
+          #
+          when q.blank?
+            sort published_on: 'desc'
+        end
+
+        # Return suggestions unless there's no query from the user
+        unless q.blank?
+          suggest :suggest_title, text: q, term: { field: 'title.tokenized', suggest_mode: 'always' }
+          suggest :suggest_body,  text: q, term: { field: 'content.tokenized', suggest_mode: 'always' }
+        end
+      end
+
+      __elasticsearch__.search(@search_definition)
+    end
+  end
+end

data/elasticsearch-rails-8.0.1/lib/rails/templates/searchable.rb

@@ -0,0 +1,224 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+module Searchable
+  extend ActiveSupport::Concern
+
+  included do
+    include Elasticsearch::Model
+
+    # Customize the index name
+    #
+    index_name [Rails.application.engine_name, Rails.env].join('_')
+
+    # Set up index configuration and mapping
+    #
+    settings index: { number_of_shards: 1, number_of_replicas: 0 } do
+      mapping do
+        indexes :title, type: 'text' do
+          indexes :title,     analyzer: 'snowball'
+          indexes :tokenized, analyzer: 'simple'
+        end
+
+        indexes :content, type: 'text'  do
+          indexes :content,   analyzer: 'snowball'
+          indexes :tokenized, analyzer: 'simple'
+        end
+
+        indexes :published_on, type: 'date'
+
+        indexes :authors do
+          indexes :full_name, type: 'text' do
+            indexes :full_name
+            indexes :raw, type: 'keyword'
+          end
+        end
+
+        indexes :categories, type: 'keyword'
+
+        indexes :comments, type: 'nested' do
+          indexes :body, analyzer: 'snowball'
+          indexes :stars
+          indexes :pick
+          indexes :user, type: 'keyword'
+          indexes :user_location, type: 'text' do
+            indexes :user_location
+            indexes :raw, type: 'keyword'
+          end
+        end
+      end
+    end
+
+    # Set up callbacks for updating the index on model changes
+    #
+    after_commit lambda { Indexer.perform_async(:index,  self.class.to_s, self.id) }, on: :create
+    after_commit lambda { Indexer.perform_async(:update, self.class.to_s, self.id) }, on: :update
+    after_commit lambda { Indexer.perform_async(:delete, self.class.to_s, self.id) }, on: :destroy
+    after_touch  lambda { Indexer.perform_async(:update, self.class.to_s, self.id) }
+
+    # Customize the JSON serialization for Elasticsearch
+    #
+    def as_indexed_json(options={})
+      hash = self.as_json(
+        include: { authors:    { methods: [:full_name], only: [:full_name] },
+                   comments:   { only: [:body, :stars, :pick, :user, :user_location] }
+                 })
+      hash['categories'] = self.categories.map(&:title)
+      hash
+    end
+
+    # Search in title and content fields for `query`, include highlights in response
+    #
+    # @param query [String] The user query
+    # @return [Elasticsearch::Model::Response::Response]
+    #
+    def self.search(query, options={})
+
+      # Prefill and set the filters (top-level `post_filter` and aggregation `filter` elements)
+      #
+      __set_filters = lambda do |key, f|
+        @search_definition[:post_filter][:bool] ||= {}
+        @search_definition[:post_filter][:bool][:must] ||= []
+        @search_definition[:post_filter][:bool][:must]  |= [f]
+
+        @search_definition[:aggregations][key.to_sym][:filter][:bool][:must] ||= []
+        @search_definition[:aggregations][key.to_sym][:filter][:bool][:must]  |= [f]
+      end
+
+      @search_definition = {
+        query: {},
+
+        highlight: {
+          pre_tags: ['<em class="label label-highlight">'],
+          post_tags: ['</em>'],
+          fields: {
+            title:    { number_of_fragments: 0 },
+            abstract: { number_of_fragments: 0 },
+            content:  { fragment_size: 50 }
+          }
+        },
+
+        post_filter: { bool: { must: [ match_all: {} ] } },
+
+        aggregations: {
+          categories: {
+            filter: { bool: { must: [ match_all: {} ] } },
+            aggregations: { categories: { terms: { field: 'categories' } } }
+          },
+          authors: {
+            filter: { bool: { must: [ match_all: {} ] } },
+            aggregations: { authors: { terms: { field: 'authors.full_name.raw' } } }
+          },
+          published: {
+            filter: { bool: { must: [ match_all: {} ] } },
+            aggregations: {
+              published: { date_histogram: { field: 'published_on', interval: 'week' } }
+            }
+          }
+        }
+      }
+
+      unless query.blank?
+        @search_definition[:query] = {
+          bool: {
+            should: [
+              { multi_match: {
+                  query: query,
+                  fields: ['title^10', 'abstract^2', 'content'],
+                  operator: 'and'
+                }
+              }
+            ]
+          }
+        }
+      else
+        @search_definition[:query] = { match_all: {} }
+        @search_definition[:sort]  = { published_on: 'desc' }
+      end
+
+      if options[:category]
+        f = { term: { categories: options[:category] } }
+
+        __set_filters.(:authors, f)
+        __set_filters.(:published, f)
+      end
+
+      if options[:author]
+        f = { term: { 'authors.full_name.raw' => options[:author] } }
+
+        __set_filters.(:categories, f)
+        __set_filters.(:published, f)
+      end
+
+      if options[:published_week]
+        f = {
+          range: {
+            published_on: {
+              gte: options[:published_week],
+              lte: "#{options[:published_week]}||+1w"
+            }
+          }
+        }
+
+        __set_filters.(:categories, f)
+        __set_filters.(:authors, f)
+      end
+
+      if query.present? && options[:comments]
+        @search_definition[:query][:bool][:should] ||= []
+        @search_definition[:query][:bool][:should] << {
+          nested: {
+            path: 'comments',
+            query: {
+              multi_match: {
+                query: query,
+                fields: ['comments.body'],
+                operator: 'and'
+              }
+            }
+          }
+        }
+        @search_definition[:highlight][:fields].update 'comments.body' => { fragment_size: 50 }
+      end
+
+      if options[:sort]
+        @search_definition[:sort]  = { options[:sort] => 'desc' }
+        @search_definition[:track_scores] = true
+      end
+
+      unless query.blank?
+        @search_definition[:suggest] = {
+          text: query,
+          suggest_title: {
+            term: {
+              field: 'title.tokenized',
+              suggest_mode: 'always'
+            }
+          },
+          suggest_body: {
+            term: {
+              field: 'content.tokenized',
+              suggest_mode: 'always'
+            }
+          }
+        }
+      end
+
+      __elasticsearch__.search(@search_definition)
+    end
+  end
+end

data/elasticsearch-rails-8.0.1/lib/rails/templates/seeds.rb

@@ -0,0 +1,75 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+require 'zlib'
+require 'yaml'
+
+Zlib::GzipReader.open(File.expand_path('../articles.yml.gz', __FILE__)) do |gzip|
+  puts "Reading articles from gzipped YAML..."
+  @documents = YAML.respond_to?(:load_documents) ? YAML.load_documents(gzip.read) : 
+    YAML.load_stream(gzip.read)
+end
+
+# Truncate the default ActiveRecord logger output
+ActiveRecord::Base.logger = ActiveSupport::Logger.new(STDERR)
+ActiveRecord::Base.logger.instance_eval do
+  @formatter = lambda do |s, d, p, message|
+    message
+      .gsub(/\[("content", ".*?")\]/m) { |match| match[0..100] + '..."]' }
+      .gsub(/\[("body", ".*?")\]/m   ) { |match| match[0..100] + '..."]' }
+      .strip
+      .concat("\n")
+  end
+end
+
+# Reduce verbosity and truncate the request body of Elasticsearch logger
+Article.__elasticsearch__.client.transport.tracer.level = Logger::INFO
+Article.__elasticsearch__.client.transport.tracer.formatter = lambda do |s, d, p, message|
+  "\n\n" + (message.size > 105 ? message[0..105].concat("...}'") : message) + "\n\n"
+end
+
+# Skip model callbacks
+%w| _touch_callbacks
+    _commit_callbacks
+    after_add_for_categories
+    after_add_for_authorships
+    after_add_for_authors
+    after_add_for_comments  |.each do |c|
+    Article.class.__send__ :define_method, c do; []; end
+  end
+
+@documents.each do |document|
+  article = Article.create! document.slice(:title, :abstract, :content, :url, :shares, :published_on)
+
+  article.categories = document[:categories].map do |d|
+    Category.find_or_create_by! title: d
+  end
+
+  article.authors = document[:authors].map do |d|
+    first_name, last_name = d.split(' ').compact.map(&:strip)
+    Author.find_or_create_by! first_name: first_name, last_name: last_name
+  end
+
+  document[:comments].each { |d| article.comments.create! d }
+
+  article.save!
+end
+
+# Remove any jobs from the "elasticsearch" Sidekiq queue
+#
+require 'sidekiq/api'
+Sidekiq::Queue.new("elasticsearch").clear