ar_indexer 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a949f827bc86002e7bb7241edb513fbe452b51ca
-  data.tar.gz: e04f080e7cd9be0fa8dfb552578cac54c079de7d
+  metadata.gz: 9b173a0feed66c6dfa32f17b624840e9aced0285
+  data.tar.gz: 5a2776b09548c4c613bea0d76e592a3ccdc07b8e
 SHA512:
-  metadata.gz: f5841ed351d64accee8237245a8ce732aa2784ba32f3189f3dd1f36c2467f25859d8b08edc674b2291be487ff4799fcc7d5dbdf527ecb63a6261c120fa889459
-  data.tar.gz: 930f41e303645f21a73aa061f0557a742ad464af9568285befb81fd2eca1961eb9ebe2f2a550ead28a35b7fad538853fb7c793c753773af33c7ffcc380fe35f8
+  metadata.gz: 3938da4be83743a63650910f5951089fa9b7a15ab8c06623117bf2bbdb3cb4d4c7ed4feb6fc8937600ce1d4b070d361ed93101ef25dbb2c51425bb64796c3294
+  data.tar.gz: d8867a7a3d5a46566ba453cd078883a5114180152362bd3560649b6743e8cc010c12b1d198d04e83f35d1b891f19dae3712ce63a878c3e82602611e9bf5500a3

data/README.md

@@ -14,10 +14,11 @@ Write a migration to add a reverse_indices table to the database (Rails migratio
       def change
         create_table :reverse_indices do |t|
           t.string :model_name
+          t.string :field_name
           t.string :word
           t.text :id_list
         end
-        add_index :reverse_indices, [:model_name, :word], :unique => true
+        add_index :reverse_indices, [:model_name, :field_name, :word], :unique => true
       end
     end
 
@@ -27,7 +28,7 @@ Run `rake db:migrate`
 
 ###Indexing###
 
-Have an ActiveRecord model? Want to index some text for searching? Just add the `has_reverse_index` function to your model. Call the function with no parameters and ARIndexer will index all string and text fields. You can pass an optional array of field names (as symbols), and ARIndexer will index only these fields.
+Have an ActiveRecord model? Want to index some text for searching? Just add the `has_reverse_index` function to your model. Call the function with no parameters and ARIndexer will index all string and text fields. You can pass an optional array of field names (as symbols), and ARIndexer will index only these fields. Also, you can pass a hash with association names as keys and a lambda to access the necessary data. Note that the lambda must accept the AR object as its sole argument and must return a string.
 
     class Post < ActiveRecord::Base
       has_reverse_index
@@ -37,6 +38,19 @@ Have an ActiveRecord model? Want to index some text for searching? Just add the
       has_reverse_index([:title, :content])
     end
 
+    class Article < ActiveRecord::Base
+      has_many :article_tags
+      has_many :tags, :through => :article_tags
+      has_reverse_index(
+        [
+          :title,
+          :content
+        ],
+        {
+          :tags => lambda {|object| object.tags.collect{|tag| tag.name}.join(', ')}
+        }
+      )
+
 At this point, ARIndexer will build and maintain a reverse index for each record under these models.
 
 ###Searching###
@@ -47,15 +61,50 @@ ARIndexer also provides a simple search class for finding records by text search
     # Or search multiple models
     # foo = IndexSearch.new([Article, List])
 
-You can also pass an options hash (which currently has a whole 1 option, `:no_results_message`)
-
-    foo = IndexSearch.new([Article], :no_results_message => "Hey man, there's nothing there.")
+You can also pass an options hash to specify what fields should be searched, how the results should be sorted, a message for displaying if there are no results, etc. The default options hash is displayed below:
+
+    @options = {
+      :fields => [],
+      # If left as an empty array, will search all fields for the given model
+      
+      :match => :any,
+      # :any will expand your search string and find results that match any keyword
+      # :all will only return results that have as many keyword matches as words in the search string
+      
+      :sort => :relevance,
+      # :relevance will sort by number of keyword matches
+      # :field allows you to specify a field to sort by
+      
+      :sort_method => nil,
+      # Allows for a lambda by which to access a sortable value.
+      # If nil, will just access the field value
+      
+      :sort_direction => :desc,
+      # Sort order, default is DESC so that the most relevant results will be returned first
+      
+      :stopwords => [],
+      # An array of words that should not be used in the search.
+      # ar_indexer has an internal array of basic stopwords, and these will be added to it
+      
+      :no_results_message => 'No results were returned for the given search term.'
+      # A stored message that can be returned if there are no results returned
+    }
+
+    foo = IndexSearch.new([Article],
+      {
+        :fields => [:title],
+        :match => :all,
+        :sort => :field,
+        :sort_direction => :asc,
+        :no_results_message => "Hey man, there's nothing there."
+      }
+    )
 
 And now you're ready to search against the index that's been built.
 
-    foo.run_search('some search string')
+    foo.search('some search string')
 
-`run_search` will return an array of ActiveRecord objects ordered by the number of matched terms within your search string. If no objects matched your search string, an emtpy array is returned. If no results are returned, you can request the `:no_results_message`
+`foo.search` will return an array of ActiveRecord objects ordered by the number of matched terms within your search string. If no objects matched your search string, an emtpy array is returned. If no results are returned, you can request the `:no_results_message`
 
     results = foo.run_search('some search string')
     unless results.empty?

data/ar_indexer.gemspec

@@ -1,18 +1,23 @@
 Gem::Specification.new do |spec|
-  spec.name           = "ar_indexer"
-  spec.version        = "0.1.4"
-  spec.date           = "2014-02-18"
-  spec.summary        = "Allows for reverse indexing selected ActiveRecord models. Handles searching and return of objects"
-  spec.description    = spec.summary
-  spec.authors        = ["Josh Stump"]
-  spec.email          = "joshua.t.stump@gmail.com"
-  spec.homepage       = "https://github.com/jstump/ar_indexer"
-  spec.require_paths  = ["lib"]
-  spec.files          = `git ls-files`.split("\n")
-  spec.license        = "GPL-2"
+  # Basic Gem Description
+  spec.name          = "ar_indexer"
+  spec.version       = "0.2.0"
+  spec.date          = "2014-10-06"
+  spec.summary       = "Allows for reverse indexing selected ActiveRecord models. Handles searching and return of objects"
+  spec.description   = spec.summary
+  spec.authors       = ["Josh MacLachlan"]
+  spec.email         = "josh.t.maclachlan@gmail.com"
+  spec.homepage      = "https://github.com/jtmaclachlan/ar_indexer"
+  spec.require_paths = ["lib"]
+  spec.files         = `git ls-files`.split("\n")
+  spec.license       = "GPL-2"
   
-  spec.add_dependency('activerecord')
-  spec.add_dependency('activesupport')
+  # Runtime Dependencies
+  spec.add_dependency('activerecord', '>= 3.0.0')
+  spec.add_dependency('activesupport', '>= 3.0.0')
   spec.add_dependency('htmlentities')
   spec.add_dependency('fast-stemmer')
+
+  # Post-Install Message
+  spec.post_install_message = "If you're upgrading from v0.1.4 to v0.2.0, read the updated documentation. Your application will throw exceptions when trying to access indexed models."
 end

data/lib/ar_indexer/has_reverse_index.rb

@@ -1,100 +1,96 @@
 module ARIndexer
-
-  # Holds methods that are used to extend ActiveRecord models.
-  # Included automatically whenever ActiveRecord is required
-
   module Model
-
-    # Extends a specified ActiveRecord model by adding the functions within the ClassMethods module.
-    # Called automatically on all ActiveRecord models
-
     def self.included(base)
       base.send :extend, ClassMethods
     end
 
-    # Class methods that can be called on any ActiveRecord model to extend functionality
-
     module ClassMethods
+      def has_reverse_index(fields = [], associations = {})
+        fields.each do |field_name|
+          unless self.columns_hash.keys.include?(field_name.to_s)
+            unless ['string', 'text'].include?(self.columns_hash[field_name.to_s].type.to_s)
+              raise TypeError, 'Model properties provided to has_reverse_index() must be of field type string or text.'
+            end
+          end
+        end
 
-      # Marks all string and text fields (or a subset thereof) of an ActiveRecord model
-      # for indexing and adds a necessary set of instance methods.
-      # If the [fields] parameter is set, indexes only the specified fields,
-      # otherwise indexes all string and text fields.
-      # 
-      # ==== Parameters
-      # 
-      # * fields: optional array of field names (as symbols) to be indexed
-      # 
-      # ==== Examples
-      # 
-      #   class Post < ActiveRecord::Base
-      #     has_reverse_index
-      #   end
-      # 
-      #   class Article < ActiveRecord::Base
-      #     has_reverse_index([:title, :content])
-      #   end
+        associations.each do |association_name, access_function|
+          unless access_function.class == Proc
+            raise TypeError, 'Model associations must have a Proc provided in order to reach the appropriate value.'
+          end
+        end
 
-      def has_reverse_index(fields = [])
         send :include, InstanceMethods
 
         class_attribute :indexed_fields
-        self.indexed_fields = fields.dup
+        class_attribute :indexed_associations
+        self.indexed_fields = fields.clone || []
+        self.indexed_associations = associations.clone || {}
 
-        after_create :on_create_record
-        after_update :on_update_record
-        before_destroy :on_destroy_record
+        after_create :ar_indexer_on_create
+        after_update :ar_indexer_on_update
+        before_destroy :ar_indexer_on_destroy
       end
       module_function :has_reverse_index
 
-      # Instance methods available to instances of an ActiveRecord model which has had has_reverse_index()
-      # called on it. Currently, there are no public instance methods.
-
       module InstanceMethods
-
         private
 
-        def array_of_values_to_index
-          values_for_indexing = []
+        def ar_indexer_get_indexable_values
+          values_to_index = {}
+          
           if self.indexed_fields.empty?
-            self.class.columns.each do |c|
-              if ['string', 'text'].include? c.type.to_s
-                values_for_indexing << self.read_attribute(c.name)
+            self.class.columns.each do |column|
+              if ['string', 'text'].include? column.type.to_s
+                value = self.read_attribute(column.name)
+                if value.class == String
+                  unless value.empty?
+                    values_to_index[column.name] = value
+                  end
+                end
               end
             end
           else
-            self.indexed_fields.each do |f|
-              if ['string', 'text'].include? self.class.columns_hash[f.to_s].type.to_s
-                values_for_indexing << self.read_attribute(f.to_s)
+            self.indexed_fields.each do |field_name|
+              value = self[field_name]
+              if value.class == String
+                unless value.empty?
+                  values_to_index[field_name.to_s] = value
+                end
               end
             end
           end
-          values_for_indexing.delete_if {|v| [nil, ''].include? v}
-          return values_for_indexing
-        end
 
-        def on_create_record
-          values_for_indexing = array_of_values_to_index
-          unless values_for_indexing.empty?
-            Indexer.build_reverse_index(self.class.to_s.split('::').last.to_s, self.id, values_for_indexing, false)
+          unless self.indexed_associations.empty?
+            self.indexed_associations.each do |association_name, access_function|
+              value = access_function.call(self)
+              if value.class == String
+                unless value.empty?
+                  values_to_index[association_name.to_s] = value
+                end
+              end
+            end
           end
+
+          return values_to_index
         end
 
-        def on_update_record
-          values_for_indexing = array_of_values_to_index
-          unless values_for_indexing.empty?
-            Indexer.build_reverse_index(self.class.to_s.split('::').last.to_s, self.id, values_for_indexing, true)
+        def ar_indexer_on_create
+          ar_indexer_get_indexable_values.each do |field_name, value|
+            Indexer.index_string(self.class.to_s.split('::').last, self.id, field_name, value, false)
           end
         end
 
-        def on_destroy_record
-          Indexer.remove_from_reverse_index(self.class.to_s.split('::').last.to_s, self.id)
+        def ar_indexer_on_update
+          ar_indexer_get_indexable_values.each do |field_name, value|
+            Indexer.index_string(self.class.to_s.split('::').last, self.id, field_name, value, true)
+          end
         end
 
+        def ar_indexer_on_destroy
+          Indexer.remove_index_id(self.class.to_s, self.id)
+        end
       end
-
     end
-
   end
-
 end

data/lib/ar_indexer/index_search.rb

@@ -1,101 +1,142 @@
 module ARIndexer
+  module ARSearch
+    class IndexSearch
+      def initialize(models, opts = {})
+        @models = {}
+        models.each do |model|
+          @models[model.to_s.split('::').last] = model
+        end
 
-  # Simple class for searching the index generated by adding has_reverse_index to ActiveRecord models
-  # 
-  # === Initialization
-  # 
-  #   foo = IndexSearch.new(Article, {:no_results_message => "We're sorry, but no results were found"})
-  # 
-  # === Parameters
-  # 
-  # * [model_names]: array of constants denoting the ActiveRecord models to search
-  # * opts: optional hash of configuration options
-  # 
-  # === Options
-  # 
-  # :no_results_message => string which can be requested and displayed if no results are found
+        @options = {
+          :fields => [],
+          :match => :any,
+          :sort => :relevance,
+          :sort_method => nil,
+          :sort_direction => :desc,
+          :stopwords => [],
+          :no_results_message => 'No results were returned for the given search term.'
+        }
+        @options.merge!(opts)
+      end
 
-  class IndexSearch
+      def search_models
+        return @models.keys
+      end
 
-    def initialize(model_names, opts = {})
-      @models = {}
-      model_names.each do |model|
-        @models[model.to_s.split('::').last] = model
+      def options(key)
+        return @options[key]
       end
-      puts @models
 
-      @options = {
-        :no_results_message => "Your #{@model_name} search returned no results."
-      }
+      def search(value)
+        # Build array of words for query `reverse_indices.word IN ('word1', 'word2')`
+        if @options[:match] == :any
+          search_terms = ARSearch.expand_forward_index(Indexer.break_string(value), @options[:stopwords])
+          enforce_threshold = false
+        else
+          stopwords = (Stopwords::STOPWORDS + @options[:stopwords]).uniq
+          search_terms = (Indexer.break_string(value) - stopwords)
+          enforce_threshold = true
+        end
 
-      @options.merge!(opts)
-    end
+        # Execute AR query based on @options[:fields]
+        if @options[:fields].empty?
+          base_results = ReverseIndex.where(:model_name => self.search_models, :word => search_terms)
+        else
+          base_results = ReverseIndex.where(:model_name => self.search_models, :field_name => @options[:fields], :word => search_terms)
+        end
 
-    # Returns either the default :no_results_message, or the one specified on initialization
-    # 
-    # ==== Returns
-    # 
-    # string
+        unless base_results.empty?
+          return ARSearch.method("sort_by_#{@options[:sort]}".to_sym).call(base_results, self, search_terms.count)
+        else
+          return []
+        end
+      end
 
-    def no_results_message
-      return @options[:no_results_message]
+      def no_results_message
+        return @options[:no_results_message]
+      end
     end
 
-    # Runs a text search against the ReverseIndex model for a given ActiveRecord model and search string.
-    # Returns 
-    # 
-    # ==== Parameters
-    # 
-    # * search_string: string on which to search for indexed objects
-    # 
-    # ==== Returns
-    # 
-    # array of ActiveRecord objects, or an empty array
-    # 
-    # ==== Examples
-    # 
-    #   foo = IndexSearch.new(Article)
-    #   foo.run_search("test string")
-    #   #=> [<#Article>, <#Article>, ...]
-
-    def run_search(search_string)
-      search_terms = Indexer.expand_lexicon(Indexer.text_to_lexicon(search_string))
-      matches = {}
-      @models.keys.each do |model|
-        matches[model] = {}
+    def self.expand_forward_index(forward_index, stopwords)
+      # Stem and pluralize
+      forward_index.each do |word|
+        root = Stemmer::stem_word(word)
+        unless forward_index.include? root
+          forward_index = forward_index.inject([root], :<<)
+        end
+        plural = word.pluralize
+        unless forward_index.include? plural
+          forward_index = forward_index.inject([plural], :<<)
+        end
       end
-      search_terms.each do |st|
-        reverse_index_records = ReverseIndex.where(:model_name => [@models.keys], :word => st)
-        if reverse_index_records.count > 0
-          reverse_index_records.each do |rir|
-            rir.retrieve_id_array.each do |id|
-              if matches[rir.model_name].has_key?(id)
-                matches[rir.model_name][id] = matches[rir.model_name][id] + 1
+      
+      # Remove stopwords and duplicates again
+      stopwords = (Stopwords::STOPWORDS + stopwords).uniq
+      forward_index = (forward_index - stopwords).uniq
+      return forward_index
+    end
+
+    def self.get_object_counts(base_results, search_models, match_type, match_threshold)
+      relevancy_counts = {}
+      unsorted_results = []
+      search_models.each do |model|
+        model_results = base_results.where(:model_name => model)
+        unless model_results.empty?
+          relevancy_counts[model] = {}
+          model_results.each do |result|
+            id_array = result.retrieve_id_array
+            id_array.each do |object_id|
+              if relevancy_counts[model][object_id].nil?
+                relevancy_counts[model][object_id] = 1
               else
-                matches[rir.model_name][id] = 1
+                relevancy_counts[model][object_id] = (relevancy_counts[model][object_id] + 1)
               end
             end
           end
+          if match_type == :all
+            relevancy_counts[model].delete_if do |object_id, count|
+              count < match_threshold
+            end
+          end
         end
+        unsorted_results << relevancy_counts[model].to_a.map{|result| result << model}
       end
-      collected_matches = []
-      matches.each do |k,v|
-        unless v.empty?
-          collected_matches << v.to_a.map{|x| x << k}
+      return unsorted_results
+    end
+
+    def self.sort_by_relevance(base_results, search_object, match_threshold)
+      unsorted_results = ARSearch.get_object_counts(base_results, search_object.search_models, search_object.options(:match), match_threshold).flatten!(1) || []
+      unless unsorted_results.empty?
+        sorted_results = unsorted_results.sort_by {|x| [x[1], x[0]]}
+        if search_object.options(:sort_direction) == :desc
+          sorted_results = sorted_results.reverse
         end
+        return sorted_results.collect {|result| result[2].constantize.find(result[0])}
+      else
+        return []
       end
-      unless collected_matches.empty?
-        collected_matches.flatten!(1)
-        objects_to_return = []
-        collected_matches.sort{|x,y| x[1] <=> y[1]}.reverse.each do |match|
-          objects_to_return << @models[match[2]].find(match[0])
+    end
+
+    def self.sort_by_field(base_results, search_object, match_threshold)
+      unsorted_results = ARSearch.get_object_counts(base_results, search_object.search_models, search_object.options(:match), match_threshold).flatten!(1) || []
+      unless unsorted_results.empty?
+        unsorted_objects = unsorted_results.collect {|result| result[2].constantize.find(result[0])}
+        sort_method = search_object.options(:sort_method)
+        case sort_method.class.to_s
+        when 'Symbol'
+          sorted_results = unsorted_objects.sort_by {|object| object[sort_method]}
+        when 'Proc'
+          sorted_results = unsorted_objects.sort_by {|object| sort_method.call(object)}
+        else
+          sorted_results = unsorted_objects
         end
-        return objects_to_return
+        if search_object.options(:sort_direction) == :desc
+          sorted_results = sorted_results.reverse
+        end
+        return sorted_results 
       else
         return []
       end
     end
-
   end
-
 end

data/lib/ar_indexer/indexer.rb

@@ -1,162 +1,255 @@
 module ARIndexer
-
-  # Contains functions for creating a forward index from text, then converting it to a reverse index
-
   module Indexer
-
-    # Turns a string into lexicon array, including basic root words and plurals
-    # 
-    # ==== Parameters
-    # 
-    # text: the string to be converted
-    # 
-    # ==== Returns
-    # 
-    # array of strings
-
-    def self.text_to_lexicon(text)
+    def self.break_string(value)
       # Remove HTML markup
-      text.gsub!(/<[^>]+>/, ' ')
+      value.gsub!(/<[^>]+>/, ' ')
       # Decode HTML entities
       coder = HTMLEntities.new
-      text = coder.decode(text)
+      value = coder.decode(value)
       # Remove most punctuation
-      text.gsub!(/[^a-zA-Z0-9\s]/, '')
+      value.gsub!(/[^a-zA-Z0-9\s]/, '')
       # Move everything to lower case
-      text.downcase!
+      value.downcase!
       # Split all words into an array
-      lexicon = text.split(' ')
+      forward_index = value.split(' ')
       # Remove stopwords and duplicates
-      lexicon = (lexicon - Stopwords::STOPWORDS).uniq
-      return lexicon
-    end
-
-    # Expands the lexicon created by text_to_lexicon, adding plurals and root words
-    # 
-    # ==== Parameters
-    # 
-    # lexicon: array of strings to be expanded
-    # 
-    # ==== Returns
-    # 
-    # array of strings
-
-    def self.expand_lexicon(lexicon)
-      # Stem and pluralize
-      lexicon.each do |word|
-        root = Stemmer::stem_word(word)
-        if !lexicon.include? root
-          lexicon = lexicon.inject([root], :<<)
-        end
-        plural = word.pluralize
-        if !lexicon.include? plural
-          lexicon = lexicon.inject([plural], :<<)
-        end
-      end
-      # Remove stopwords and duplicates again
-      lexicon = (lexicon - Stopwords::STOPWORDS).uniq
-      return lexicon
-    end
-
-    # Takes an array of strings to be indexed, and calls text_to_lexicon on each.
-    # Returns the combined array flattened, uniquified, and sorted in alphabetical order
-    # 
-    # ==== Parameters
-    # 
-    # values_to_index: array of string values to index
-    # 
-    # ==== Returns
-    # 
-    # array of strings
-
-    def self.build_forward_index(values_to_index)
-      forward_index = []
-      # Run text_to_lexicon for each indexed field
-      values_to_index.each do |v|
-        forward_index << self.text_to_lexicon(v) if ![nil, ''].include? v
-      end
-      # Return the lexicon flattened, uniquified, and in alphabetical order
-      forward_index = forward_index.flatten.uniq.sort
+      forward_index = (forward_index - Stopwords::STOPWORDS).uniq
       return forward_index
     end
 
-    # For a given model name and object id, compares the list of words with the forward index of the text.
-    # If a word exists in the reverse index but not the forward index, removes the object id from the reverse index.
-    # If the id array is empty, removes the reverse index record
-    # 
-    # ==== Parameters
-    # 
-    # * model_name: string version of the model name to clean records for
-    # * record_id: object id to search for in the reverse index
-    # * forward_index: the array of words to check against
-
-    def self.clean_reverse_index(model_name, record_id, forward_index)
-      reverse_index_records = ReverseIndex.where(:model_name => model_name)
-      reverse_index_records.each do |rir|
-        if rir.id_list.match(/,{0,1}#{record_id},{0,1}/)
-          if !forward_index.include? rir.word
-            id_array = rir.retrieve_id_array
-            id_array.delete(record_id.to_i)
-            if id_array.empty?
-              rir.destroy
-            else
-              new_id_list = id_array.join(',')
-              rir.update(:id_list => new_id_list)
-            end
+    def self.index_string(model_name, object_id, field_name, value, repair_on_completion)
+      forward_index = self.break_string(value)
+      forward_index.each do |word|
+        if index_record = ReverseIndex.where(:model_name => model_name, :field_name => field_name, :word => word).first
+          current_id_array = index_record.retrieve_id_array
+          unless current_id_array.include? object_id
+            new_id_list = (current_id_array << object_id).sort.join(',')
+            index_record.update(:id_list => new_id_list)
           end
+        else
+          ReverseIndex.create(:model_name => model_name, :field_name => field_name, :word => word, :id_list => object_id)
         end
       end
+      repair_index(model_name, object_id, field_name, forward_index) if repair_on_completion
     end
 
-    # Takes an array of values to index, runs it through build_forward_index(), then builds the reverse index
-    # from the returned values
-    # 
-    # ==== Parameters
-    # 
-    # * model_name: the string version of the model name
-    # * record_id: the id of the object being indexed
-    # * values_to_index: array of string objects to use in building the reverse index
-    # * cleaning_required: boolean flag, whether or not to run clean_reverse_index()
-
-    def self.build_reverse_index(model_name, record_id, values_to_index, cleaning_required = false)
-      forward_index = self.build_forward_index(values_to_index)
-      forward_index.each do |word|
-        if reverse_index_record = ReverseIndex.where(:model_name => model_name, :word => word).first
-          id_array = reverse_index_record.retrieve_id_array
-          if !id_array.include? record_id
-            new_id_list = (id_array << record_id).join(',')
-            reverse_index_record.update(:id_list => new_id_list)
+    def self.remove_index_id(model_name, object_id)
+      index_records = ReverseIndex.where(:model_name => model_name)
+      if index_records.count > 0
+        index_records.each do |record|
+          if record.id_list.match(/#{object_id},{0,1}/)
+            current_id_array = record.retrieve_id_array
+            if current_id_array.delete(object_id)
+              if current_id_array.empty?
+                record.destroy
+              else
+                new_id_list = current_id_array.join(',')
+                record.update(:id_list => new_id_list)
+              end
+            end
           end
-        else
-          ReverseIndex.create(:model_name => model_name, :word => word, :id_list => record_id)
         end
       end
-      self.clean_reverse_index(model_name, record_id, forward_index) if cleaning_required
     end
 
-    # Removes an object id from the reverse index for a specified model.
-    # If the id array is empty after removing the record id, destroys the reverse index record
-    # 
-    # ==== Parameters
-    # 
-    # model_name: string version of the model name to remove records for
-    # record_id: object id to remove records for
-
-    def self.remove_from_reverse_index(model_name, record_id)
-      reverse_index_records = ReverseIndex.where(:model_name => model_name)
-      reverse_index_records.each do |rir|
-        id_array = rir.retrieve_id_array
-        if id_array.include? record_id.to_i
-          id_array.delete(record_id.to_i)
-          if id_array.empty?
-            rir.destroy
-          else
-            rir.update(:id_list => id_array.join(','))
+    def self.repair_index(model_name, object_id, field_name, forward_index)
+      index_records = ReverseIndex.where(:model_name => model_name, :field_name => field_name)
+      if index_records.count > 0
+        index_records.each do |record|
+          if record.id_list.match(/#{object_id},{0,1}/)
+            unless forward_index.include?(record.word)
+              current_id_array = record.retrieve_id_array
+              if current_id_array.delete(object_id)
+                if current_id_array.empty?
+                  record.destroy
+                else
+                  new_id_list = current_id_array.join(',')
+                  record.update(:id_list => new_id_list)
+                end
+              end
+            end
           end
         end
       end
     end
-
   end
 
+  module Stopwords
+    STOPWORDS = [
+      "a",
+      "about",
+      "above",
+      "after",
+      "again",
+      "against",
+      "all",
+      "am",
+      "an",
+      "and",
+      "any",
+      "are",
+      "aren't",
+      "as",
+      "at",
+      "be",
+      "because",
+      "been",
+      "before",
+      "being",
+      "below",
+      "between",
+      "both",
+      "but",
+      "by",
+      "can't",
+      "cannot",
+      "could",
+      "couldn't",
+      "did",
+      "didn't",
+      "do",
+      "does",
+      "doesn't",
+      "doing",
+      "don't",
+      "down",
+      "during",
+      "each",
+      "few",
+      "for",
+      "from",
+      "further",
+      "had",
+      "hadn't",
+      "has",
+      "hasn't",
+      "have",
+      "haven't",
+      "having",
+      "he",
+      "he'd",
+      "he'll",
+      "he's",
+      "her",
+      "here",
+      "here's",
+      "hers",
+      "herself",
+      "him",
+      "himself",
+      "his",
+      "how",
+      "how's",
+      "i",
+      "i'd",
+      "i'll",
+      "i'm",
+      "i've",
+      "if",
+      "in",
+      "into",
+      "is",
+      "isn't",
+      "it",
+      "it's",
+      "its",
+      "itself",
+      "let's",
+      "me",
+      "more",
+      "most",
+      "mustn't",
+      "my",
+      "myself",
+      "no",
+      "nor",
+      "not",
+      "of",
+      "off",
+      "on",
+      "once",
+      "only",
+      "or",
+      "other",
+      "ought",
+      "our",
+      "ours",
+      "ourselves",
+      "out",
+      "over",
+      "own",
+      "same",
+      "shan't",
+      "she",
+      "she'd",
+      "she'll",
+      "she's",
+      "should",
+      "shouldn't",
+      "so",
+      "some",
+      "such",
+      "than",
+      "that",
+      "that's",
+      "the",
+      "their",
+      "theirs",
+      "them",
+      "themselves",
+      "then",
+      "there",
+      "there's",
+      "these",
+      "they",
+      "they'd",
+      "they'll",
+      "they're",
+      "they've",
+      "this",
+      "those",
+      "through",
+      "to",
+      "too",
+      "under",
+      "until",
+      "up",
+      "very",
+      "was",
+      "wasn't",
+      "we",
+      "we'd",
+      "we'll",
+      "we're",
+      "we've",
+      "were",
+      "weren't",
+      "what",
+      "what's",
+      "when",
+      "when's",
+      "where",
+      "where's",
+      "which",
+      "while",
+      "who",
+      "who's",
+      "whom",
+      "why",
+      "why's",
+      "with",
+      "won't",
+      "would",
+      "wouldn't",
+      "you",
+      "you'd",
+      "you'll",
+      "you're",
+      "you've",
+      "your",
+      "yours",
+      "yourself",
+      "yourselves"
+    ]
+  end
 end

data/lib/ar_indexer/reverse_index.rb

@@ -1,25 +1,15 @@
 module ARIndexer
-
   class ReverseIndex < ::ActiveRecord::Base
-
     if ::ActiveRecord::VERSION::MAJOR < 4
-      attr_accessible :id_list, :model_name, :word
+      attr_accessible :model_name, :field_name, :word, :id_list
     end
 
-    validates_uniqueness_of :word, :scope => :model_name
-
-    # Retrieves the id_list property as a parsed array of integers
-    # 
-    # ==== Returns
-    # 
-    # array of integer
+    validates_uniqueness_of :word, :scope => [:model_name, :field_name]
 
     def retrieve_id_array
       id_array = self.id_list.split(',')
       id_array.map! {|id| id.to_i}
       return id_array
     end
-
   end
-
 end

data/lib/ar_indexer.rb

@@ -1,21 +1,26 @@
+# Require runtime dependencies
 require 'active_record'
 require 'active_support'
 require 'active_support/inflector'
 require 'htmlentities'
 require 'fast-stemmer'
 
+# Require gem files
 require 'ar_indexer/reverse_index'
 require 'ar_indexer/has_reverse_index'
-require 'ar_indexer/stopwords'
 require 'ar_indexer/indexer'
 require 'ar_indexer/index_search'
 
 # Main gem module
-
 module ARIndexer
+  # Gem version storage
+  module Version
+    MAJOR = '0'
+    MINOR = '2'
+    BUILD = '0'
 
-  VERSION = "0.1.2"
-
+    STRING = "#{MAJOR}.#{MINOR}.#{BUILD}"
+  end
 end
 
 include ARIndexer

metadata

@@ -1,79 +1,79 @@
 --- !ruby/object:Gem::Specification
 name: ar_indexer
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
-- Josh Stump
+- Josh MacLachlan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-18 00:00:00.000000000 Z
+date: 2014-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: htmlentities
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: fast-stemmer
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Allows for reverse indexing selected ActiveRecord models. Handles searching
   and return of objects
-email: joshua.t.stump@gmail.com
+email: josh.t.maclachlan@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - LICENSE
 - README.md
@@ -83,28 +83,29 @@ files:
 - lib/ar_indexer/index_search.rb
 - lib/ar_indexer/indexer.rb
 - lib/ar_indexer/reverse_index.rb
-- lib/ar_indexer/stopwords.rb
-homepage: https://github.com/jstump/ar_indexer
+homepage: https://github.com/jtmaclachlan/ar_indexer
 licenses:
 - GPL-2
 metadata: {}
-post_install_message: 
+post_install_message: If you're upgrading from v0.1.4 to v0.2.0, read the updated
+  documentation. Your application will throw exceptions when trying to access indexed
+  models.
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.6
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Allows for reverse indexing selected ActiveRecord models. Handles searching

data/lib/ar_indexer/stopwords.rb

@@ -1,186 +0,0 @@
-module ARIndexer
-
-  # Contains array of stopwords that should not be stopwords
-
-  module Stopwords
-
-    STOPWORDS = [
-      "a",
-      "about",
-      "above",
-      "after",
-      "again",
-      "against",
-      "all",
-      "am",
-      "an",
-      "and",
-      "any",
-      "are",
-      "aren't",
-      "as",
-      "at",
-      "be",
-      "because",
-      "been",
-      "before",
-      "being",
-      "below",
-      "between",
-      "both",
-      "but",
-      "by",
-      "can't",
-      "cannot",
-      "could",
-      "couldn't",
-      "did",
-      "didn't",
-      "do",
-      "does",
-      "doesn't",
-      "doing",
-      "don't",
-      "down",
-      "during",
-      "each",
-      "few",
-      "for",
-      "from",
-      "further",
-      "had",
-      "hadn't",
-      "has",
-      "hasn't",
-      "have",
-      "haven't",
-      "having",
-      "he",
-      "he'd",
-      "he'll",
-      "he's",
-      "her",
-      "here",
-      "here's",
-      "hers",
-      "herself",
-      "him",
-      "himself",
-      "his",
-      "how",
-      "how's",
-      "i",
-      "i'd",
-      "i'll",
-      "i'm",
-      "i've",
-      "if",
-      "in",
-      "into",
-      "is",
-      "isn't",
-      "it",
-      "it's",
-      "its",
-      "itself",
-      "let's",
-      "me",
-      "more",
-      "most",
-      "mustn't",
-      "my",
-      "myself",
-      "no",
-      "nor",
-      "not",
-      "of",
-      "off",
-      "on",
-      "once",
-      "only",
-      "or",
-      "other",
-      "ought",
-      "our",
-      "ours",
-      "ourselves",
-      "out",
-      "over",
-      "own",
-      "same",
-      "shan't",
-      "she",
-      "she'd",
-      "she'll",
-      "she's",
-      "should",
-      "shouldn't",
-      "so",
-      "some",
-      "such",
-      "than",
-      "that",
-      "that's",
-      "the",
-      "their",
-      "theirs",
-      "them",
-      "themselves",
-      "then",
-      "there",
-      "there's",
-      "these",
-      "they",
-      "they'd",
-      "they'll",
-      "they're",
-      "they've",
-      "this",
-      "those",
-      "through",
-      "to",
-      "too",
-      "under",
-      "until",
-      "up",
-      "very",
-      "was",
-      "wasn't",
-      "we",
-      "we'd",
-      "we'll",
-      "we're",
-      "we've",
-      "were",
-      "weren't",
-      "what",
-      "what's",
-      "when",
-      "when's",
-      "where",
-      "where's",
-      "which",
-      "while",
-      "who",
-      "who's",
-      "whom",
-      "why",
-      "why's",
-      "with",
-      "won't",
-      "would",
-      "wouldn't",
-      "you",
-      "you'd",
-      "you'll",
-      "you're",
-      "you've",
-      "your",
-      "yours",
-      "yourself",
-      "yourselves"
-    ]
-
-  end
-
-end