mongoid_search 0.3.6 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 65d13fcd90c890df7b15f2175b701e951259f8de
-  data.tar.gz: '097843e60c25fc38ddb96789093dc798a08c5739'
+SHA256:
+  metadata.gz: 6551ebbcf9e4da8d5ef2bd51036aa3580e7c4023043d228ce88cb8069c8bba31
+  data.tar.gz: a1b040501713dbb5d7f874dadeb2a05cc5a0af3f80dc89b4b8b387afa02abb1f
 SHA512:
-  metadata.gz: a13b1d7f1bce08ffed931346ec1b1b6750ad984aeb263d93fc1c1db3dd8d03761a763958fb8d000ec19b0ea98b791e3d15020cd152375dbc5d5e19338cc5944f
-  data.tar.gz: 71008ecd40e79df705f769d03e0b03953a3278b3cb46ceb325b212e48b8c1321c58aa540750b094d8a94cc9082cbd66e13bba145ebfc7c0af6f78ce7a72fa796
+  metadata.gz: e24c0139031664d6616db5ba52338850d0cb4b2fbb9e82920a8db4e0cfb87b1cc0dabb9ba4bf17e78699143682f2055bdd5ac9acc9ed9d475decb73d76b06129
+  data.tar.gz: f4a234e8c235fa037362715e405e9dc45ea85d18e5de54274b8525e3f5cb9173d6d230696ff7b2031e0f4bcd58bfeaa75a9456a69f00d47088f50bb15f211019

data/README.md

@@ -1,8 +1,8 @@
 # Mongoid Search
 
-Mongoid Search is a simple full text search implementation for Mongoid ORM. It supports Mongoid 3, 4, 5 and 6 and performs well for small data sets. If your searchable model is big (i.e. 1.000.000+ records), [mongoid_fulltext](https://github.com/mongoid/mongoid_fulltext), ElasticSearch, Solr or Sphinx may suit you better.
+Mongoid Search is a simple full text search implementation for Mongoid ORM. It supports Mongoid 6, 7, and 8 and performs well for small data sets. If your searchable model is big (i.e. 1.000.000+ records), [mongoid_fulltext](https://github.com/mongoid/mongoid_fulltext), ElasticSearch, Solr or Sphinx may suit you better.
 
-[![Build Status](https://travis-ci.org/mongoid/mongoid_search.svg?branch=master)](https://travis-ci.org/mongoid/mongoid_search)
+[![Test](https://github.com/mongoid/mongoid_search/actions/workflows/test.yml/badge.svg)](https://github.com/mongoid/mongoid_search/actions/workflows/test.yml)
 
 ## Installation
 
@@ -73,6 +73,22 @@ Product.full_text_search("apple iphone").size
 # => 1
 ```
 
+You can also search in "virtual" fields by defining them as methods. This can be useful when you have a method with dynamic fields (i.e. variable schema).
+```ruby
+class ModelWithDynamicFields
+  
+  ...
+  
+  search_in :search_data
+
+  def search_data
+    # concatenate all String fields' values
+    self.attributes.select{|k,v| v.is_a?(String) }.values.join(' ')
+  end
+end
+```
+Mongoid_search will run the method before save and use it's output to populate the `_keywords` field.
+
 Of course, some models could have more than one index. For instance, two different searches with different fields, so you could even specify from which index should be searched:
 
 ```ruby

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rubygems'
 require 'rake'
 

data/lib/mongoid_search/log.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Mongoid::Search::Log
   cattr_accessor :silent
 

data/lib/mongoid_search/mongoid_search.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid::Search
   extend ActiveSupport::Concern
 
@@ -11,7 +13,7 @@ module Mongoid::Search
     @@classes
   end
 
-  module ClassMethods #:nodoc:
+  module ClassMethods # :nodoc:
     # Set a field or a number of fields as sources for search
     def search_in(*args)
       args, options = args_and_options(args)
@@ -65,7 +67,7 @@ module Mongoid::Search
         { options[:index] => kw }
       end
 
-      criteria.send("#{(options[:match])}_of", *keywords_hash)
+      criteria.send("#{options[:match]}_of", *keywords_hash)
     end
 
     def args_and_options(args)
@@ -92,7 +94,7 @@ module Mongoid::Search
     end
 
     def search_relevant(query, options)
-      results_with_relevance(query, options).sort { |o| o['value'] }.map do |r|
+      results_with_relevance(query, options).sort_by { |o| o['value'] }.map do |r|
         new(r['_id'].merge(relevance: r['value'])) do |o|
           # Need to match the actual object
           o.instance_variable_set('@new_record', false)

data/lib/mongoid_search/railtie.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid::Search
   class Railtie < Rails::Railtie
     rake_tasks do

data/lib/mongoid_search/tasks/mongoid_search.rake

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 namespace :mongoid_search do
   desc 'Goes through all documents with search enabled and indexes the keywords.'
   task index: :environment do
-    ::Rails.application.eager_load!
+    Rails.application.eager_load!
     if Mongoid::Search.classes.blank?
       Mongoid::Search::Log.log "No model to index keywords.\n"
     else
       Mongoid::Search.classes.each do |klass|
-        Mongoid::Search::Log.silent = ENV['SILENT']
+        Mongoid::Search::Log.silent = ENV.fetch('SILENT', nil)
         Mongoid::Search::Log.log "\nIndexing documents for #{klass.name}:\n"
         klass.index_keywords!
       end

data/lib/mongoid_search/util.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module Mongoid::Search::Util
   def self.keywords(klass, fields)
@@ -17,8 +18,8 @@ module Mongoid::Search::Util
         end
       end
     else
-      value = if klass.respond_to?(fields.to_s + '_translations')
-                klass.send(fields.to_s + '_translations').values
+      value = if klass.respond_to?("#{fields}_translations")
+                klass.send("#{fields}_translations").values
               elsif klass.respond_to?(fields)
                 klass.send(fields)
               else
@@ -38,15 +39,15 @@ module Mongoid::Search::Util
     strip_accents = Mongoid::Search.strip_accents
 
     return [] if text.blank?
+
     text = text.to_s
-               .mb_chars
-               .normalize(:kd)
+               .unicode_normalize(:nfkd)
                .downcase
                .to_s
                .gsub(strip_symbols, ' ') # strip symbols
                .gsub(strip_accents, '')  # strip accents
-               .gsub(/[#{ligatures.keys.join("")}]/) { |c| ligatures[c] }
-               .split(' ')
+               .gsub(/[#{ligatures.keys.join}]/) { |c| ligatures[c] }
+               .split
                .reject { |word| word.size < Mongoid::Search.minimum_word_size }
     text = text.reject { |word| ignore_list.include?(word) } unless ignore_list.blank?
     text = text.map(&stem_proc) if stem_keywords

data/lib/mongoid_search.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'mongoid_search/mongoid_search'
 
 require 'mongoid_search/railtie' if defined?(Rails)
@@ -58,7 +60,7 @@ module Mongoid::Search
 
   # Strip special symbols
   mattr_accessor :strip_symbols
-  @@strip_symbols = /[._:;'\"`,?|+={}()!@#%^&*<>~\$\-\\\/\[\]]/
+  @@strip_symbols = /[._:;'"`,?|+={}()!@#%^&*<>~$\-\\\/\[\]]/
 
   # Strip accents
   mattr_accessor :strip_accents

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongoid_search
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.5.0
 platform: ruby
 authors:
 - Mauricio Zaffari
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-05-17 00:00:00.000000000 Z
+date: 2026-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fast-stemmer
@@ -30,70 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 6.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
-- !ruby/object:Gem::Dependency
-  name: database_cleaner
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.8.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.8.0
-- !ruby/object:Gem::Dependency
-  name: mongoid-compatibility
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '11.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '11.0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.4'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.4'
+        version: 6.0.0
 description: Simple full text search implementation.
 email:
 - mauricio@papodenerd.net
@@ -104,27 +48,18 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- VERSION
 - lib/mongoid_search.rb
 - lib/mongoid_search/log.rb
 - lib/mongoid_search/mongoid_search.rb
 - lib/mongoid_search/railtie.rb
 - lib/mongoid_search/tasks/mongoid_search.rake
 - lib/mongoid_search/util.rb
-- spec/config/ignorelist.yml
-- spec/models/category.rb
-- spec/models/product.rb
-- spec/models/subproduct.rb
-- spec/models/tag.rb
-- spec/models/variant.rb
-- spec/mongoid_search_spec.rb
-- spec/spec_helper.rb
-- spec/util_spec.rb
-homepage: http://www.papodenerd.net/mongoid-search-full-text-search-for-your-mongoid-models/
+homepage: https://github.com/mongoid/mongoid_search
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -132,25 +67,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14
-signing_key: 
+rubygems_version: 3.4.19
+signing_key:
 specification_version: 4
 summary: Search implementation for Mongoid ORM
-test_files:
-- spec/models/variant.rb
-- spec/models/category.rb
-- spec/models/product.rb
-- spec/models/tag.rb
-- spec/models/subproduct.rb
-- spec/config/ignorelist.yml
-- spec/spec_helper.rb
-- spec/util_spec.rb
-- spec/mongoid_search_spec.rb
+test_files: []

data/VERSION

@@ -1 +0,0 @@
-0.3.6

data/spec/config/ignorelist.yml

@@ -1,2 +0,0 @@
-ignorelist:
-  amazing, awesome

data/spec/models/category.rb

@@ -1,9 +0,0 @@
-class Category
-  include Mongoid::Document
-  include Mongoid::Attributes::Dynamic if ::Mongoid::VERSION >= '4'
-
-  field :name, localize: true
-  field :description
-
-  has_many :products
-end

data/spec/models/product.rb

@@ -1,24 +0,0 @@
-class Product
-  include Mongoid::Document
-  include Mongoid::Search
-  include Mongoid::Attributes::Dynamic if ::Mongoid::VERSION >= '4'
-
-  field :brand
-  field :name
-  field :unit
-  field :measures, type: Array
-  field :attrs, type: Array
-  field :info, type: Hash
-
-  has_many :tags
-  if Mongoid::Compatibility::Version.mongoid6_or_newer?
-    belongs_to  :category, required: false
-  else
-    belongs_to  :category
-  end
-  embeds_many :subproducts
-
-  search_in :brand, :name, :outlet, :attrs, tags: :name, category: %i[name description],
-                                            subproducts: %i[brand name], info: %i[summary description]
-  search_in :unit, :measures, index: :_unit_keywords
-end

data/spec/models/subproduct.rb

@@ -1,9 +0,0 @@
-class Subproduct
-  include Mongoid::Document
-  include Mongoid::Attributes::Dynamic if ::Mongoid::VERSION >= '4'
-
-  field :brand
-  field :name
-
-  embedded_in :product, inverse_of: :subproducts
-end

data/spec/models/tag.rb

@@ -1,15 +0,0 @@
-class Tag
-  include Mongoid::Document
-  include Mongoid::Search
-  include Mongoid::Attributes::Dynamic if ::Mongoid::VERSION >= '4'
-
-  field :name
-
-  belongs_to :product
-
-  def title
-    name
-  end
-
-  search_in :title, product: [:name, { info: %i[summary description], category: %i[name description] }]
-end

data/spec/models/variant.rb

@@ -1,7 +0,0 @@
-autoload :Product, 'models/product.rb'
-class Variant < Product
-  field :color
-  field :size
-  search_in :color
-  search_in :size, index: :_unit_keywords
-end

data/spec/mongoid_search_spec.rb

@@ -1,371 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe Mongoid::Search do
-  before(:all) do
-    @default_proc = Mongoid::Search.stem_proc
-    @default_strip_symbols = Mongoid::Search.strip_symbols
-    @default_strip_accents = Mongoid::Search.strip_accents
-  end
-
-  after(:all) do
-    Mongoid::Search.stem_proc = @default_proc
-  end
-
-  before(:each) do
-    Mongoid::Search.match         = :any
-    Mongoid::Search.stem_keywords = false
-    Mongoid::Search.ignore_list   = nil
-    Mongoid::Search.stem_proc     = @default_proc
-    @product = Product.create brand: 'Apple',
-                              name: 'iPhone',
-                              unit: 'mobile olé awesome',
-                              tags: (@tags = %w[Amazing Awesome Olé].map { |tag| Tag.new(name: tag) }),
-                              category: Category.new(name: 'Mobile', description: 'Reviews'),
-                              subproducts: [Subproduct.new(brand: 'Apple', name: 'Craddle')],
-                              info: { summary: 'Info-summary',
-                                      description: 'Info-description' }
-  end
-
-  describe 'Serialized hash fields' do
-    context 'when the hash is populated' do
-      it 'should return the product' do
-        expect(Product.full_text_search('Info-summary').first).to eq @product
-        expect(Product.full_text_search('Info-description').first).to eq @product
-      end
-    end
-
-    context 'when the hash is empty' do
-      before(:each) do
-        @product.info = nil
-        @product.save
-      end
-
-      it 'should not return the product' do
-        expect(Product.full_text_search('Info-description').size).to eq 0
-        expect(Product.full_text_search('Info-summary').size).to eq 0
-      end
-    end
-  end
-
-  context 'utf-8 characters' do
-    before do
-      Mongoid::Search.stem_keywords = false
-      Mongoid::Search.ignore_list   = nil
-      @product = Product.create brand: 'Эльбрус',
-                                name: 'Процессор',
-                                unit: 'kílográm Olé',
-                                tags: %w[Amazing Awesome Olé].map { |tag| Tag.new(name: tag) },
-                                category: Category.new(name: 'процессоры'),
-                                subproducts: []
-    end
-
-    it 'should leave utf8 characters' do
-      expect(@product._keywords).to eq %w[amazing awesome ole процессор процессоры эльбрус]
-      expect(@product._unit_keywords).to eq %w[kilogram ole]
-    end
-
-    it "should return results in search when case doesn't match" do
-      expect(Product.full_text_search('ЭЛЬБРУС').size).to eq 1
-      expect(Product.full_text_search('KILOGRAM', index: :_unit_keywords).size).to eq 1
-    end
-  end
-
-  context 'when references are nil' do
-    context 'when instance is being created' do
-      it 'should not complain about method missing' do
-        expect { Product.create! }.not_to raise_error
-      end
-    end
-
-    it 'should validate keywords' do
-      product = Product.create brand: 'Apple', name: 'iPhone', unit: 'box'
-      expect(product._keywords).to eq(%w[apple iphone])
-      expect(product._unit_keywords).to eq(%w[box])
-    end
-  end
-
-  it 'should set the _keywords field for array fields also' do
-    @product.attrs = ['lightweight', 'plastic', :red]
-    @product.measures = ['box', 'bunch', :bag]
-    @product.save!
-    expect(@product._keywords).to include 'lightweight', 'plastic', 'red'
-    expect(@product._unit_keywords).to include 'box', 'bunch', 'bag'
-  end
-
-  it 'should inherit _keywords field and build upon' do
-    variant = Variant.create brand: 'Apple',
-                             name: 'iPhone',
-                             tags: %w[Amazing Awesome Olé].map { |tag| Tag.new(name: tag) },
-                             category: Category.new(name: 'Mobile'),
-                             subproducts: [Subproduct.new(brand: 'Apple', name: 'Craddle')],
-                             color: :white,
-                             size: :big
-    expect(variant._keywords).to include 'white'
-    expect(variant._unit_keywords).to include 'big'
-    expect(Variant.full_text_search(name: 'Apple', color: :white)).to eq [variant]
-    expect(Variant.full_text_search({ size: 'big' }, index: :_unit_keywords)).to eq [variant]
-  end
-
-  it 'should expand the ligature to ease searching' do
-    # ref: http://en.wikipedia.org/wiki/Typographic_ligature, only for french right now. Rules for other languages are not know
-    variant1 = Variant.create tags: ['œuvre'].map { |tag| Tag.new(name: tag) }
-    variant2 = Variant.create tags: ['æquo'].map { |tag| Tag.new(name: tag) }
-    variant3 = Variant.create measures: ['ꜵquo'].map { |measure| measure }
-
-    expect(Variant.full_text_search('œuvre')).to eq [variant1]
-    expect(Variant.full_text_search('oeuvre')).to eq [variant1]
-    expect(Variant.full_text_search('æquo')).to eq [variant2]
-    expect(Variant.full_text_search('aequo')).to eq [variant2]
-    expect(Variant.full_text_search('aoquo', index: :_unit_keywords)).to eq [variant3]
-    expect(Variant.full_text_search('ꜵquo', index: :_unit_keywords)).to eq [variant3]
-  end
-
-  it 'should set the keywords fields with stemmed words if stem is enabled' do
-    Mongoid::Search.stem_keywords = true
-    @product.save!
-    expect(@product._keywords.sort).to eq %w[amaz appl awesom craddl iphon mobil review ol info descript summari].sort
-    expect(@product._unit_keywords.sort).to eq %w[mobil awesom ol].sort
-  end
-
-  it 'should set the keywords fields with custom stemmed words if stem is enabled with a custom lambda' do
-    Mongoid::Search.stem_keywords = true
-    Mongoid::Search.stem_proc     = proc { |word| word.upcase }
-    @product.save!
-    expect(@product._keywords.sort).to eq %w[AMAZING APPLE AWESOME CRADDLE DESCRIPTION INFO IPHONE MOBILE OLE REVIEWS SUMMARY]
-    expect(@product._unit_keywords.sort).to eq %w[AWESOME MOBILE OLE]
-  end
-
-  it 'should ignore keywords in an ignore list' do
-    Mongoid::Search.ignore_list = YAML.safe_load(File.open(File.dirname(__FILE__) + '/config/ignorelist.yml'))['ignorelist']
-    @product.save!
-    expect(@product._keywords.sort).to eq %w[apple craddle iphone mobile reviews ole info description summary].sort
-    expect(@product._unit_keywords.sort).to eq %w[mobile ole].sort
-  end
-
-  it 'should incorporate numbers as keywords' do
-    @product = Product.create brand: 'Ford',
-                              name: 'T 1908',
-                              tags: %w[Amazing First Car].map { |tag| Tag.new(name: tag) },
-                              category: Category.new(name: 'Vehicle')
-
-    @product.save!
-    expect(@product._keywords).to eq %w[1908 amazing car first ford vehicle]
-  end
-
-  it 'should return results in search' do
-    expect(Product.full_text_search('apple').size).to eq 1
-  end
-
-  it 'should return results in search for dynamic attribute' do
-    @product[:outlet] = 'online shop'
-    @product.save!
-    expect(Product.full_text_search('online').size).to eq 1
-  end
-
-  it 'should return results in search even searching a accented word' do
-    expect(Product.full_text_search('Ole').size).to eq 1
-    expect(Product.full_text_search('Olé').size).to eq 1
-  end
-
-  it "should return results in search even if the case doesn't match" do
-    expect(Product.full_text_search('oLe').size).to eq 1
-  end
-
-  it 'should return results in search with a partial word by default' do
-    expect(Product.full_text_search('iph').size).to eq 1
-  end
-
-  it 'should return results for any matching word with default search' do
-    expect(Product.full_text_search('apple motorola').size).to eq 1
-  end
-
-  it 'should not return results when all words do not match, if using :match => :all' do
-    Mongoid::Search.match = :all
-    expect(Product.full_text_search('apple motorola').size).to eq 0
-  end
-
-  it 'should return results for any matching word, using :match => :all, passing :match => :any to .full_text_search' do
-    Mongoid::Search.match = :all
-    expect(Product.full_text_search('apple motorola', match: :any).size).to eq 1
-  end
-
-  it 'should not return results when all words do not match, passing :match => :all to .full_text_search' do
-    expect(Product.full_text_search('apple motorola', match: :all).size).to eq 0
-  end
-
-  it 'should return no results when a blank search is made' do
-    Mongoid::Search.allow_empty_search = false
-    expect(Product.full_text_search('').size).to eq 0
-  end
-
-  it 'should return results when a blank search is made when :allow_empty_search is true' do
-    Mongoid::Search.allow_empty_search = true
-    expect(Product.full_text_search('').size).to eq 1
-  end
-
-  it 'should search for embedded documents' do
-    expect(Product.full_text_search('craddle').size).to eq 1
-  end
-
-  it 'should search for reference documents' do
-    expect(Product.full_text_search('reviews').size).to eq 1
-  end
-
-  it 'should work in a chainable fashion' do
-    expect(@product.category.products.where(brand: 'Apple').full_text_search('apple').size).to eq 1
-    expect(@product.category.products.full_text_search('craddle').where(brand: 'Apple').size).to eq 1
-  end
-
-  it 'should return the classes that include the search module' do
-    expect(Mongoid::Search.classes.sort_by(&:name)).to eq [Product, Tag]
-  end
-
-  it 'should have a method to index keywords' do
-    expect(@product.index_keywords!).to include(true)
-  end
-
-  it 'should have a class method to index all documents keywords' do
-    expect(Product.index_keywords!).not_to include(false)
-  end
-
-  context 'when regex search is false' do
-    before do
-      Mongoid::Search.regex_search = false
-    end
-
-    it 'should not return results in search with a partial word if not using regex search' do
-      expect(Product.full_text_search('iph').size).to eq 0
-    end
-
-    it 'should return results in search with a full word if not using regex search' do
-      expect(Product.full_text_search('iphone').size).to eq 1
-    end
-  end
-
-  context 'when regex search is true' do
-    before do
-      Mongoid::Search.regex_search = true
-    end
-
-    after do
-      Mongoid::Search.regex_search = false
-    end
-
-    it 'should not return results in search with a partial word if using regex search' do
-      expect(Product.full_text_search('iph').size).to eq 1
-    end
-
-    it 'should return results in search with a full word if using regex search' do
-      expect(Product.full_text_search('iphone').size).to eq 1
-    end
-
-    context 'when query include special characters that should not be stripped' do
-      before do
-        Mongoid::Search.strip_symbols = /[\n]/
-        Mongoid::Search.strip_accents = /[^\s\p{Graph}]/
-      end
-
-      after do
-        Mongoid::Search.strip_symbols = @default_strip_symbols
-        Mongoid::Search.strip_accents = @default_strip_accents
-      end
-
-      it 'should escape regex special characters' do
-        expect(Product.full_text_search('iphone (steve').size).to eq 1
-      end
-    end
-
-    context 'Match partial words on the beginning' do
-      before do
-        Mongoid::Search.regex = proc { |query| /^#{query}/ }
-      end
-
-      it 'should return results in search which starts with query string' do
-        expect(Product.full_text_search('iphone').size).to eq 1
-      end
-
-      it 'should not return results in search which does not start with query string' do
-        expect(Product.full_text_search('phone').size).to eq 0
-      end
-    end
-
-    context 'Match partial words on the end' do
-      before do
-        Mongoid::Search.regex = proc { |query| /#{query}$/ }
-      end
-
-      it 'should return results in search which ends with query string' do
-        expect(Product.full_text_search('phone').size).to eq 1
-      end
-
-      it 'should not return results in search which does not end with query string' do
-        expect(Product.full_text_search('phon').size).to eq 0
-      end
-    end
-  end
-
-  context 'relevant search' do
-    before do
-      Mongoid::Search.relevant_search = true
-      @imac = Product.create name: 'apple imac'
-    end
-
-    it 'should return results ordered by relevance and with correct ids' do
-      expect(Product.full_text_search('apple imac').map(&:_id)).to eq [@imac._id, @product._id]
-    end
-
-    it 'results should be recognized as persisted objects' do
-      expect(Product.full_text_search('apple imac').map(&:persisted?)).not_to include false
-    end
-
-    it 'should include relevance information' do
-      expect(Product.full_text_search('apple imac').map(&:relevance)).to eq [2, 1]
-    end
-  end
-
-  context 'when using methods for keywords' do
-    it 'should set the _keywords from methods' do
-      expect(@tags.first._keywords).to include 'amazing'
-    end
-  end
-
-  context 'when using deeply nested fields for keywords' do
-    context 'when explicitly calling set_keywords' do
-      it 'should set the _keywords from parent' do
-        @tags.first.send(:set_keywords)
-        expect(@tags.first._keywords).to eq %w[amazing description info iphone mobile reviews summary]
-      end
-    end
-  end
-
-  context 'when using localized fields' do
-    it 'should set the keywords from all localizations' do
-      @product = Product.create brand: 'Ford',
-                                name: 'T 1908',
-                                tags: %w[Amazing First Car].map { |tag| Tag.new(name: tag) },
-                                category: Category.new(name_translations: { en: 'Vehicle', de: 'Fahrzeug' })
-      expect(@product._keywords).to include('fahrzeug')
-    end
-  end
-
-  context 'minimum word size' do
-    before(:each) do
-      Mongoid::Search.minimum_word_size = 3
-    end
-
-    after(:each) do
-      Mongoid::Search.minimum_word_size = 2
-    end
-
-    it 'should ignore keywords with length less than minimum word size' do
-      @product = Product.create name: 'a'
-      expect(@product._keywords.size).to eq 0
-
-      @product = Product.create name: 'ap'
-      expect(@product._keywords.size).to eq 0
-
-      @product = Product.create name: 'app'
-      expect(@product._keywords.size).to eq 1
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,35 +0,0 @@
-require 'simplecov'
-SimpleCov.start
-
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'mongoid'
-require 'database_cleaner'
-require 'fast_stemmer'
-require 'yaml'
-require 'mongoid_search'
-require 'mongoid-compatibility'
-
-Mongoid.configure do |config|
-  config.connect_to 'mongoid_search_test'
-end
-
-Dir["#{File.dirname(__FILE__)}/models/*.rb"].each { |file| require file }
-
-DatabaseCleaner.orm = :mongoid
-
-RSpec.configure do |config|
-  config.before(:all) do
-    Mongoid.logger.level = Logger::INFO
-    Mongo::Logger.logger.level = Logger::INFO if Mongoid::Compatibility::Version.mongoid5_or_newer?
-    DatabaseCleaner.strategy = :truncation
-  end
-
-  config.before(:each) do
-    DatabaseCleaner.start
-  end
-
-  config.after(:each) do
-    DatabaseCleaner.clean
-  end
-end

data/spec/util_spec.rb

@@ -1,72 +0,0 @@
-
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe Mongoid::Search::Util do
-  before(:all) do
-    @default_proc = Mongoid::Search.stem_proc
-  end
-
-  after(:all) do
-    Mongoid::Search.stem_proc = @default_proc
-  end
-
-  before do
-    Mongoid::Search.stem_keywords = false
-    Mongoid::Search.ignore_list = ''
-    Mongoid::Search.stem_proc = @default_proc
-  end
-
-  it 'should return an empty array if no text is passed' do
-    expect(Mongoid::Search::Util.normalize_keywords('')).to eq []
-  end
-
-  it 'should return an array of keywords' do
-    expect(Mongoid::Search::Util.normalize_keywords('keyword').class).to eq Array
-  end
-
-  it 'should return an array of strings' do
-    expect(Mongoid::Search::Util.normalize_keywords('keyword').first.class).to eq String
-  end
-
-  it 'should remove accents from the text passed' do
-    expect(Mongoid::Search::Util.normalize_keywords('café')).to eq ['cafe']
-  end
-
-  it 'should downcase the text passed' do
-    expect(Mongoid::Search::Util.normalize_keywords('CaFé')).to eq ['cafe']
-  end
-
-  it 'should downcase utf-8 chars of the text passed' do
-    expect(Mongoid::Search::Util.normalize_keywords('Кафе')).to eq ['кафе']
-  end
-
-  it 'should split whitespaces, hifens, dots, underlines, etc..' do
-    expect(Mongoid::Search::Util.normalize_keywords("CaFé-express.com delicious;come visit, and 'win' an \"iPad\"")).to eq %w[cafe express com delicious come visit and win an ipad]
-  end
-
-  it 'should stem keywords' do
-    Mongoid::Search.stem_keywords = true
-    expect(Mongoid::Search::Util.normalize_keywords('A runner running and eating')).to eq %w[runner run and eat]
-  end
-
-  it 'should stem keywords using a custom proc' do
-    Mongoid::Search.stem_keywords = true
-    Mongoid::Search.stem_proc = ->(word) { word.upcase }
-
-    expect(Mongoid::Search::Util.normalize_keywords('A runner running and eating')).to eq %w[RUNNER RUNNING AND EATING]
-  end
-
-  it 'should ignore keywords from ignore list' do
-    Mongoid::Search.stem_keywords = true
-    Mongoid::Search.ignore_list = YAML.safe_load(File.open(File.dirname(__FILE__) + '/config/ignorelist.yml'))['ignorelist']
-    expect(Mongoid::Search::Util.normalize_keywords('An amazing awesome runner running and eating')).to eq %w[an runner run and eat]
-  end
-
-  it 'should ignore keywords with less than two words' do
-    expect(Mongoid::Search::Util.normalize_keywords('A runner running')).not_to include 'a'
-  end
-
-  it 'should not ignore numbers' do
-    expect(Mongoid::Search::Util.normalize_keywords('Ford T 1908')).to include '1908'
-  end
-end