mongoid_search 0.3.4 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 832d506c4a4b192adabbc3858899481804da533e
-  data.tar.gz: ee2c35e2dc25e5de7cc7bb02c149260ff487ff04
+  metadata.gz: 790663a1de866f407ace368cc503cd724cf4ffc6
+  data.tar.gz: f95fc5e91b0eb1b12eb95a60bd9c57688ae12bb7
 SHA512:
-  metadata.gz: 7f40a5e5437f1865b71bd929ff3c861c33f35197e5c561bfaff6d0ffd31671983c1c0c5699ccbe0f9fb9af7c3af253ff9b704f6b93c186be8c13168ea6dc03b4
-  data.tar.gz: 63e5ee87ed079f03373951efc4cc6eb6accf13cf48ab4e8f53b76bcd689fb04bb097fbe2a2e66db6eccd71438db0876b4abd1f8e61608d23ff37aabc92a3eb8c
+  metadata.gz: ec1fd1b237c921939f66ca1b7a719f13a1275a19f42e86ef72f368ae7396b21c5fa6ab97e090a070ae656b45bccdaf6607e369a82754e9bfec828f2bca3a1c43
+  data.tar.gz: 3af9e42610b204de4a78e802bd3efaff38cabfa8a53a1f82b7af191cb9fe31e823e203f3087b606efe2d6fea38b0deb92b3751d2ab49674b410df06b1b40fb31

data/README.md

@@ -1,177 +1,190 @@
-Mongoid Search
-============
+# Mongoid Search
 
-Mongoid Search is a simple full text search implementation for Mongoid ORM. It performs well for small data sets. If your searchable model is big (i.e. 1.000.000+ records), solr or sphinx may suit you better.
+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.
 
-Installation
---------
+[![Build Status](https://travis-ci.org/mongoid/mongoid_search.svg?branch=master)](https://travis-ci.org/mongoid/mongoid_search)
 
-In your Gemfile:
-
-    gem 'mongoid_search'
+## Installation
 
-If your project is still using mongoid 2.x.x, stick to mongoid_search 0.2.x:
+In your Gemfile:
 
-    gem 'mongoid_search', '~> 0.2.8'
+```ruby
+gem 'mongoid_search'
+```
 
 Then:
 
-    bundle install
+```
+bundle install
+```
 
-Examples
---------
+## Examples
 
-    class Product
-      include Mongoid::Document
-      include Mongoid::Search
-      field :brand
-      field :name
-      field :info, :type => Hash
+```ruby
+class Product
+  include Mongoid::Document
+  include Mongoid::Search
+  field :brand
+  field :name
+  field :info, type: Hash
 
-      has_many   :tags
-      belongs_to :category
+  has_many   :tags
+  belongs_to :category
 
-      search_in :brand, :name, :tags => :name, :category => :name, :info => [:summary, :description]
-    end
+  search_in :brand, :name, tags: :name, category: :name, info: %i[summary description]
+end
 
-    class Tag
-      include Mongoid::Document
-      field :name
+class Tag
+  include Mongoid::Document
+  field :name
 
-      belongs_to :product
-    end
+  belongs_to :product
+end
 
-    class Category
-      include Mongoid::Document
-      field :name
+class Category
+  include Mongoid::Document
+  field :name
 
-      has_many :products
-    end
+  has_many :products
+end
+```
 
-Now when you save a product, you get a _keywords field automatically:
+Now when you save a product, you get a `_keywords` field automatically:
 
-    p = Product.new :brand => "Apple", :name => "iPhone", :info => {:summary => "Info-summary", :description => "Info-description"}
-    p.tags << Tag.new(:name => "Amazing")
-    p.tags << Tag.new(:name => "Awesome")
-    p.tags << Tag.new(:name => "Superb")
-    p.save
-    => true
-    p._keywords
-    => ["amazing", "apple", "awesome", "iphone", "superb", "Info-summary", "Info-description"]
+```ruby
+p = Product.new brand: 'Apple', name: 'iPhone', info: { summary: 'Info-summary', description: 'Info-description' }
+p.tags << Tag.new(name: 'Amazing')
+p.tags << Tag.new(name: 'Awesome')
+p.tags << Tag.new(name: 'Superb')
+p.save
+# => true
+p._keywords
+# => ["amazing", "apple", "awesome", "iphone", "superb", "Info-summary", "Info-description"]
+```
 
-Now you can run search, which will look in the _keywords field and return all matching results:
+Now you can run search, which will look in the `_keywords` field and return all matching results:
 
-    Product.full_text_search("apple iphone").size
-    => 1
+```ruby
+Product.full_text_search("apple iphone").size
+# => 1
+```
 
 Note that the search is case insensitive, and accept partial searching too:
 
-    Product.full_text_search("ipho").size
-    => 1
+```ruby
+Product.full_text_search('ipho').size
+# => 1
+```
 
-Assuming you have a category with multiple products you can use the following
-code to search for 'iphone' in products cheaper than $499
+Assuming you have a category with multiple products you can use the following code to search for 'iphone' in products cheaper than $499.
 
-    @category.products.where(:price.lt => 499).full_text_search('iphone').asc(:price)
+```ruby
+category.products.where(:price.lt => 499).full_text_search('iphone').asc(:price)
+```
 
 To index or reindex all existing records, run this rake task
 
-    $ rake mongoid_search:index
-
-Options
--------
-
-match:
-
-  _:any_ - match any occurrence
+```
+$ rake mongoid_search:index
+```
 
-  _:all_ - match all ocurrences
+## Options
 
-  Default is _:any_.
+### match
 
-    Product.full_text_search("apple motorola", match: :any).size
-    => 1
+* `:any` - match any occurrence
+* `:all` - match all occurrences
 
-    Product.full_text_search("apple motorola", match: :all).size
-    => 0
+Default is `:any`.
 
-allow\_empty\_search:
+```ruby
+Product.full_text_search('apple motorola', match: :any).size
+# => 1
 
-  _true_ - will return Model.all
+Product.full_text_search('apple motorola', match: :all).size
+# => 0
+```
 
-  _false_ - will return []
+### allow\_empty\_search
 
-  Default is _false_.
+* `true` - will return `Model.all`
+* `false` - will return `[]`
 
-    Product.full_text_search("", allow_empty_search: true).size
-    => 1
+Default is `false`.
 
-relevant_search:
+```ruby
+Product.full_text_search('', allow_empty_search: true).size
+# => 1
+```
 
-  _true_ - Adds relevance information to the results
+### relevant_search
 
-  _false_ - No relevance information
+* `true` - adds relevance information to the results
+* `false` - no relevance information
 
-  Default is _false_.
+Default is `false`.
 
-    Product.full_text_search('amazing apple', relevant_search: true)
-    => [#<Product _id: 5016e7d16af54efe1c000001, _type: nil, brand: "Apple", name: "iPhone", attrs: nil, info: nil, category_id: nil, _keywords: ["amazing", "apple", "awesome", "iphone", "superb"], relevance: 2.0>]
+```ruby
+Product.full_text_search('amazing apple', relevant_search: true)
+# => [#<Product _id: 5016e7d16af54efe1c000001, _type: nil, brand: "Apple", name: "iPhone", attrs: nil, info: nil, category_id: nil, _keywords: ["amazing", "apple", "awesome", "iphone", "superb"], relevance: 2.0>]
+```
 
- Please note that relevant_search will return an Array and not a Criteria object. The search method should always be called in the end of the method chain.
+Please note that relevant_search will return an Array and not a Criteria object. The search method should always be called in the end of the method chain.
 
-Initializer
------------
+## Initializer
 
 Alternatively, you can create an initializer to setup those options:
 
-    Mongoid::Search.setup do |config|
-      ## Default matching type. Match :any or :all searched keywords
-      config.match = :any
+```ruby
+Mongoid::Search.setup do |config|
+  ## Default matching type. Match :any or :all searched keywords
+  config.match = :any
 
-      ## If true, an empty search will return all objects
-      config.allow_empty_search = false
+  ## If true, an empty search will return all objects
+  config.allow_empty_search = false
 
-      ## If true, will search with relevance information
-      config.relevant_search = false
+  ## If true, will search with relevance information
+  config.relevant_search = false
 
-      ## Stem keywords
-      config.stem_keywords = false
+  ## Stem keywords
+  config.stem_keywords = false
 
-      ## Add a custom proc returning strings to replace the default stemmer
-      # For example using ruby-stemmer:
-      # config.stem_proc = Proc.new { |word| Lingua.stemmer(word, :language => 'nl') }
+  ## Add a custom proc returning strings to replace the default stemmer
+  # For example using ruby-stemmer:
+  # config.stem_proc = Proc.new { |word| Lingua.stemmer(word, :language => 'nl') }
 
-      ## Words to ignore
-      config.ignore_list = []
+  ## Words to ignore
+  config.ignore_list = []
 
-      ## An array of words
-      # config.ignore_list = %w{ a an to from as }
+  ## An array of words
+  # config.ignore_list = %w{ a an to from as }
 
-      ## Or from a file
-      # config.ignore_list = YAML.load(File.open(File.dirname(__FILE__) + '/config/ignorelist.yml'))["ignorelist"]
+  ## Or from a file
+  # config.ignore_list = YAML.load(File.open(File.dirname(__FILE__) + '/config/ignorelist.yml'))["ignorelist"]
 
-      ## Search using regex (slower)
-      config.regex_search = true
+  ## Search using regex (slower)
+  config.regex_search = true
 
-      ## Regex to search
+  ## Regex to search
 
-      ## Match partial words on both sides (slower)
-      config.regex = Proc.new { |query| /#{query}/ }
+  ## Match partial words on both sides (slower)
+  config.regex = Proc.new { |query| /#{query}/ }
 
-      ## Match partial words on the beginning or in the end (slightly faster)
-      # config.regex = Proc.new { |query| /^#{query}/ }
-      # config.regex = Proc.new { |query| /#{query}$/ }
+  ## Match partial words on the beginning or in the end (slightly faster)
+  # config.regex = Proc.new { |query| /^#{query}/ }
+  # config.regex = Proc.new { |query| /#{query}$/ }
 
-      # Ligatures to be replaced
-      # http://en.wikipedia.org/wiki/Typographic_ligature
-      config.ligatures = { "œ"=>"oe", "æ"=>"ae" }
+  # Ligatures to be replaced
+  # http://en.wikipedia.org/wiki/Typographic_ligature
+  config.ligatures = { "œ"=>"oe", "æ"=>"ae" }
 
-      # Strip symbols regex to be replaced. These symbols will be replaced by space
-      config.strip_symbols = /[._:;'\"`,?|+={}()!@#%^&*<>~\$\-\\\/\[\]]/
+  # Strip symbols regex to be replaced. These symbols will be replaced by space
+  config.strip_symbols = /[._:;'\"`,?|+={}()!@#%^&*<>~\$\-\\\/\[\]]/
 
-      # Strip accents regex to be replaced. These sybols will be removed after strip_symbols replacing
-      config.strip_accents = /[^\s\p{Alnum}]/
+  # Strip accents regex to be replaced. These sybols will be removed after strip_symbols replacing
+  config.strip_accents = /[^\s\p{Alnum}]/
 
-      # Minimum word size. Words smaller than it won't be indexed
-      config.minimum_word_size = 2
-    end
+  # Minimum word size. Words smaller than it won't be indexed
+  config.minimum_word_size = 2
+end
+```

data/Rakefile

@@ -3,8 +3,11 @@ require 'rake'
 
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.rspec_opts = ["-c", "-f progress"]
+  spec.rspec_opts = ['-c', '-f progress']
   spec.pattern = 'spec/**/*_spec.rb'
 end
 
-task :default => :spec
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new(:rubocop)
+
+task default: %i[rubocop spec]

data/VERSION

@@ -1 +1 @@
-0.3.4
+0.3.5

data/lib/mongoid_search.rb

@@ -1,10 +1,6 @@
-# encoding: utf-8
-
 require 'mongoid_search/mongoid_search'
 
-if defined?(Rails)
-  require 'mongoid_search/railtie'
-end
+require 'mongoid_search/railtie' if defined?(Rails)
 
 module Mongoid::Search
   ## Default matching type. Match :any or :all searched keywords
@@ -25,7 +21,7 @@ module Mongoid::Search
 
   ## Stem procedure
   mattr_accessor :stem_proc
-  @@stem_proc = Proc.new { |word| word.stem }
+  @@stem_proc = proc { |word| word.stem }
 
   ## Words to ignore
   mattr_accessor :ignore_list
@@ -45,7 +41,7 @@ module Mongoid::Search
   mattr_accessor :regex
 
   ## Match partial words on both sides (slower)
-  @@regex = Proc.new { |query| /#{query}/ }
+  @@regex = proc { |query| /#{query}/ }
 
   ## Match partial words on the beginning or in the end (slightly faster)
   # @@regex = Proc.new { |query| /^#{query}/ }
@@ -54,7 +50,7 @@ module Mongoid::Search
   # Ligatures to be replaced
   # http://en.wikipedia.org/wiki/Typographic_ligature
   mattr_accessor :ligatures
-  @@ligatures = { "œ"=>"oe", "æ"=>"ae" }
+  @@ligatures = { 'œ' => 'oe', 'æ' => 'ae' }
 
   # Minimum word size. Words smaller than it won't be indexed
   mattr_accessor :minimum_word_size

data/lib/mongoid_search/log.rb

@@ -14,7 +14,8 @@ class Mongoid::Search::Log
   end
 
   private
+
   def self.colorize(text, code)
     "\033[#{code}m#{text}\033[0m"
   end
-end
+end

data/lib/mongoid_search/mongoid_search.rb

@@ -15,16 +15,16 @@ module Mongoid::Search
     # Set a field or a number of fields as sources for search
     def search_in(*args)
       args, _options = args_and_options(args)
-      self.search_fields = (self.search_fields || []).concat args
+      self.search_fields = (search_fields || []).concat args
 
-      field :_keywords, :type => Array
+      field :_keywords, type: Array
 
-      index({ :_keywords => 1 }, { :background => true })
+      index({ _keywords: 1 }, background: true)
 
       before_save :set_keywords
     end
 
-    def full_text_search(query, options={})
+    def full_text_search(query, options = {})
       options = extract_options(options)
       attr_accessor :relevance if options[:relevant_search].eql? true
 
@@ -44,34 +44,37 @@ module Mongoid::Search
     # Goes through all documents in the class that includes Mongoid::Search
     # and indexes the keywords.
     def index_keywords!
-      all.each { |d| d.index_keywords! ? Log.green(".") : Log.red("F") }
+      all.each { |d| d.index_keywords! ? Log.green('.') : Log.red('F') }
     end
 
     private
 
     def query(keywords, options)
       keywords_hash = keywords.map do |kw|
-        kw = Mongoid::Search.regex.call(kw) if Mongoid::Search.regex_search
-        { :_keywords => kw }
+        if Mongoid::Search.regex_search
+          escaped_kw = Regexp.escape(kw)
+          kw = Mongoid::Search.regex.call(escaped_kw)
+        end
+        { _keywords: kw }
       end
 
-      criteria.send("#{(options[:match]).to_s}_of", *keywords_hash)
+      criteria.send("#{(options[:match])}_of", *keywords_hash)
     end
 
     def args_and_options(args)
       options = args.last.is_a?(Hash) &&
-        [:match,
-         :allow_empty_search,
-         :relevant_search].include?(args.last.keys.first) ? args.pop : {}
+        %i[match
+           allow_empty_search
+           relevant_search].include?(args.last.keys.first) ? args.pop : {}
 
       [args, extract_options(options)]
     end
 
     def extract_options(options)
       {
-        :match              => options[:match]              || Mongoid::Search.match,
-        :allow_empty_search => options[:allow_empty_search] || Mongoid::Search.allow_empty_search,
-        :relevant_search    => options[:relevant_search]    || Mongoid::Search.relevant_search
+        match: options[:match] || Mongoid::Search.match,
+        allow_empty_search: options[:allow_empty_search] || Mongoid::Search.allow_empty_search,
+        relevant_search: options[:relevant_search] || Mongoid::Search.relevant_search
       }
     end
 
@@ -81,20 +84,18 @@ module Mongoid::Search
 
     def search_relevant(query, options)
       results_with_relevance(query, options).sort { |o| o['value'] }.map do |r|
-
-        new(r['_id'].merge(:relevance => r['value'])) do |o|
+        new(r['_id'].merge(relevance: r['value'])) do |o|
           # Need to match the actual object
           o.instance_variable_set('@new_record', false)
           o._id = r['_id']['_id']
         end
-
       end
     end
 
     def results_with_relevance(query, options)
       keywords = Mongoid::Search::Util.normalize_keywords(query)
 
-      map = %Q{
+      map = %{
           function() {
             var entries = 0;
             for(i in keywords) {
@@ -110,13 +111,13 @@ module Mongoid::Search
           }
       }
 
-      reduce = %Q{
+      reduce = %{
           function(key, values) {
             return(values);
           }
       }
 
-      query(keywords, options).map_reduce(map, reduce).scope(:keywords => keywords).out(:inline => 1)
+      query(keywords, options).map_reduce(map, reduce).scope(keywords: keywords).out(inline: 1)
     end
   end
 
@@ -125,7 +126,7 @@ module Mongoid::Search
   end
 
   def set_keywords
-    self._keywords = Mongoid::Search::Util.keywords(self, self.search_fields).
-      flatten.reject{|k| k.nil? || k.empty?}.uniq.sort
+    self._keywords = Mongoid::Search::Util.keywords(self, search_fields)
+                                          .flatten.reject { |k| k.nil? || k.empty? }.uniq.sort
   end
 end