ar_indexer 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8dd86c184c032a0b0781f6729fa63fdbf7bb4f7b
-  data.tar.gz: d3b65442cb95b6cc32d2cf37439804780c49d49d
+  metadata.gz: a949f827bc86002e7bb7241edb513fbe452b51ca
+  data.tar.gz: e04f080e7cd9be0fa8dfb552578cac54c079de7d
 SHA512:
-  metadata.gz: 9d8c95d4d341b21e2a7d7c0c4d69eb9975a595e4a5a7c12cb3b751c460d6b194eb6ec5b2de47ac2860ef1000b36a539f88fddbc59babcd5c78392c5269717506
-  data.tar.gz: 541319aa5471dd282106290e88a161ee80c865b84dab6221ec832c245dc7796c43d7c99ea37d385246aa7cb73926b1d7abd30af4cb001f0e1ffc132517ab7c1e
+  metadata.gz: f5841ed351d64accee8237245a8ce732aa2784ba32f3189f3dd1f36c2467f25859d8b08edc674b2291be487ff4799fcc7d5dbdf527ecb63a6261c120fa889459
+  data.tar.gz: 930f41e303645f21a73aa061f0557a742ad464af9568285befb81fd2eca1961eb9ebe2f2a550ead28a35b7fad538853fb7c793c753773af33c7ffcc380fe35f8

data/README.md

@@ -41,13 +41,15 @@ At this point, ARIndexer will build and maintain a reverse index for each record
 
 ###Searching###
 
-ARIndexer also provides a simple search class for finding records by text search. To initialize an instance of this class, just pass it the ActiveRecord model it needs to search.
+ARIndexer also provides a simple search class for finding records by text search. To initialize an instance of this class, just pass it an array of ActiveRecord models it needs to search.
 
-    foo = IndexSearch.new(Article)
+    foo = IndexSearch.new([Article])
+    # 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.")
+    foo = IndexSearch.new([Article], :no_results_message => "Hey man, there's nothing there.")
 
 And now you're ready to search against the index that's been built.
 

data/ar_indexer.gemspec

@@ -1,18 +1,18 @@
 Gem::Specification.new do |spec|
-	spec.name           = "ar_indexer"
-	spec.version        = "0.1.2"
-	spec.date           = "2013-10-25"
-	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"
-	
-	spec.add_dependency('activerecord')
-	spec.add_dependency('activesupport')
-	spec.add_dependency('htmlentities')
-	spec.add_dependency('fast-stemmer')
+  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"
+  
+  spec.add_dependency('activerecord')
+  spec.add_dependency('activesupport')
+  spec.add_dependency('htmlentities')
+  spec.add_dependency('fast-stemmer')
 end

data/lib/ar_indexer.rb

@@ -1,19 +1,20 @@
-# Requires for gem dependencies
 require 'active_record'
 require 'active_support'
 require 'active_support/inflector'
 require 'htmlentities'
 require 'fast-stemmer'
-# 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
 
-	VERSION = "0.1.2"
+  VERSION = "0.1.2"
 
 end
 

data/lib/ar_indexer/has_reverse_index.rb

@@ -1,70 +1,100 @@
 module ARIndexer
 
-	module Model
-
-		def self.included(base)
-			base.send :extend, ClassMethods
-		end
-
-		module ClassMethods
-
-			def has_reverse_index(fields = [])
-				send :include, InstanceMethods
-
-				class_attribute :indexed_fields
-				self.indexed_fields = fields.dup
-
-				after_create :on_create_record
-				after_update :on_update_record
-				before_destroy :on_destroy_record
-			end
-			module_function :has_reverse_index
-
-			module InstanceMethods
-
-				private
-
-				def array_of_values_to_index
-					values_for_indexing = []
-					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)
-							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)
-							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)
-					end
-				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)
-					end
-				end
-
-				def on_destroy_record
-					Indexer.remove_from_reverse_index(self.class.to_s.split('::').last.to_s, self.id)
-				end
-
-			end
-
-		end
-
-	end
+  # 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
+
+      # 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
+
+      def has_reverse_index(fields = [])
+        send :include, InstanceMethods
+
+        class_attribute :indexed_fields
+        self.indexed_fields = fields.dup
+
+        after_create :on_create_record
+        after_update :on_update_record
+        before_destroy :on_destroy_record
+      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 = []
+          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)
+              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)
+              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)
+          end
+        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)
+          end
+        end
+
+        def on_destroy_record
+          Indexer.remove_from_reverse_index(self.class.to_s.split('::').last.to_s, self.id)
+        end
+
+      end
+
+    end
+
+  end
 
 end

data/lib/ar_indexer/index_search.rb

@@ -1,47 +1,101 @@
 module ARIndexer
 
-	class IndexSearch
-
-		def initialize(model_name, opts = {})
-			@model_name = model_name.to_s.split('::').last
-			@model_class = @model_name.constantize
-
-			@options = {
-				:no_results_message => "Your #{@model_name} search returned no results."
-			}
-
-			@options.merge!(opts)
-		end
-
-		def no_results_message
-			return @options[:no_results_message]
-		end
-
-		def run_search(search_string)
-			search_terms = Indexer.text_to_lexicon(search_string)
-			match_counts = {}
-			search_terms.each do |st|
-				if reverse_index_record = ReverseIndex.where(:model_name => @model_name, :word => st).first
-					reverse_index_record.retrieve_id_array.each do |id|
-						if match_counts.has_key?(id)
-							match_counts[id] = match_counts[id] + 1
-						else
-							match_counts[id] = 1
-						end
-					end
-				end
-			end
-			unless match_counts.empty?
-				objects_to_return = []
-				match_counts.to_a.sort{|x,y| x[1] <=> y[1]}.collect{|x| x[0]}.reverse.each do |id|
-					objects_to_return << @model_class.find(id)
-				end
-				return objects_to_return
-			else
-				return []
-			end
-		end
-
-	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
+
+  class IndexSearch
+
+    def initialize(model_names, opts = {})
+      @models = {}
+      model_names.each do |model|
+        @models[model.to_s.split('::').last] = model
+      end
+      puts @models
+
+      @options = {
+        :no_results_message => "Your #{@model_name} search returned no results."
+      }
+
+      @options.merge!(opts)
+    end
+
+    # Returns either the default :no_results_message, or the one specified on initialization
+    # 
+    # ==== Returns
+    # 
+    # string
+
+    def no_results_message
+      return @options[:no_results_message]
+    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] = {}
+      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
+              else
+                matches[rir.model_name][id] = 1
+              end
+            end
+          end
+        end
+      end
+      collected_matches = []
+      matches.each do |k,v|
+        unless v.empty?
+          collected_matches << v.to_a.map{|x| x << k}
+        end
+      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
+        return objects_to_return
+      else
+        return []
+      end
+    end
+
+  end
 
 end

data/lib/ar_indexer/indexer.rb

@@ -1,111 +1,162 @@
 module ARIndexer
 
-	module Indexer
-
-		def self.text_to_lexicon(text)
-			# Replace any HTML tag with a space
-			text.gsub!(/<[^>]+>/, ' ')
-			# Decode HTML entities
-			coder = HTMLEntities.new
-			text = coder.decode(text)
-			# Perform the initial split on spaces
-			lexicon = text.split(/\s+/)
-			# Drop any words that include no letters or numbers
-			lexicon.delete_if {|word| word.match(/^[^\w\d]+$/)}
-			# Clean up each array entry
-			lexicon.each do |word|
-				# Shift everything to lower case
-				word.downcase!
-				# Remove beginning and ending punctuation
-				word.gsub!(/(^[^a-z0-9]+|[^a-z0-9]+$)/, '')
-			end
-			# Remove stopwords and take only the unique entries
-			lexicon = (lexicon - Stopwords::STOPWORDS).uniq
-			# Make a pass at obtaining additional words for matching
-			lexicon.each do |word|
-				lexicon = lexicon.inject([word.gsub(/'/, ''), word.gsub(/'.+$/, '')], :<<) if word.match(/'/)
-				if word.match(/[\-_\|\/]/)
-					lexicon = lexicon.inject([word.split(/[\-_\|\/@\.]/)], :<<)
-				end
-				stem = Stemmer.stem_word(word)
-				if stem != word && !stem.match(/[^a-z0-9]$/)
-					lexicon = lexicon.inject([stem], :<<)
-				end
-				plural = word.pluralize
-				if plural != word
-					lexicon = lexicon.inject([plural], :<<)
-				end
-			end
-			# Flatten any new arrays gained by splitting words
-			lexicon = lexicon.flatten
-			# Remove stopwords and take only the unique entries
-			lexicon = (lexicon - Stopwords::STOPWORDS).uniq
-			# Drop any entries shorter than 2 characters
-			lexicon.delete_if {|word| word.length < 2}
-			# Return the lexicon array
-			return lexicon
-		end
-
-		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
-			return forward_index
-		end
-
-		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
-					end
-				end
-			end
-		end
-
-		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)
-					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
-
-		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(','))
-					end
-				end
-			end
-		end
-
-	end
+  # 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)
+      # Remove HTML markup
+      text.gsub!(/<[^>]+>/, ' ')
+      # Decode HTML entities
+      coder = HTMLEntities.new
+      text = coder.decode(text)
+      # Remove most punctuation
+      text.gsub!(/[^a-zA-Z0-9\s]/, '')
+      # Move everything to lower case
+      text.downcase!
+      # Split all words into an array
+      lexicon = text.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
+      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
+          end
+        end
+      end
+    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)
+          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(','))
+          end
+        end
+      end
+    end
+
+  end
 
 end

data/lib/ar_indexer/reverse_index.rb

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

@@ -1,184 +1,186 @@
 module ARIndexer
 
-	module Stopwords
+  # Contains array of stopwords that should not be 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"
-		]
+  module Stopwords
 
-	end
+    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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ar_indexer
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Josh Stump
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-25 00:00:00.000000000 Z
+date: 2014-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord