search_magic 0.2.0 → 0.3.0

data/Gemfile.lock

@@ -1,34 +1,31 @@
 PATH
   remote: .
   specs:
-    search_magic (0.2.0)
+    search_magic (0.3.0)
       chronic
-      mongoid (>= 2.0.0)
+      mongoid (>= 2.4.3)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    activemodel (3.1.3)
-      activesupport (= 3.1.3)
+    activemodel (3.2.1)
+      activesupport (= 3.2.1)
       builder (~> 3.0.0)
+    activesupport (3.2.1)
       i18n (~> 0.6)
-    activesupport (3.1.3)
       multi_json (~> 1.0)
-    archive-tar-minitar (0.5.2)
-    bson (1.5.1)
-    bson_ext (1.5.1)
+    bson (1.5.2)
+    bson_ext (1.5.2)
+      bson (= 1.5.2)
     builder (3.0.0)
     chronic (0.6.6)
-    columnize (0.3.5)
     database_cleaner (0.7.0)
     diff-lcs (1.1.3)
     fabrication (1.2.0)
     i18n (0.6.0)
-    linecache19 (0.5.12)
-      ruby_core_source (>= 0.1.4)
-    mongo (1.5.1)
-      bson (= 1.5.1)
-    mongoid (2.3.4)
+    mongo (1.5.2)
+      bson (= 1.5.2)
+    mongoid (2.4.3)
       activemodel (~> 3.1)
       mongo (~> 1.3)
       tzinfo (~> 0.3.22)
@@ -41,16 +38,6 @@ GEM
     rspec-expectations (2.7.0)
       diff-lcs (~> 1.1.2)
     rspec-mocks (2.7.0)
-    ruby-debug-base19 (0.11.25)
-      columnize (>= 0.3.1)
-      linecache19 (>= 0.5.11)
-      ruby_core_source (>= 0.1.4)
-    ruby-debug19 (0.11.6)
-      columnize (>= 0.3.1)
-      linecache19 (>= 0.5.11)
-      ruby-debug-base19 (>= 0.11.19)
-    ruby_core_source (0.1.5)
-      archive-tar-minitar (>= 0.5.2)
     tzinfo (0.3.31)
 
 PLATFORMS
@@ -61,5 +48,4 @@ DEPENDENCIES
   database_cleaner
   fabrication
   rspec
-  ruby-debug19
   search_magic!

data/README.markdown

@@ -4,7 +4,7 @@ SearchMagic provides full-text search capabilities to [mongoid](http://github.co
 
 ## Installation
 
-SearchMagic is built on top of mongoid; in all likelihood, it will only work with versions greater than or equal to *2.0.0*. The project can be installed as a gem on a target system:
+SearchMagic is built on top of mongoid; in all likelihood, it will only work with versions greater than or equal to *2.0.0*. However, see Upgrading for information related to bugs which might be fixed due to newer versions of mongoid. The project can be installed as a gem on a target system:
 
 ```
 gem install search_magic
@@ -138,6 +138,89 @@ Mongoid already comes with a mechanism for [ordering documents](http://mongoid.o
 
 We'll revisit this topic in more detail after looking at how associations work.
 
+### Instance values matching a search pattern
+
+_(As of version 0.3.0.)_
+
+Searchable documents gain an instance method, **values_matching**, which takes one parameter, a search **pattern**, returning the entries in **searchable_values** which match **pattern**. This method behaves similarly to **search_for**; notably, it will take any input accepted by **search_for**.
+
+```ruby
+pattern = "los angeles state:ca"
+address = Address.search_for(pattern).first
+address.values_matching(pattern)            # ["city:los", "city:angeles", "state:ca"]
+```
+
+As can be inferred from the previous example, this can be useful for discerning which selectors of a given document are matching specific text. It can also be useful for determining which data is present in a given document, when altering the search mode.
+
+### Altering the search mode
+
+_(As of version 0.3.0.)_
+
+The search mode establishes how each successive query fragment winnows the result set of the search. Two different search modes are supported by SearchMagic:
+
+1. **all**: in this mode, a matching document must have data that satisfies each query fragment of the search pattern;
+2. **any**: in this mode, a matching document must have data that satisfies at least one query fragment of the search pattern.
+
+The mode is alterable on a per-query basis through the **mode** selector. Should **mode** be absent from a query, the query defaults to the **all** behavior. Despite the examples, please note that **mode** need not be specified first within a pattern; its presence anywhere within the pattern is sufficient. However, also note that successive instances within a query will overwrite previous instances.
+
+The following two searches are equivalent: they both return all addresses which represent a location within Los Angeles, CA.
+
+```ruby
+Address.search_for("mode:all city:'los angeles' state:ca")
+Address.search_for("city:'los angeles' state:ca")
+```
+
+However, the following search is more expansive: it matches all addresses which represent a location either within Los Angeles, or within the state of California.
+
+```ruby
+Address.search_for("mode:any city:'los angeles' state:ca")
+```
+
+### Searching within an embedded hash
+
+_(As of version 0.3.0.)_
+
+Embedded hashes are handled slightly differently from normal searchable fields: like normal fields, the hash selector follows normal naming rules, but keys are specified with an extra **":"** separator. 
+
+```ruby
+class Video
+  include Mongoid::Document
+  include SearchMagic
+  field :data, type: Hash, default: {}
+  search_on :data
+end
+```
+
+Given the preceding class definition, which defines a searchable hash field called **data**, a search may be performed on arbitrary keys within **data** in the following manner:
+
+```ruby
+Video.search_for("data:resolution:1080p")
+Video.search_for("data:director:'Tim Burton'")
+Video.search_for("data:duration:#{60.minutes}")
+```
+
+Which is to say that searching a hash takes the form of specifying the hash field selector, followed by a colon separator and the specific key, followed by a colon separator and the specific value for the key. Values are handled according to other rules specified within this document. In this format, the hash field selector and the specified key act as the full selector for the query fragment.
+
+### "I sense something; a presence I've not felt since..."
+
+_(As of version 0.3.0.)_
+
+Most of the useful functionality provided by SearchMagic is to be found in searching the document search graph for specific values. However, it can also be useful to simply determine whether a given selector has any value, rather than a particular one. This can be done through a simple presence detection test, which matches a given document if the document has a value set on the (searchable) field.
+
+For example, to search for all addresses which have a **postal_code** set, the following query might be used:
+
+```ruby
+Address.search_for("postal_code?") # i.e. all addresses for which address.postal_code.present? would return true.
+```
+
+Which is to say that a presence detection query fragment is formed by specifying a selector followed by a question mark (**?**). This can be especially useful for determining if an embedded hash has a value present for a given key:
+
+```ruby
+Video.search_for("data:duration?") # i.e. all videos for which video.data[duration].present? would return true.
+```
+
+Note that Boolean searchable fields will automatically transcribe the boolean value into either true or false; presence detection does not currently take this into consideration, so while a presence detection fragment will match a selector which evaluates to true, it will also match a selector which evaluates to false.
+
 ### Querying docs about their searchables
 
 SearchMagic provides some utility methods which can be used to find out information about a document's searchable fields:
@@ -160,7 +243,7 @@ Similar caveats exist for **arrangeable_values**. Its main purpose is to enable
 
 ## Global Configuration
 
-For the most part, configuration options are local to the documents and fields they are defined within. However, there are a few global options which are used across models, which can be altered through global configuration. These options (okay, for right now, "option", as there is only one) can be accessed through SearchMagic's **config** hash:
+For the most part, configuration options are local to the documents and fields they are defined within. However, there are a few global options which are used across models, which can be altered through global configuration. These options can be accessed through SearchMagic's **config** hash:
 
 ```ruby
 SearchMagic.config # for global options!
@@ -188,6 +271,18 @@ Note that **search_for** will immediately use the new separator value after a ch
 
 Setting **selector_value_separator** to **nil** results in the same behavior as setting it to ':'.
 
+### :presence_detector
+
+_(As of 0.3.0)_
+
+Defaults to '?'. This is the token matched by **search_for** to signal that a simple presence detection query fragment is being requested.
+
+### :default_search_mode
+
+_(As of 0.3.0)_
+
+Defaults to 'all'. This is the search mode that will be used by default unless overridden by a **mode** query fragment. While this can be set to anything, the only values which alter behavior are **nil**, **:all/"all"**, and **:any/"any"**. Setting this to nil causes the default behavior.
+
 ## A little more depth...
 
 ### Search Graph
@@ -234,7 +329,7 @@ Game.searchables.keys # [:title, :price, :high_score, :developer_name, :develope
 
 See how the searchables from Developer were automatically added to Game? Only those fields which are within Developer's search graph will be subsumed into Game. Notice how there is a field and an association within Document which are not being searched on? Those are not added to Game's searchables.
 
-Take another look at Game's searchables. Notice the way that fields coming from an association are handled? They are receive a prefix equivalent to the name of the association. This allows SearchMagic to build rather complex search graphs without having to necessarily worry about weird aliasing issues. The values coming from these fields will be stored within each Game instance's **searchable_values** with this prefixed name, and **search_for** will likewise be expecting the use of the prefixed names.
+Take another look at Game's searchables. Notice the way that fields coming from an association are handled? They all receive a prefix equivalent to the name of the association. This allows SearchMagic to build rather complex search graphs without having to necessarily worry about weird aliasing issues. The values coming from these fields will be stored within each Game instance's **searchable_values** with this prefixed name, and **search_for** will likewise be expecting the use of the prefixed names.
 
 ```ruby
 game = Game.search_for("developer_name:bethesda title:skyrim").first
@@ -267,7 +362,7 @@ There are three important things to note about this:
 2. All of the searchables coming from **games** are prefixed with the singular form of the association name.
 3. This includes even those searchables which are, themselves, representative of an association.
 
-SearchMagic should be able to handle as complex of a document graph as you care to throw at it. (*SearchMagic and its developer are not liable for computer's exploding while attempting to process crazy large document graphs.*) While the running example is fairly linear, you are not limited to simple paths like this: you can have search graphs which are as broad and deep as you like. Which leads us to the next topic.
+SearchMagic should be able to handle as complex of a document graph as you care to throw at it. (*SearchMagic and its developer are not liable for computers exploding while attempting to process crazy large document graphs.*) While the running example is fairly linear, you are not limited to simple paths like this: you can have search graphs which are as broad and deep as you like. Which leads us to the next topic.
 
 #### Cyclic Searches
 
@@ -299,7 +394,7 @@ As you can see, Game remains the same, while Developer gains a few extra searcha
 
 ### arrange
 
-Now that we've explored the search graph, its time to revisit arranging data. Any values coming from a document's searchables are replicated in a hash within that document: its **arrangeable_values**. Will slightly costly, when it comes to replicating data across a document hierarchy, it provides a very clever trick: it allows a document to be sorted by any of its searchables, regardless of where they come from. It matters not whether the searchable is a field on the defining document or on an association. It matters not whether a field is coming from a referenced or an embedded document. All are welcome, and all are handled exactly the same.
+Now that we've explored the search graph, its time to revisit arranging data. Any values coming from a document's searchables are replicated in a hash within that document: its **arrangeable_values**. While slightly costly, when it comes to replicating data across a document hierarchy, it provides a very clever trick: it allows a document to be sorted by any of its searchables, regardless of where they come from. It matters not whether the searchable is a field on the defining document or on an association. It matters not whether a field is coming from a referenced or an embedded document. All are welcome, and all are handled exactly the same.
 
 Using the running examples from the last sections, let's explore some example usage:
 
@@ -391,6 +486,10 @@ Developer.search_for("opened_on:'January 1986'")
 
 Note, in order for the natural language processing to be invoked properly, the *value* part of a search must be wrapped in quotes; multiple occurrences of a datable searchable will be processed separately, rather than as a unit.
 
+## Upgrading
+
+* **0.3.0**: Mongoid 2.4.3 or greater is now required, to facilitate the use of the **search_for** scope on an embedded document from within a non-searchable parent.
+
 ## Problems? Comments?
 
 Feel free to add an [issue on GitHub](search_magic/issues) or fork the project and send a pull request. 

data/lib/search_magic.rb

@@ -4,6 +4,7 @@ module SearchMagic
   require 'search_magic/stack_frame'
   require 'search_magic/metadata'
   require 'search_magic/full_text_search'
+  require 'search_magic/railtie' if defined?(Rails)
   include ActiveSupport::Configurable
   extend ActiveSupport::Concern
   

data/lib/search_magic/full_text_search.rb

@@ -28,34 +28,84 @@ module SearchMagic
           map(&:first).map(&:name)
       end
       
+      # To support range searches, this will need to become more complicated. Specifically, it will need to be able
+      # to remove any term which contains a [:below, :before, :above, :after] selector, retreive the base selector and
+      # the target valuee, and match the latter against the former within the :arrangeable_values array as part of
+      # the returned criteria. How this then translates to :values_matching is currently unknown.
       def search_for(pattern)
-        separator = Regexp.escape(SearchMagic.config.selector_value_separator || ':')
+        options, pattern = strip_option_terms_from(pattern)
+        terms = terms_for(pattern)
+        unless terms.blank?
+          send( :"#{options[:mode] || default_search_mode}_in", :searchable_values => terms)
+        else
+          criteria
+        end
+      end
+      alias :and_for :search_for
+      
+      def arrange(arrangeable, direction = :asc)
+        arrangeable.blank? || !searchables.keys.include?(arrangeable.to_sym) ? criteria : order_by([["arrangeable_values.#{arrangeable}", direction]])
+      end
+      
+      def strip_option_terms_from(pattern)
+        unless pattern.blank?
+          [Hash[*(pattern.scan(option_terms).flatten)].symbolize_keys, pattern.gsub(option_terms, '').strip]
+        else
+          [{}, pattern]
+        end
+      end
+      
+      def terms_for(pattern)
         rval = /("[^"]+"|'[^']+'|\S+)/
-        rsearch = /(?:(#{searchables.keys.join('|')})#{separator}#{rval})|#{rval}/i
+        rnot_separator = "[^#{separator}]+"
+        rsearch = /(?:(#{searchable_names})(?:#{separator}#{rval}|(#{presence_detector_escaped})))|#{rval}/i
         unless pattern.blank?
           terms = pattern.scan(rsearch).map(&:compact).map do |term|
-            selector = term.length > 1 ? Regexp.escape(term.first) : "[^#{separator}]+"
-            metadata = searchables[term.first.to_sym] if term.length > 1
+            selector = term.length > 1 ? Regexp.escape(term.first) : rnot_separator
+            metadata = searchables[term.first.match(/^[^:]+/)[0].to_sym] if term.length > 1
             parsed_date = Chronic.parse(term.last) if metadata && metadata.datable?
             prefix = "#{selector}#{separator}"
             prefix = "(#{prefix})?" if term.length == 1
-            fragment = /#{selector}#{separator}#{parsed_date}/i if parsed_date
+            fragment = /^#{selector}#{separator}#{parsed_date}/i if parsed_date
+            fragment = /^#{prefix}[^#{separator}\s]+/i if term.last == presence_detector
             fragment || term.last.scan(/\b(\S+)\b/).flatten.map do |word|
-              /#{prefix}.*#{Regexp.escape(word)}/i
+              /^#{prefix}.*#{Regexp.escape(word)}/i
             end
           end.flatten
-          all_in(:searchable_values => terms)
         else
-          criteria
+          []
         end
       end
-      alias :and_for :search_for
       
-      def arrange(arrangeable, direction = :asc)
-        arrangeable.blank? || !searchables.keys.include?(arrangeable.to_sym) ? criteria : order_by([["arrangeable_values.#{arrangeable}", direction]])
+      private
+      
+      def searchable_names
+        @searchable_names ||= searchables.values.map {|metadata| metadata.search_regex_fragment}.join("|")
       end
       
-      private 
+      def option_terms
+        @option_terms ||= Regexp.union( 
+          *{
+            :mode => [:all, :any]
+          }.map {|key, value| /(#{key})#{separator}(#{value.join('|')})/i}
+        )
+      end
+      
+      def presence_detector_escaped
+        @presence_detector_escaped ||= Regexp.escape(presence_detector)
+      end
+      
+      def presence_detector
+        @presence_detector ||= (SearchMagic.config.presence_detector || '?')
+      end
+      
+      def separator
+        @separator ||= Regexp.escape(SearchMagic.config.selector_value_separator || ':')
+      end
+      
+      def default_search_mode
+        Regexp.escape(([SearchMagic.config.default_search_mode.to_s] & %w{all any}).first || 'all')
+      end
       
       def create_searchables
         stack, visited, fields = [StackFrame.new(self)], {}, []
@@ -78,6 +128,13 @@ module SearchMagic
         fields.index_by(&:name)
       end
     end
+    
+    def values_matching(pattern)
+      options, pattern = self.class.strip_option_terms_from(pattern)
+      terms = self.class.terms_for(pattern)
+      r = Regexp.union(*terms)
+      searchable_values.grep(r)
+    end
   
     private
     

data/lib/search_magic/metadata.rb

@@ -12,6 +12,10 @@ module SearchMagic
       @name ||= through.map(&:term).compact.join("_").to_sym
     end
     
+    def search_regex_fragment
+      self.hashable? ? "#{name}#{separator}[^#{separator}\\s]+" : name.to_s
+    end
+    
     def comparable?
       @comparable ||= self.type.public_instance_methods.include? :<
     end
@@ -23,30 +27,45 @@ module SearchMagic
     def unnameable?
       @unnameable ||= self.name == :""
     end
-  
-    def value_for(obj, keep_punctuation)
-      v = get_value(obj)
-      v = v.is_a?(Array) ? v.join(" ") : v.to_s
-      v = v.gsub(/[[:punct:]]/, ' ') unless keep_punctuation
-      v
-    end
     
+    def hashable?
+      @hashable ||= self.type <= Hash
+    end
+      
     def arrangeable_value_for(obj)
       post_process(get_value(obj))
     end
   
     def searchable_value_for(obj)
-      value_for(obj, options[:keep_punctuation]).downcase.split.map {|word| [name.blank? ? nil : name, word].compact.join(SearchMagic.config.selector_value_separator || ':')}
+      value_for(get_value(obj)).downcase.split.map {|word| [name.blank? ? nil : name, word].compact.join(separator)}
     end
     
     private
     
+    def value_for(obj)
+      v = obj
+      v = v.map {|key, value| value_for(value).split.map {|word| "#{key}#{separator}#{word}"} }.flatten if obj.is_a?(Hash)
+      v = v.is_a?(Array) ? v.join(" ") : v.to_s
+      options[:keep_punctuation] || obj.is_a?(Hash) ? v : v.to_s.gsub(/[[:punct:]]/, ' ')
+    end
+        
+    def separator
+      SearchMagic.config.selector_value_separator || ':'
+    end
+    
     def get_value(obj)
-      self.through.map(&:field_name).inject(obj) {|memo, method| memo.is_a?(Array) ? memo.map{|o| o.send(method)} : memo.send(method)}
+      self.through.map(&:field_name).inject(obj) {|memo, method| memo.present? ? (memo.is_a?(Array) ? memo.map{|o| o.send(method)} : memo.send(method)) : nil}
     end
     
     def post_process(value)
-      value.is_a?(Array) ? value.map {|obj| convert_date_to_time(obj)} : convert_date_to_time(value)
+      case(value.class)
+      when Array
+        value.map {|obj| convert_date_to_time(obj)}
+      when Hash
+        Hash[*value.map {|key, value| [key, convert_date_to_time(value)]}]
+      else
+        convert_date_to_time(value)
+      end
     end
     
     def convert_date_to_time(value)

data/lib/search_magic/railtie.rb

@@ -0,0 +1,7 @@
+module SearchMagic
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      Dir["tasks/**/*.rake"].each { |ext| load ext }
+    end
+  end
+end

data/lib/search_magic/version.rb

@@ -1,3 +1,3 @@
 module SearchMagic
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/tasks/rebuild_searchable_values.rake

@@ -0,0 +1,8 @@
+namespace :search_magic do
+  desc "Updates each SearchMagic document's :searchable_values array"
+  task :rebuild => :environment do |t, args|
+    Module.constants.map {|c| Module.const_get(c)}.select {|c| c.class == Class && c < SearchMagic}.each do |document|
+      document.all.each {|d| d.save!}
+    end
+  end
+end

data/search_magic.gemspec

@@ -12,13 +12,13 @@ Gem::Specification.new do |s|
   s.summary     = %q{SearchMagic provides scoped full text search and sort capabilities to Mongoid documents}
   s.description = %q{Adds scopes to a Mongoid document providing search and sort capabilities on arbitrary fields and associations.}
   
-  s.add_dependency("mongoid", ">= 2.0.0")
+  s.add_dependency("mongoid", ">= 2.4.3")
   s.add_dependency("chronic")
   s.add_development_dependency("rspec")
   s.add_development_dependency("database_cleaner")
   s.add_development_dependency("bson_ext")
   s.add_development_dependency("fabrication")
-  s.add_development_dependency('ruby-debug19')
+  # s.add_development_dependency('ruby-debug19')
 
   s.rubyforge_project = "search_magic"
 

data/spec/fabricators/game_fabricator.rb

@@ -0,0 +1,6 @@
+Fabricator(:game) do
+  title { Fabricate.sequence(:game) {|i| "Game Title #{i}"} }
+  price { [19.95, 45.50, 59.99, 79.99, 99.99].sample }
+  high_score { 500 + rand(1000) }
+  released_on { [1.month.ago, 6.months.ago, 1.year.ago, 10.years.ago].sample.to_date }
+end

data/spec/fabricators/user_fabricator.rb

@@ -0,0 +1,4 @@
+Fabricator(:user) do
+  name { Fabricate.sequence(:user_name) {|i| "user-name-#{i}"} }
+  watchlists(:count => 5) {|user, watchlist| Fabricate(:watchlist, :user => user)}
+end

data/spec/fabricators/video_fabricator.rb

@@ -0,0 +1,9 @@
+Fabricator(:video) do
+  title { Fabricate.sequence(:video_title) {|i| "video-title-#{i}"} }
+  extra {
+    {
+      "resolution" => %w[480i 480p 720p 1080p 1080i 1080p].sample,
+      "duration" => 180 * rand
+    }
+  }
+end

data/spec/fabricators/watchlist_fabricator.rb

@@ -0,0 +1,3 @@
+Fabricator(:watchlist) do
+  description { Fabricate.sequence(:watchlist_description) {|i| "watchlist-#{i}"} }
+end

data/spec/models/game.rb

@@ -9,7 +9,8 @@ class Game
   referenced_in :developer
   
   search_on :title
-  search_on :price
+  search_on :price, :keep_punctuation => true
   search_on :high_score
+  search_on :released_on, :keep_punctuation => true
   search_on :developer, :except => :opened_on
 end

data/spec/models/model_with_field_types.rb

@@ -7,6 +7,7 @@ class ModelWithFieldTypes
   field :date_field, :type => Date
   field :float_field, :type => Float
   field :bool_field, :type => Boolean
+  field :hash_field, :type => Hash
   
   def some_value
     true
@@ -18,5 +19,6 @@ class ModelWithFieldTypes
   search_on :date_field
   search_on :float_field
   search_on :bool_field
+  search_on :hash_field
   search_on :some_value
 end

data/spec/models/user.rb

@@ -0,0 +1,6 @@
+class User
+  include Mongoid::Document
+  field :name
+  
+  embeds_many :watchlists
+end

data/spec/models/video.rb

@@ -0,0 +1,8 @@
+class Video
+  include Mongoid::Document
+  include SearchMagic
+  field :title, :type => String
+  field :extra, :type => Hash, :default => {}
+  search_on :title
+  search_on :extra
+end

data/spec/models/watchlist.rb

@@ -0,0 +1,8 @@
+class Watchlist
+  include Mongoid::Document
+  include SearchMagic
+  field :description
+  
+  embedded_in :user
+  search_on :description
+end

data/spec/unit/search_magic/associations_spec.rb

@@ -18,14 +18,14 @@ describe SearchMagic::FullTextSearch do
   
   context "when a model excludes an associated documents fields" do
     subject { Game }
-    its("searchables.keys") { should include(:title, :price, :high_score, :developer_name) }
+    its("searchables.keys") { should include(:title, :price, :high_score, :released_on, :developer_name) }
     its("searchables.keys") { should_not include(:developer_opened_on) }
   end
   
   context "when a model only includes certain fields from an associated document" do
     subject { Player }
     its("searchables.keys") { should include(:name, :game_title, :game_developer_name) }
-    its("searchables.keys") { should_not include(:game_price, :game_high_score, :game_developer_opened_on)}
+    its("searchables.keys") { should_not include(:game_price, :game_high_score, :game_released_on, :game_developer_opened_on)}
   end
   
   context "when a model embeds one other document" do

data/spec/unit/search_magic/configuration_spec.rb

@@ -1,28 +1,56 @@
 describe SearchMagic do
   it { should respond_to(:config) }
 
-  shared_examples_for "selector_value_separator" do |separator|
-    context "with a configuration for :selector_value_separator of '#{separator}'" do
-      let(:tags) { %w{foo b.a.r b-az q:ux z!png p'zow} }
-      before(:each) { SearchMagic.config.selector_value_separator = separator }
-      before(:each) { Fabricate(:asset, :tags => tags) }
-      after(:each) { SearchMagic.config.selector_value_separator = nil }
-      let(:asset) { Asset.first }
-      describe do
-        subject { asset }
-        its(:searchable_values) { should include( *tags.map {|tag| "tag#{separator || ':'}#{tag}"} ) }
-      end
-      describe "searching for models should use '#{separator || ':'}'" do
-        subject { Asset.search_for("tag#{separator || ':'}foo") }
-        its(:count) { should == 1 }
-        its(:first) { should == asset }
+  context "global option: selector_value_separator" do
+    shared_examples_for "selector_value_separator" do |separator|
+      context "with a configuration for :selector_value_separator of #{separator.inspect}" do
+        let(:tags) { %w{foo b.a.r b-az q:ux z!png p'zow} }
+        before(:each) { SearchMagic.config.selector_value_separator = separator }
+        before(:each) { Fabricate(:asset, :tags => tags) }
+        after(:each) { SearchMagic.config.selector_value_separator = nil }
+        let(:asset) { Asset.first }
+        describe do
+          subject { asset }
+          its(:searchable_values) { should include( *tags.map {|tag| "tag#{separator || ':'}#{tag}"} ) }
+        end
+        describe "searching for models should use '#{separator || ':'}'" do
+          subject { Asset.search_for("tag#{separator || ':'}foo") }
+          its(:count) { should == 1 }
+          its(:first) { should == asset }
+        end
       end
     end
+  
+    it_should_behave_like "selector_value_separator", nil
+    it_should_behave_like "selector_value_separator", ':'
+    it_should_behave_like "selector_value_separator", '/'
+    it_should_behave_like "selector_value_separator", '-'
+    it_should_behave_like "selector_value_separator", '!'
   end
   
-  it_should_behave_like "selector_value_separator", nil
-  it_should_behave_like "selector_value_separator", ':'
-  it_should_behave_like "selector_value_separator", '/'
-  it_should_behave_like "selector_value_separator", '-'
-  it_should_behave_like "selector_value_separator", '!'
+  context "global option: default_search_mode" do
+    before(:each) do
+      Fabricate(:asset, :tags => %w[b.a.r p'zow z!png dirigible])
+      Fabricate(:asset, :tags => %w[foo b-az q:ux dirigible])
+    end
+    
+    shared_examples_for "default_search_mode" do |default_search_mode, expected_count, should_fail|
+      context "with a configuration for :default_search_mode of #{default_search_mode.inspect}" do
+        let(:pattern) { "dirigible z!png" }
+        before(:each) { SearchMagic.config.default_search_mode = default_search_mode }
+        after(:each) { SearchMagic.config.default_search_mode = nil }
+        describe "searching without an explicit mode" do
+          subject { Asset.search_for(pattern) }
+          its(:count) { should == expected_count }
+        end
+      end
+    end
+    
+    it_should_behave_like "default_search_mode", nil, 1
+    it_should_behave_like "default_search_mode", "all", 1
+    it_should_behave_like "default_search_mode", "any", 2
+    it_should_behave_like "default_search_mode", :all, 1
+    it_should_behave_like "default_search_mode", :any, 2
+    it_should_behave_like "default_search_mode", "unsupported", 1
+  end
 end

data/spec/unit/search_magic/embedded_hash_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe SearchMagic do
+  context "when a model includes an embedded hash" do
+    subject { Video }
+    its("searchables.keys") { should == [:title, :extra] }
+    its(:searchable_names) { should == "title|extra:[^:\\s]+"}
+  end
+  
+  context "a model with an embedded hash" do
+    subject { Video.searchables[:extra] }
+    it { should be_hashable }
+  end
+  
+  context "searching for a model with an embedded hash" do
+    before(:each) do
+      Fabricate(:video, :extra => {"resolution" => "1080p"})
+      Fabricate(:video, :extra => {"resolution" => "1080i"})
+      Fabricate(:video, :extra => {"resolution" => "720p"})
+      Fabricate(:video, :extra => {"director" => "Alan Smithee"})
+    end
+    
+    shared_examples_for "an embedded hash" do |key, expected_value, expected_count|
+      if expected_value.present?
+        context "the criteria \"extra:#{key}:#{expected_value}\"" do
+          subject { Video.search_for("extra:#{key}:#{expected_value}") }
+          its(:selector) { should == {:searchable_values => {"$all" => expected_value.gsub(/^'([^']+)'$/, '\1').split.map {|word| /^extra:#{key}:.*#{word}/i }}}}
+          its(:count) { should == 1 }
+        end
+        context "the instance" do
+          Video.search_for("extra:#{key}:#{expected_value}").each do |video|
+            context video do
+              its(:extra) { should_not be_blank }
+              it { video.extra[key].should =~ /#{expected_value}/i }
+            end
+          end
+        end
+      end
+      context "the criteria \"extra:#{key}?\"" do
+        subject { Video.search_for("extra:#{key}?") }
+        its(:selector) { should == {:searchable_values => {"$all" => [/^extra:#{key}:[^:\s]+/i]} }}
+        its(:count) { should == expected_count }
+      end
+    end
+    
+    it_should_behave_like "an embedded hash", "resolution", "1080p", 3
+    it_should_behave_like "an embedded hash", "resolution", "1080i", 3
+    it_should_behave_like "an embedded hash", "resolution", "720p", 3
+    it_should_behave_like "an embedded hash", "director", "smithee", 1
+    it_should_behave_like "an embedded hash", "director", "alan", 1
+    it_should_behave_like "an embedded hash", "director", "'alan smithee'", 1
+    it_should_behave_like "an embedded hash", "widget", nil, 0
+    
+    context "an instance's values_matching" do
+      subject { Video.search_for("extra:resolution?").first.values_matching("extra:resolution?") }
+      it { should include("extra:resolution:1080p") }
+    end
+  end
+end

data/spec/unit/search_magic/embedded_in_non_searchable_class_spec.rb

@@ -0,0 +1,35 @@
+describe SearchMagic do
+  context "when searching for documents through an attribute of a non-searchable class" do
+    before(:each) do
+      Fabricate(:user)
+    end
+    
+    context "an embedded documents searchable_values should not be empty" do
+      subject { User.first.watchlists.first }
+      its(:searchable_values) { should == %w[description:watchlist description:0] }
+    end
+    
+    context "directly searching an embedded document" do
+      subject { User.first.watchlists.where(:description => /^([^:]+:)?.*watchlist/i) }
+      its(:count) { should == 5 }
+    end
+    
+    context "the terms for a given watchlist" do
+      subject { User.first.watchlists.first }
+      it { subject.values_matching("watchlist").should == ["description:watchlist"] }
+    end
+    
+    context "directly searching the searchable_values of an embedded document" do
+      subject { User.first.watchlists.all_in(:searchable_values => [/^([^:]+:)?.*watchlist/i]) }
+      its(:selector) { should == {:searchable_values => {"$all" => [/^([^:]+:)?.*watchlist/i]}} }
+      its(:count) { should == 5 }
+    end
+    
+    context "the search query should be" do
+      subject { User.first.watchlists.search_for("watchlist") }
+      its(:selector) { should == {:searchable_values => {"$all" => [/^([^:]+:)?.*watchlist/i]}} }
+      it { expect { subject.count }.to_not raise_error }
+      its(:count) { should == 5 }
+    end
+  end
+end

data/spec/unit/search_magic/metadata_spec.rb

@@ -12,7 +12,7 @@ describe SearchMagic::Metadata do
   end
   
   context "when dealing with breadcrumbs with :skip_prefix" do
-    subject { SearchMagic::Metadata.new(through: [SearchMagic::Breadcrumb.new(:foo, {skip_prefix: true}), SearchMagic::Breadcrumb.new(:bar, {})]) }
+    subject { SearchMagic::Metadata.new(:through => [SearchMagic::Breadcrumb.new(:foo, {:skip_prefix => true}), SearchMagic::Breadcrumb.new(:bar, {})]) }
     its(:name) { should == :bar }
   end
   
@@ -20,4 +20,11 @@ describe SearchMagic::Metadata do
     subject { SearchMagic::Metadata.new(:through => [SearchMagic::Breadcrumb.new(:foo, {}), SearchMagic::Breadcrumb.new(:bar, {:skip_prefix => true}), SearchMagic::Breadcrumb.new(:baz, {:as => :qux})]) }
     its(:name) { should == :foo_qux }
   end
+  
+  context "when dealing with a nil instance for a given breadcrump" do
+    let(:metadata) { SearchMagic::Metadata.new(:through => [SearchMagic::Breadcrumb.new(:foo, {}), SearchMagic::Breadcrumb.new(:bar, {})], :options => {}) }
+    let(:instance) { Struct.new(:foo).new(nil) }
+    it { expect { metadata.searchable_value_for(instance) }.to_not raise_error }
+    it { metadata.searchable_value_for(instance).should be_blank }
+  end
 end

data/spec/unit/search_magic/metadata_type_spec.rb

@@ -1,19 +1,19 @@
 describe SearchMagic do
+  shared_examples_for "metadata" do |field, type, comparable, search_regex_fragment|
+    subject { ModelWithFieldTypes.searchables[field] }
+    its(:type) { should == type }
+    its(:comparable?) { should == comparable }
+    its(:search_regex_fragment) { should == search_regex_fragment }
+  end
+  
   context "when included in a model which defines field types" do
-    subject { ModelWithFieldTypes.searchables }
-    it { subject[:generic_field].type.should == Mongoid::Fields::Serializable::Object }
-    it { subject[:generic_field].comparable?.should be_false }
-    it { subject[:string_field].type.should == String }
-    it { subject[:string_field].comparable?.should be_true }
-    it { subject[:float_field].type.should == Float }
-    it { subject[:float_field].comparable?.should be_true }
-    it { subject[:int_field].type.should == Integer }
-    it { subject[:int_field].comparable?.should be_true }
-    it { subject[:date_field].type.should == Date }
-    it { subject[:date_field].comparable?.should be_true }
-    it { subject[:bool_field].type.should == Boolean }
-    it { subject[:bool_field].comparable?.should be_false }
-    it { subject[:some_value].type.should == Object }
-    it { subject[:some_value].comparable?.should be_false }
+    it_behaves_like "metadata", :generic_field, Object, false, "generic_field"
+    it_behaves_like "metadata", :string_field, String, true, "string_field"
+    it_behaves_like "metadata", :float_field, Float, true, "float_field"
+    it_behaves_like "metadata", :int_field, Integer, true, "int_field"
+    it_behaves_like "metadata", :date_field, Date, true, "date_field"
+    it_behaves_like "metadata", :bool_field, Boolean, false, "bool_field"
+    it_behaves_like "metadata", :some_value, Object, false, "some_value"
+    it_behaves_like "metadata", :hash_field, Hash, false, "hash_field:[^:\\s]+"
   end
 end

data/spec/unit/search_magic/range_searches_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe SearchMagic do
+  context "when searching a model" do
+    before(:each) do
+      Fabricate(:game, :high_score => 250, :price => 19.95, :released_on => 2.weeks.ago)
+      Fabricate(:game, :high_score => 500, :price => 49.95, :released_on => 6.weeks.ago)
+      Fabricate(:game, :high_score => 750, :price => 59.95, :released_on => 4.months.ago)
+      Fabricate(:game, :high_score => 1000, :price => 79.95, :released_on => 8.months.ago)
+      Fabricate(:game, :high_score => 1250, :price => 99.95, :released_on => 4.years.ago)
+      Fabricate(:game, :high_score => 1500, :price => 149.95, :released_on => 15.years.ago)
+    end
+    
+    shared_examples_for "a simple range search" do |field, selector, value, expected_count|
+      context "the criteria" do
+        subject { Game.search_for("#{field}:#{selector}:#{value}") }
+        its(:count) { should == expected_count }
+      end
+      context "the instances" do
+        Game.search_for("#{field}:#{selector}:#{value}").each do |game|
+          context game do
+            case selector
+            when :below, :before
+              its(field) { should be < value }
+            when :above, :after
+              its(field) { should be > value }
+            end
+          end
+        end
+      end
+    end
+    
+    context "with a :below selector" do
+      it_should_behave_like "a simple range search", :high_score, :below, 1000, 3
+      it_should_behave_like "a simple range search", :price, :below, 50.00, 2
+      it_should_behave_like "a simple range search", :released_on, :below, 1.year.ago, 2
+    end
+    
+    context "with a :before selector" do
+      it_should_behave_like "a simple range search", :high_score, :before, 1000, 3
+      it_should_behave_like "a simple range search", :price, :before, 50.00, 2
+      it_should_behave_like "a simple range search", :released_on, :before, 1.year.ago, 2
+    end
+    
+    context "with an :above selector" do
+      it_should_behave_like "a simple range search", :high_score, :above, 1000, 2
+      it_should_behave_like "a simple range search", :price, :above, 50.00, 4
+      it_should_behave_like "a simple range search", :released_on, :above, 1.year.ago, 4
+    end
+    
+    context "with an :after selector" do
+      it_should_behave_like "a simple range search", :high_score, :after, 1000, 2
+      it_should_behave_like "a simple range search", :price, :after, 50.00, 4
+      it_should_behave_like "a simple range search", :released_on, :after, 1.year.ago, 4
+    end
+  end
+end

data/spec/unit/search_magic/search_modes_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe SearchMagic do
+  context "the model class" do
+    subject { Asset }
+    it { should respond_to(:strip_option_terms_from).with(1).argument }
+    it { subject.strip_option_terms_from(nil).should == [{}, nil] }
+    it { subject.strip_option_terms_from("tag:foo").should == [{}, "tag:foo"] }
+    it { subject.strip_option_terms_from("mode:any tag:foo").should == [{:mode => "any"}, "tag:foo"] }
+    it { subject.strip_option_terms_from("mode:all tag:foo").should == [{:mode => "all"}, "tag:foo"] }
+    it { subject.strip_option_terms_from("mode:all mode:any").should == [{:mode => "any"}, ""] }
+    it { subject.strip_option_terms_from("mode:any mode:all").should == [{:mode => "all"}, ""] }
+    it { subject.strip_option_terms_from("mode:all mode:any mode:all").should == [{:mode => "all"}, ""] }
+  end
+  context "when searching" do
+    before(:each) do
+      5.times { Fabricate(:asset, :tags => %w[b.a.r p'zow z!png dirigible]) }
+      5.times { Fabricate(:asset, :tags => %w[foo b-az q:ux dirigible]) }
+    end
+  
+    shared_examples_for "search" do |pattern, expected_count|
+      subject { Asset.search_for(pattern) }
+      its(:count) { should == expected_count }
+    end
+  
+    context "without a search mode" do
+      it_should_behave_like "search", "tag:foo tag:b.a.r", 0
+      it_should_behave_like "search", "tag:foo tag:b-az", 5
+      it_should_behave_like "search", "tag:dirigible", 10
+      it_should_behave_like "search", "tag:foo tag:dirigible", 5
+    end
+  
+    context "with a search mode" do
+      context "of all" do
+        it_should_behave_like "search", "mode:all tag:foo tag:b.a.r", 0
+        it_should_behave_like "search", "mode:all tag:foo tag:b-az", 5
+        it_should_behave_like "search", "mode:all tag:dirigible", 10
+        it_should_behave_like "search", "mode:all tag:foo tag:dirigible", 5
+      end
+    
+      context "of any" do
+        it_should_behave_like "search", "mode:any tag:foo tag:b.a.r", 10
+        it_should_behave_like "search", "mode:any tag:foo tag:b-az", 5
+        it_should_behave_like "search", "mode:any tag:dirigible", 10
+        it_should_behave_like "search", "mode:any tag:foo tag:dirigible", 10
+      end
+    end
+  end
+end

data/spec/unit/search_magic/search_pattern_syntax_spec.rb

@@ -2,18 +2,18 @@ describe SearchMagic::FullTextSearch do
   context "when searching for \"title:'foo bar'\"" do
     subject { Asset.search_for("title:'foo bar'") }
     its("selector.keys") { should include(:searchable_values) }
-    it { subject.selector[:searchable_values]["$all"].should include(/title:.*foo/i, /title:.*bar/i)}
+    it { subject.selector[:searchable_values]["$all"].should include(/^title:.*foo/i, /^title:.*bar/i)}
   end
   
   context "when searching for 'title:\"foo bar\"'" do
     subject { Asset.search_for('title:"foo bar"') }
     its("selector.keys") { should include(:searchable_values) }
-    it { subject.selector[:searchable_values]["$all"].should include(/title:.*foo/i, /title:.*bar/i)}
+    it { subject.selector[:searchable_values]["$all"].should include(/^title:.*foo/i, /^title:.*bar/i)}
   end
   
   context "when searching for 'title:foo title:bar'" do
     subject { Asset.search_for('title:foo title:bar') }
     its("selector.keys") { should include(:searchable_values) }
-    it { subject.selector[:searchable_values]["$all"].should include(/title:.*foo/i, /title:.*bar/i)}
+    it { subject.selector[:searchable_values]["$all"].should include(/^title:.*foo/i, /^title:.*bar/i)}
   end
 end

data/spec/unit/search_magic/values_matching_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe SearchMagic do
+  context "documents should have a method for finding values matching a pattern" do
+    let(:asset) { Fabricate(:asset) }
+    subject { asset }
+    it { should respond_to(:values_matching).with(1).argument }
+  end
+  
+  context "given a pattern, :values_matching should return an array" do
+    let(:asset) { Fabricate(:asset) }
+    subject { asset.values_matching("some pattern") }
+    it { should be_an(Array) }
+  end
+  
+  context "given a pattern" do
+    before(:each) { Fabricate(:asset, :tags => %w{b.a.r p'zow}) }
+    let(:asset) { Asset.first }
+    let(:pattern) { "asset generic tag:p'zow" }
+    context "which matches the document" do
+      subject { Asset.search_for(pattern) }
+      its(:count) { should == 1 }
+      its(:first) { should == asset }
+    end
+    context ":values_matching" do
+      subject { asset.values_matching(pattern) }
+      its(:length) { should == 3 }
+      it { should include("title:asset", "description:generic", "tag:p'zow") }
+      it { should_not include("title:title", "description:description", "tag:b.a.r") }
+    end
+  end
+  
+  shared_examples_for "a pattern" do |mode, pattern, expected_values|
+    before(:each) { Fabricate(:asset, tags: %w{b.a.r p'zow}) }
+    let(:asset) { Asset.first }
+    context "which matches the document" do
+      subject { Asset.search_for(pattern) }
+      its(:count) { should == 1 }
+      its(:first) { should == asset }
+    end
+    context ":values_matching" do
+      subject { asset.values_matching("mode:#{mode || :all} #{pattern}") }
+      its(:length) { should == expected_values.length }
+      it { should =~ expected_values }
+    end
+  end
+  
+  # The following specs are for a potential change to values_matching, which would allow it to take search mode
+  # into consideration. Needs more thought.
+  # context "given a pattern with a search mode" do
+  #   it_should_behave_like "a pattern", :all, "asset generic tag:p'zow", %w{title:asset description:generic tag:p'zow}
+  #   it_should_behave_like "a pattern", :all, "dirigible tag:p'zow", %w{}
+  #   it_should_behave_like "a pattern", :any, "dirigible b.a.r", %w{tag:b.a.r}
+  # end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: search_magic
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,22 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-03 00:00:00.000000000Z
+date: 2012-01-30 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid
-  requirement: &70196635537280 !ruby/object:Gem::Requirement
+  requirement: &70118998615140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 2.4.3
   type: :runtime
   prerelease: false
-  version_requirements: *70196635537280
+  version_requirements: *70118998615140
 - !ruby/object:Gem::Dependency
   name: chronic
-  requirement: &70196635536820 !ruby/object:Gem::Requirement
+  requirement: &70118998612180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70196635536820
+  version_requirements: *70118998612180
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70196635536300 !ruby/object:Gem::Requirement
+  requirement: &70118998611160 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70196635536300
+  version_requirements: *70118998611160
 - !ruby/object:Gem::Dependency
   name: database_cleaner
-  requirement: &70196635535760 !ruby/object:Gem::Requirement
+  requirement: &70118998609200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70196635535760
+  version_requirements: *70118998609200
 - !ruby/object:Gem::Dependency
   name: bson_ext
-  requirement: &70196635535140 !ruby/object:Gem::Requirement
+  requirement: &70118998606780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70196635535140
+  version_requirements: *70118998606780
 - !ruby/object:Gem::Dependency
   name: fabrication
-  requirement: &70196635534340 !ruby/object:Gem::Requirement
+  requirement: &70118998604200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,18 +76,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70196635534340
-- !ruby/object:Gem::Dependency
-  name: ruby-debug19
-  requirement: &70196635533880 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: *70196635533880
+  version_requirements: *70118998604200
 description: Adds scopes to a Mongoid document providing search and sort capabilities
   on arbitrary fields and associations.
 email:
@@ -105,13 +94,19 @@ files:
 - lib/search_magic/breadcrumb.rb
 - lib/search_magic/full_text_search.rb
 - lib/search_magic/metadata.rb
+- lib/search_magic/railtie.rb
 - lib/search_magic/stack_frame.rb
 - lib/search_magic/version.rb
+- lib/tasks/rebuild_searchable_values.rake
 - search_magic.gemspec
 - spec/fabricators/asset_fabricator.rb
 - spec/fabricators/developer_fabricator.rb
 - spec/fabricators/field_skip_prefix_fabricator.rb
+- spec/fabricators/game_fabricator.rb
 - spec/fabricators/simple_inclusion_model_fabricator.rb
+- spec/fabricators/user_fabricator.rb
+- spec/fabricators/video_fabricator.rb
+- spec/fabricators/watchlist_fabricator.rb
 - spec/models/absolutely_not_searchable.rb
 - spec/models/address.rb
 - spec/models/asset.rb
@@ -131,20 +126,28 @@ files:
 - spec/models/phone.rb
 - spec/models/player.rb
 - spec/models/simple_inclusion_model.rb
+- spec/models/user.rb
+- spec/models/video.rb
+- spec/models/watchlist.rb
 - spec/spec_helper.rb
 - spec/unit/search_magic/arrangements_spec.rb
 - spec/unit/search_magic/associations_spec.rb
 - spec/unit/search_magic/breadcrumb_spec.rb
 - spec/unit/search_magic/configuration_spec.rb
 - spec/unit/search_magic/date_parsing_spec.rb
+- spec/unit/search_magic/embedded_hash_spec.rb
+- spec/unit/search_magic/embedded_in_non_searchable_class_spec.rb
 - spec/unit/search_magic/fields_spec.rb
 - spec/unit/search_magic/graph_searches_spec.rb
 - spec/unit/search_magic/metadata_spec.rb
 - spec/unit/search_magic/metadata_type_spec.rb
 - spec/unit/search_magic/model_updates_spec.rb
+- spec/unit/search_magic/range_searches_spec.rb
+- spec/unit/search_magic/search_modes_spec.rb
 - spec/unit/search_magic/search_pattern_syntax_spec.rb
 - spec/unit/search_magic/simple_inclusion_model_spec.rb
 - spec/unit/search_magic/stack_frame_spec.rb
+- spec/unit/search_magic/values_matching_spec.rb
 homepage: http://github.com/joshuabowers/search_magic
 licenses: []
 post_install_message: 
@@ -174,7 +177,11 @@ test_files:
 - spec/fabricators/asset_fabricator.rb
 - spec/fabricators/developer_fabricator.rb
 - spec/fabricators/field_skip_prefix_fabricator.rb
+- spec/fabricators/game_fabricator.rb
 - spec/fabricators/simple_inclusion_model_fabricator.rb
+- spec/fabricators/user_fabricator.rb
+- spec/fabricators/video_fabricator.rb
+- spec/fabricators/watchlist_fabricator.rb
 - spec/models/absolutely_not_searchable.rb
 - spec/models/address.rb
 - spec/models/asset.rb
@@ -194,17 +201,25 @@ test_files:
 - spec/models/phone.rb
 - spec/models/player.rb
 - spec/models/simple_inclusion_model.rb
+- spec/models/user.rb
+- spec/models/video.rb
+- spec/models/watchlist.rb
 - spec/spec_helper.rb
 - spec/unit/search_magic/arrangements_spec.rb
 - spec/unit/search_magic/associations_spec.rb
 - spec/unit/search_magic/breadcrumb_spec.rb
 - spec/unit/search_magic/configuration_spec.rb
 - spec/unit/search_magic/date_parsing_spec.rb
+- spec/unit/search_magic/embedded_hash_spec.rb
+- spec/unit/search_magic/embedded_in_non_searchable_class_spec.rb
 - spec/unit/search_magic/fields_spec.rb
 - spec/unit/search_magic/graph_searches_spec.rb
 - spec/unit/search_magic/metadata_spec.rb
 - spec/unit/search_magic/metadata_type_spec.rb
 - spec/unit/search_magic/model_updates_spec.rb
+- spec/unit/search_magic/range_searches_spec.rb
+- spec/unit/search_magic/search_modes_spec.rb
 - spec/unit/search_magic/search_pattern_syntax_spec.rb
 - spec/unit/search_magic/simple_inclusion_model_spec.rb
 - spec/unit/search_magic/stack_frame_spec.rb
+- spec/unit/search_magic/values_matching_spec.rb