ar_indexer 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e7c29be1f921a9f40f47975390cd2658ef90eb91
-  data.tar.gz: 727458d961183a7e364d625085fa29dc6a7b97ee
+  metadata.gz: 7445f0b1bc4e4b69f743a0a5c8a613c3bda4db9e
+  data.tar.gz: 0ef7910bb47cef64066030952a9d876cdbf967f0
 SHA512:
-  metadata.gz: bce0e4fccb1de8992adab38ee2b81957cf76004f9c7d3c396744c4eb81e385149aef13ac7463453aaaea8b5b15ed039f26561f70f2cdf4582009c6be8729a2af
-  data.tar.gz: 8f2ca453649095cdca6d52dcf862e2c54dae0b3cc8cd4ebee86f985b3309d69cbdfc8ea85dd439ec617044d49317ef91379715e91d30464839888976b2b563d8
+  metadata.gz: e303a490b0f237c7c8bbe33e130b1fff20cac94d7a73ee48f26e4c3e3b9a45980a103cbd98001bd120894c2ec7ea7c7241602a21e8e300bfbf8d07f245c09dbe
+  data.tar.gz: e1eea6aab30a108f8adf68ca8dba8590b4b8e8b4fe4b5a4b9f429f094590aabf5e7fbd2c746ce26ee90c85cf3e5842d22c89434ee6283913a31e7325c6cbbded

data/README.md

@@ -1,43 +1,50 @@
-#ARIndexer#
+# ARIndexer
 
 [![Gem Version](https://badge.fury.io/rb/ar_indexer.svg)](http://badge.fury.io/rb/ar_indexer)
 
 ARIndexer provides basic indexing and text search for ActiveRecord models. You choose which fields to index per model, and the index is automatically generated/updated on create/edit.
 
-##Installation##
+## Installation
 
 Add ARIndexer to your Gemfile
-    
-    gem 'ar_indexer'
+
+```ruby
+gem 'ar_indexer'
+```
 
 Write a migration to add a reverse_indices table to the database (Rails migration generator coming soon). Due to an exception encountered in Rails 4.2 (DangerousAttributes exception), the model\_name column has been renamed to model\_constant.
 
-    class CreateReverseIndices < ActiveRecord::Migration
-      def change
-        create_table :reverse_indices do |t|
-          t.string :model_constant
-          t.string :field_name
-          t.string :word
-          t.text :id_list
-        end
-        add_index :reverse_indices, [:model_constant, :field_name, :word], :unique => true
-      end
+```ruby
+class CreateReverseIndices < ActiveRecord::Migration
+  def change
+    create_table :reverse_indices do |t|
+      t.string :model_constant
+      t.string :field_name
+      t.string :word
+      t.text :id_list
     end
 
+    add_index :reverse_indices, [:model_constant, :field_name, :word], :unique => true
+  end
+end
+```
+
 Run `rake db:migrate`
 
-##Usage##
+## Usage
 
-###Indexing###
+### 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 hash of configuration values to customize which fields and associations are indexed, and how often each type of "field" are indexed. The default hash is below, and will be merged with the hash you pass in.
 
-    ari_configuration = {
-      fields: [],
-      associations: {},
-      index_on_create: [],
-      index_on_update: []
-    }
+```ruby
+ari_configuration = {
+  fields: [],
+  associations: {},
+  index_on_create: [],
+  index_on_update: []
+}
+```
 
 To expand on the above configuration:
 * fields: If empty, will index all String and Text fields of the AR model. Pass an array of `Symbol` field names to only index the whitelisted fields
@@ -46,98 +53,111 @@ To expand on the above configuration:
 * index_on_update: If empty, will index both fields and associations as an after_update function. Add `:fields` and/or `:associations` to the array to control which are automatically indexed.
 
 Below is an example configuration hash passed for an example `Article` model, which has a collection of `Tag` objects. In this example, we've chosen to only automatically index the fields, sometimes necessary when an AR object needs to have `reload` called on it to make sure associations are up to date. Include as many or as few options as you need.
-    
-    {
-      fields: [:title, :subtitle, :content],
-      associations: {
-        tags: lambda {|object| object.tags.collect{|tag| tag.name}.join(', ')}
-      },
-      index_on_create: [:fields],
-      index_on_update: [:fields]
-    }
-
-Now let's see some examples in the models:
 
-    class Post < ActiveRecord::Base
-      has_reverse_index
-    end
+```ruby
+{
+  fields: [:title, :subtitle, :content],
+  associations: {
+    tags: lambda {|object| object.tags.collect{|tag| tag.name}.join(', ')}
+  },
+  index_on_create: [:fields],
+  index_on_update: [:fields]
+}
+```
 
-    class Article < ActiveRecord::Base
-      has_reverse_index({
-        fields: [:title, :content]
-      })
-    end
+Now let's see some examples in the models:
 
-    class Article < ActiveRecord::Base
-      has_many :article_tags
-      has_many :tags, :through => :article_tags
-      has_reverse_index({
-        fields: [:title, :content],
-        associations: {
-          tags: lambda {|object| object.tags.collect{|tag| tag.name}.join(', ')}
-        }
-      })
-    end
+```ruby
+class Post < ActiveRecord::Base
+  has_reverse_index
+end
+
+class Article < ActiveRecord::Base
+  has_reverse_index(
+    fields: [:title, :content]
+  )
+end
+
+class Article < ActiveRecord::Base
+  has_many :article_tags
+  has_many :tags, :through => :article_tags
+  has_reverse_index(
+    fields: [:title, :content],
+    associations: {
+      tags: lambda {|object| object.tags.collect{|tag| tag.name}.join(', ')}
+    }
+  )
+end
+```
 
 At this point, ARIndexer will build and maintain a reverse index for each record under these models. If you need to reindex the object at any time, the instance methods `index_object`, `index_fields`, and `index_associations` are added to all ActiveRecord objects with `has_reverse_index` declared.
 
-###Searching###
+### Searching
 
 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])
-    # Or search multiple models
-    # foo = IndexSearch.new([Article, List])
+```ruby
+foo = IndexSearch.new([Article])
+# Or search multiple models
+# foo = IndexSearch.new([Article, List])
+```
 
 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.
-      # Pass a proc that takes the AR object to access a sortable value
-      # Pass the symbol of the field name you want to access to just pull 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
-    }
+```ruby
+@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.
+  # Pass a proc that takes the AR object to access a sortable value
+  # Pass the symbol of the field name you want to access to just pull the field value
 
-    foo = IndexSearch.new([Article],
-      {
-        :fields => [:title],
-        :match => :all,
-        :sort => :field,
-        :sort_direction => :asc,
-        :no_results_message => "Hey man, there's nothing there."
-      }
-    )
+  :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.search('some search string')
+```ruby
+foo.search('some search string')
+```
 
 `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?
-      # Do stuff with your results
-    else
-      puts foo.no_results_message    #=> Hey man, there's nothing there.
-    end
+```ruby
+results = foo.run_search('some search string')
+unless results.empty?
+  # Do stuff with your results
+else
+  puts foo.no_results_message    #=> Hey man, there's nothing there.
+end
+```

data/ar_indexer.gemspec

@@ -1,8 +1,8 @@
 Gem::Specification.new do |spec|
   # Basic Gem Description
   spec.name          = "ar_indexer"
-  spec.version       = "0.3.1"
-  spec.date          = "2015-02-05"
+  spec.version       = "0.3.2"
+  spec.date          = "2018-11-21"
   spec.summary       = "Allows for reverse indexing selected ActiveRecord models. Handles searching and return of objects"
   spec.description   = spec.summary
   spec.authors       = ["Josh MacLachlan"]
@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.files         = `git ls-files`.split("\n")
   spec.license       = "GPL-2"
-  
+
   # Runtime Dependencies
   spec.add_dependency('activerecord', '>= 3.0.0')
   spec.add_dependency('activesupport', '>= 3.0.0')

data/lib/ar_indexer/has_reverse_index.rb

@@ -5,12 +5,13 @@ module ARIndexer
     end
 
     module ClassMethods
-      def has_reverse_index(indexing_opts = {})
+      def has_reverse_index(**indexing_opts)
         if indexing_opts.nil?
           indexing_opts = {}
         end
 
         fields = indexing_opts[:fields] || []
+
         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)
@@ -20,8 +21,9 @@ module ARIndexer
         end
 
         associations = indexing_opts[:associations] || {}
+
         associations.each do |association_name, access_function|
-          unless access_function.class == Proc
+          unless access_function.is_a?(Proc)
             raise TypeError, 'Model associations must have a Proc provided in order to reach the appropriate value.'
           end
         end
@@ -29,6 +31,7 @@ module ARIndexer
         send :include, InstanceMethods
 
         class_attribute :ari_configuration
+
         self.ari_configuration = {
           fields: [],
           associations: {},
@@ -40,27 +43,29 @@ module ARIndexer
         after_update :ar_indexer_on_update
         before_destroy :ar_indexer_on_destroy
       end
+
       module_function :has_reverse_index
 
       module InstanceMethods
         def index_object(cleanup = false)
           values_to_index = ar_indexer_get_indexable_values
+
           values_to_index.each do |field_name, value|
             Indexer.index_string(self.class.to_s.split('::').last, self.id, field_name, value, cleanup)
           end
         end
-        
+
         def index_fields(cleanup = false)
-          values_to_index = ar_indexer_get_indexable_values
-          values_to_index.delete_if {|key, value| self.ari_configuration[:associations].keys.map{|field| field.to_s}.include?(key)}
+          values_to_index = ar_indexer_get_indexable_values([:fields])
+
           values_to_index.each do |field_name, value|
             Indexer.index_string(self.class.to_s.split('::').last, self.id, field_name, value, cleanup)
           end
         end
 
         def index_associations(cleanup = false)
-          values_to_index = ar_indexer_get_indexable_values
-          values_to_index.delete_if {|key, value| self.ari_configuration[:fields].map{|field| field.to_s}.include?(key)}
+          values_to_index = ar_indexer_get_indexable_values([:associations])
+
           values_to_index.each do |field_name, value|
             Indexer.index_string(self.class.to_s.split('::').last, self.id, field_name, value, cleanup)
           end
@@ -68,38 +73,21 @@ module ARIndexer
 
         private
 
-        def ar_indexer_get_indexable_values
+        def ar_indexer_get_indexable_values(index = [:fields, :associations])
           values_to_index = {}
-          
-          if self.class.ari_configuration[:fields].empty?
-            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.class.ari_configuration[: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
+
+          if index.include?(:fields)
+            ari_fields = self.class.ari_configuration[:fields].map{|f| f.to_s}
+            indexed_columns = self.class.ari_configuration[:fields].empty? ? self.class.column_names : (self.class.column_names & ari_fields)
+            values_to_index.merge!(ar_indexer_gather_column_values(indexed_columns))
           end
 
-          unless self.class.ari_configuration[:associations].empty?
+          if index.include?(:associations) and !self.class.ari_configuration[:associations].empty?
             self.class.ari_configuration[: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
+
+              if value.is_a?(String)
+                values_to_index[association_name.to_s] = value unless value.empty?
               end
             end
           end
@@ -107,31 +95,39 @@ module ARIndexer
           return values_to_index
         end
 
+        def ar_indexer_gather_column_values(columns)
+          column_values = {}
+
+          columns.each do |column|
+            value = self.read_attribute(column)
+
+            if value.is_a?(String)
+              column_values[column] = value unless value.empty?
+            end
+          end
+
+          return column_values
+        end
+
         def ar_indexer_on_create
           to_index = self.class.ari_configuration[:index_on_create]
+
           if to_index == []
             self.index_object(false)
           else
-            if to_index.include? :fields
-              self.index_fields(false)
-            end
-            if to_index.include? :associations
-              self.index_associations(false)
-            end
+            self.index_fields(false) if to_index.include? :fields
+            self.index_associations(false) if to_index.include? :associations
           end
         end
 
         def ar_indexer_on_update
           to_index = self.class.ari_configuration[:index_on_update]
+
           if to_index == []
             self.index_object(true)
           else
-            if to_index.include? :fields
-              self.index_fields(true)
-            end
-            if to_index.include? :associations
-              self.index_associations(true)
-            end
+            self.index_fields(true) if to_index.include? :fields
+            self.index_associations(true) if to_index.include? :associations
           end
         end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ar_indexer
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Josh MacLachlan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-05 00:00:00.000000000 Z
+date: 2018-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -104,7 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.2.3
 signing_key: 
 specification_version: 4
 summary: Allows for reverse indexing selected ActiveRecord models. Handles searching