mongoid_search 0.3.4 → 0.3.5

data/lib/mongoid_search/tasks/mongoid_search.rake

@@ -1,6 +1,6 @@
 namespace :mongoid_search do
   desc 'Goes through all documents with search enabled and indexes the keywords.'
-  task :index => :environment do
+  task index: :environment do
     ::Rails.application.eager_load!
     if Mongoid::Search.classes.blank?
       Mongoid::Search::Log.log "No model to index keywords.\n"

data/lib/mongoid_search/util.rb

@@ -1,28 +1,28 @@
-# encoding: utf-8
+
 module Mongoid::Search::Util
   def self.keywords(klass, fields)
     if fields.is_a?(Array)
       fields.map do |field|
-        self.keywords(klass, field)
+        keywords(klass, field)
       end
     elsif fields.is_a?(Hash)
       fields.keys.map do |field|
         attribute = klass.send(field)
         unless attribute.blank?
           if attribute.is_a?(Array)
-            attribute.map{ |a| self.keywords(a, fields[field]) }
+            attribute.map { |a| keywords(a, fields[field]) }
           else
-            self.keywords(attribute, fields[field])
+            keywords(attribute, fields[field])
           end
         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.to_s + '_translations')
+                klass.send(fields.to_s + '_translations').values
               elsif klass.respond_to?(fields)
                 klass.send(fields)
               else
-                value = klass[fields];
+                value = klass[fields]
               end
       value = value.join(' ') if value.respond_to?(:join)
       normalize_keywords(value) if value
@@ -38,19 +38,18 @@ module Mongoid::Search::Util
     strip_accents = Mongoid::Search.strip_accents
 
     return [] if text.blank?
-    text = text.to_s.
-      mb_chars.
-      normalize(:kd).
-      downcase.
-      to_s.
-      gsub(strip_symbols, ' '). # strip symbols
-      gsub(strip_accents, '').  # strip accents
-      gsub(/[#{ligatures.keys.join("")}]/) {|c| ligatures[c]}.
-      split(' ').
-      reject { |word| word.size < Mongoid::Search.minimum_word_size }
+    text = text.to_s
+               .mb_chars
+               .normalize(:kd)
+               .downcase
+               .to_s
+               .gsub(strip_symbols, ' ') # strip symbols
+               .gsub(strip_accents, '')  # strip accents
+               .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
     text
   end
-
 end

data/spec/models/product.rb

@@ -5,13 +5,17 @@ class Product
 
   field :brand
   field :name
-  field :attrs, :type => Array
-  field :info, :type => Hash
+  field :attrs, type: Array
+  field :info, type: Hash
 
-  has_many    :tags
-  belongs_to  :category
+  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 => [:name, :description],
-            :subproducts => [:brand, :name], :info => [ :summary, :description ]
+  search_in :brand, :name, :outlet, :attrs, tags: :name, category: %i[name description],
+                                            subproducts: %i[brand name], info: %i[summary description]
 end

data/spec/models/subproduct.rb

@@ -5,5 +5,5 @@ class Subproduct
   field :brand
   field :name
 
-  embedded_in :product, :inverse_of => :subproducts
+  embedded_in :product, inverse_of: :subproducts
 end

data/spec/models/tag.rb

@@ -8,8 +8,8 @@ class Tag
   belongs_to :product
 
   def title
-      self.name
+    name
   end
 
-  search_in :title, :product => [:name, { :info => [ :summary, :description ], :category => [:name, :description]}]
+  search_in :title, product: [:name, { info: %i[summary description], category: %i[name description] }]
 end

data/spec/models/variant.rb

@@ -1,4 +1,4 @@
-autoload :Product, "models/product.rb"
+autoload :Product, 'models/product.rb'
 class Variant < Product
   field :color
   search_in :color

data/spec/mongoid_search_spec.rb

@@ -1,11 +1,10 @@
-# encoding: utf-8
-
 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
@@ -17,193 +16,192 @@ describe Mongoid::Search do
     Mongoid::Search.stem_keywords = false
     Mongoid::Search.ignore_list   = nil
     Mongoid::Search.stem_proc     = @default_proc
-    @product = Product.create :brand => "Apple",
-      :name => "iPhone",
-      :tags => (@tags = ["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
+    @product = Product.create brand: 'Apple',
+                              name: 'iPhone',
+                              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
+    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
+      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
+  context 'utf-8 characters' do
     before do
       Mongoid::Search.stem_keywords = false
       Mongoid::Search.ignore_list   = nil
-      @product = Product.create :brand => "Эльбрус",
-        :name => "Процессор",
-        :tags => ["Amazing", "Awesome", "Olé"].map { |tag| Tag.new(:name => tag) },
-        :category => Category.new(:name => "процессоры"),
-        :subproducts => []
+      @product = Product.create brand: 'Эльбрус',
+                                name: 'Процессор',
+                                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 ["amazing", "awesome", "ole", "процессор", "процессоры", "эльбрус"]
+    it 'should leave utf8 characters' do
+      expect(@product._keywords).to eq %w[amazing awesome 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('ЭЛЬБРУС').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
+  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" 
-      expect(product._keywords).to eq(["apple", "iphone"])
+      product = Product.create brand: 'Apple', name: 'iPhone'
+      expect(product._keywords).to eq(%w[apple iphone])
     end
   end
 
-
-  it "should set the _keywords field for array fields also" do
+  it 'should set the _keywords field for array fields also' do
     @product.attrs = ['lightweight', 'plastic', :red]
     @product.save!
     expect(@product._keywords).to include 'lightweight', 'plastic', 'red'
   end
 
-  it "should inherit _keywords field and build upon" do
-    variant = Variant.create :brand => "Apple",
-      :name => "iPhone",
-      :tags => ["Amazing", "Awesome", "Olé"].map { |tag| Tag.new(:name => tag) },
-      :category => Category.new(:name => "Mobile"),
-      :subproducts => [Subproduct.new(:brand => "Apple", :name => "Craddle")],
-      :color => :white
+  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
     expect(variant._keywords).to include 'white'
-    expect(Variant.full_text_search(:name => 'Apple', :color => :white)).to eq [variant]
+    expect(Variant.full_text_search(name: 'Apple', color: :white)).to eq [variant]
   end
 
-  it "should expand the ligature to ease searching" do
+  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)}
+    variant1 = Variant.create tags: ['œuvre'].map { |tag| Tag.new(name: tag) }
+    variant2 = Variant.create tags: ['æquo'].map { |tag| Tag.new(name: tag) }
 
-    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('œ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]
   end
 
-  it "should set the _keywords field with stemmed words if stem is enabled" do
+  it 'should set the _keywords field with stemmed words if stem is enabled' do
     Mongoid::Search.stem_keywords = true
     @product.save!
-    expect(@product._keywords.sort).to eq ["amaz", "appl", "awesom", "craddl", "iphon", "mobil", "review", "ol", "info", "descript", "summari"].sort
+    expect(@product._keywords.sort).to eq %w[amaz appl awesom craddl iphon mobil review ol info descript summari].sort
   end
 
-  it "should set the _keywords field with custom stemmed words if stem is enabled with a custom lambda" do
+  it 'should set the _keywords field with custom stemmed words if stem is enabled with a custom lambda' do
     Mongoid::Search.stem_keywords = true
-    Mongoid::Search.stem_proc     = Proc.new { |word| word.upcase }
+    Mongoid::Search.stem_proc     = proc { |word| word.upcase }
     @product.save!
-    expect(@product._keywords.sort).to eq ["AMAZING", "APPLE", "AWESOME", "CRADDLE", "DESCRIPTION", "INFO", "IPHONE", "MOBILE", "OLE", "REVIEWS", "SUMMARY"]
+    expect(@product._keywords.sort).to eq %w[AMAZING APPLE AWESOME CRADDLE DESCRIPTION INFO IPHONE MOBILE OLE REVIEWS SUMMARY]
   end
 
-  it "should ignore keywords in an ignore list" do
-    Mongoid::Search.ignore_list = YAML.load(File.open(File.dirname(__FILE__) + '/config/ignorelist.yml'))["ignorelist"]
+  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 ["apple", "craddle", "iphone", "mobile", "reviews", "ole", "info", "description", "summary"].sort
+    expect(@product._keywords.sort).to eq %w[apple craddle iphone mobile reviews ole info description summary].sort
   end
 
-  it "should incorporate numbers as keywords" do
-    @product = Product.create :brand => "Ford",
-      :name => "T 1908",
-      :tags => ["Amazing", "First", "Car"].map { |tag| Tag.new(:name => tag) },
-      :category => Category.new(:name => "Vehicle")
+  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 ["1908", "amazing", "car", "first", "ford",  "vehicle"]
+    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
+  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"
+  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
+    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
+  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
+    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
+  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
+  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
+  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
+    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
+  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
+    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
+  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
+  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
+    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
+  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
+    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
+  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
+  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
+    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).to eq [Product, Tag]
+    expect(Mongoid::Search.classes.sort_by(&:name)).to eq [Product, Tag]
   end
 
   it 'should have a method to index keywords' do
@@ -214,22 +212,21 @@ describe Mongoid::Search do
     expect(Product.index_keywords!).not_to include(false)
   end
 
-  context "when regex search is false" do
+  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
+    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
+    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
-   
+  context 'when regex search is true' do
     before do
       Mongoid::Search.regex_search = true
     end
@@ -238,90 +235,104 @@ describe Mongoid::Search 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
+    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
+    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.new { |query| /^#{query}/ }
+        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
+      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
+      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.new { |query| /#{query}$/ }
+        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
+
+      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
+      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
+  context 'relevant search' do
     before do
       Mongoid::Search.relevant_search = true
-      @imac = Product.create :name => 'apple imac'
+      @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]
+    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
+    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]
+    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"
+  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
+  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 ["amazing", "description", "info", "iphone", "mobile", "reviews", "summary"]
+        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 => ["Amazing", "First", "Car"].map { |tag| Tag.new(:name => tag) },
-        :category => Category.new(:name_translations => { :en => "Vehicle", :de => "Fahrzeug" })
-      expect(@product._keywords).to include("fahrzeug")
+  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
+  context 'minimum word size' do
     before(:each) do
       Mongoid::Search.minimum_word_size = 3
     end
@@ -330,14 +341,14 @@ describe Mongoid::Search 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'
+    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'
+      @product = Product.create name: 'ap'
       expect(@product._keywords.size).to eq 0
 
-      @product = Product.create :name => 'app'
+      @product = Product.create name: 'app'
       expect(@product._keywords.size).to eq 1
     end
   end