algoliasearch-rails 1.7.0 → 1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 740b9ffd93cd8537e849d5ca75dcbee77dfdd153
-  data.tar.gz: 39d3828d7d048d426bbc8f7964d5f3edadaf6218
+  metadata.gz: 2aa68e2724bc3f0c7b43545b8d5156ae476acfde
+  data.tar.gz: 4e3d1a69ce8cff145fc91b69f845cb2c38bde8bb
 SHA512:
-  metadata.gz: 5c0ef9db00ed0db52a436039e601c91a0cef33f884c7be3cc515c4acc5aca271dc2e1daa99b2d8fdc30f57d0da5d7a830ca8102f28f9e5e846a6f1c3b3ea8f3d
-  data.tar.gz: a32a694f54c5f5e20a6e2dd8b87492d246eba261fb480882e46ec458bfe34d750a81fc7707d37231d90a07a087c5e0e10d4413b6ca32393de0428c9b452b7f85
+  metadata.gz: 7e685c99823cb8f047b1bfd8d390a5b2a535df639586f6e7e8d92fe5eb60b546370f2697bfbc07a3afbfc067195ec23ad7b81a17645699ac93b974dbb2331811
+  data.tar.gz: bf4848ce707351534dbe3fe03f952419a721a3ce4e37b7ecaf84c90c574721a1edae0373ec74eab936bf0146ee267fbbcc700a84eefeb13e02a1d1f7b3dce916

data/ChangeLog

@@ -1,5 +1,10 @@
 CHANGELOG
 
+2014-01-31  1.7.1
+
+      * Ensure methods are not conflicting with already defined ones (use algolia_METHOD_NAME)
+      * Add ```:if``` and ```:unless``` options to control objects indexing
+
 2014-01-07  1.7.0
 
       * Updated algoliasearch to 1.2 (httpclient instead of curb as underlying HTTP layer)

data/Gemfile

@@ -7,7 +7,10 @@ gem 'rubysl', '~> 2.0', platform: :rbx
 group :test do 
   gem 'rspec', '>= 2.5.0'
   gem 'activerecord', '>= 3.0.7'
-  gem 'sqlite3'
+  gem 'sqlite3', platform: [:rbx, :ruby]
+  gem 'jdbc-sqlite3', platform: :jruby
+  gem 'activerecord-jdbc-adapter', platform: :jruby
+  gem 'activerecord-jdbcsqlite3-adapter', platform: :jruby
   gem 'autotest'
   gem 'autotest-fsevent'
   gem 'redgreen'

data/Gemfile.lock

@@ -17,6 +17,11 @@ GEM
       activesupport (= 4.0.2)
       arel (~> 4.0.0)
     activerecord-deprecated_finders (1.0.3)
+    activerecord-jdbc-adapter (1.3.4)
+      activerecord (>= 2.2)
+    activerecord-jdbcsqlite3-adapter (1.3.4)
+      activerecord-jdbc-adapter (~> 1.3.4)
+      jdbc-sqlite3 (~> 3.7.2)
     activesupport (4.0.2)
       i18n (~> 0.6, >= 0.6.4)
       minitest (~> 4.2)
@@ -29,12 +34,13 @@ GEM
       json (>= 1.5.1)
     arel (4.0.1)
     atomic (1.1.14)
+    atomic (1.1.14-java)
     autotest (4.4.6)
       ZenTest (>= 4.4.1)
     autotest-fsevent (0.2.9)
       sys-uname
     autotest-growl (0.2.16)
-    backports (3.3.5)
+    backports (3.4.0)
     builder (3.1.4)
     coderay (1.1.0)
     diff-lcs (1.2.5)
@@ -47,6 +53,7 @@ GEM
     faraday_middleware (0.9.0)
       faraday (>= 0.7.4, < 0.9)
     ffi (1.9.3)
+    ffi (1.9.3-java)
     ffi2-generators (0.1.1)
     gh (0.13.0)
       addressable
@@ -58,7 +65,9 @@ GEM
     highline (1.6.20)
     httpclient (2.3.4.1)
     i18n (0.6.9)
+    jdbc-sqlite3 (3.7.2.1)
     json (1.8.1)
+    json (1.8.1-java)
     kaminari (0.15.0)
       actionpack (>= 3.0.0)
       activesupport (>= 3.0.0)
@@ -75,6 +84,11 @@ GEM
       coderay (~> 1.0)
       method_source (~> 0.8)
       slop (~> 3.4)
+    pry (0.9.12.4-java)
+      coderay (~> 1.0)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+      spoon (~> 0.0)
     pusher-client (0.4.0)
       websocket (~> 1.0.0)
     rack (1.5.2)
@@ -295,11 +309,15 @@ GEM
     rubysl-yaml (2.0.4)
     rubysl-zlib (2.0.1)
     slop (3.4.7)
+    spoon (0.0.4)
+      ffi
     sqlite3 (1.3.8)
     sys-uname (0.9.2)
       ffi (>= 1.0.0)
     thread_safe (0.1.3)
       atomic
+    thread_safe (0.1.3-java)
+      atomic
     travis (1.6.6)
       addressable (~> 2.3)
       backports
@@ -318,14 +336,18 @@ GEM
     will_paginate (3.0.5)
 
 PLATFORMS
+  java
   ruby
 
 DEPENDENCIES
   activerecord (>= 3.0.7)
+  activerecord-jdbc-adapter
+  activerecord-jdbcsqlite3-adapter
   algoliasearch (~> 1.2)
   autotest
   autotest-fsevent
   autotest-growl
+  jdbc-sqlite3
   json (>= 1.5.1)
   kaminari
   rake

data/README.md

@@ -16,6 +16,7 @@ Table of Content
 1. [Setup](#setup)
 1. [Quick Start](#quick-start)
 1. [Options](#options)
+1. [Configuration example](#configuration-example)
 1. [Indexing](#indexing)
 1. [Tags](#tags)
 1. [Geo-search](#geo-search)
@@ -105,6 +106,14 @@ end
 p Contact.search("jon doe")
 ```
 
+**Notes:** All methods injected by the ```AlgoliaSearch``` include are prefixed by ```algolia_``` and aliased to the associated short names if they aren't already defined.
+
+```ruby
+Contact.algolia_reindex! # <=> Contact.reindex!
+
+Contact.algolia_search("jon doe") # <=> Contact.search("jon doe")
+```
+
 Options
 ----------
 
@@ -194,6 +203,90 @@ class UniqUser < ActiveRecord::Base
 end
 ```
 
+You can add constraints controlling if a record must be indexed by using options the ```:if``` or ```:unless``` options.
+
+```ruby
+class Post < ActiveRecord::Base
+  include AlgoliaSearch
+
+  algoliasearch if: :published?, unless: :deleted? do
+  end
+
+  def published?
+    # [...]
+  end
+
+  def deleted?
+    # [...]
+  end
+end
+```
+
+Configuration example
+---------------------
+
+Here is a real-word configuration example (from [HN Search](https://github.com/algolia/hn-search)):
+
+```ruby
+class Item < ActiveRecord::Base
+  include AlgoliaSearch
+
+  algoliasearch per_environment: true do
+    # the list of attributes sent to Algolia's API
+    attribute :created_at, :title, :url, :author, :points, :story_text, :comment_text, :author, :num_comments, :story_id, :story_title, :
+
+    # integer version of the created_at datetime field, to use numerical filtering
+    attribute :created_at_i do
+      created_at.to_i
+    end
+
+    # `title` is more important than `{story,comment}_text`, `{story,comment}_text` more than `url`, `url` more than `author`
+    # btw, do not take into account position in most fields to avoid first word match boost
+    attributesToIndex ['unordered(title)', 'unordered(story_text)', 'unordered(comment_text)', 'unordered(url)', 'author', 'created_at_i']
+
+    # list of attributes to highlight
+    attributesToHighlight ['title', 'story_text', 'comment_text', 'url', 'story_url', 'author', 'story_title']
+
+    # tags used for filtering
+    tags do
+      [item_type, "author_#{author}", "story_#{story_id}"]
+    end
+
+    # use associated number of HN points to sort results (last sort criteria)
+    customRanking ['desc(points)', 'desc(num_comments)']
+
+    # controls the way results are sorted sorting on the following 4 criteria (one after another)
+    # I removed the 'exact' match critera (improve 1-words query relevance, doesn't fit HNSearch needs)
+    ranking ['typo', 'proximity', 'attribute', 'custom']
+
+    # google+, $1.5M raises, C#: we love you
+    separatorsToIndex '+#$'
+  end
+
+  def story_text
+    item_type_cd != Item.comment ? text : nil
+  end
+
+  def story_title
+    comment? && story ? story.title : nil
+  end
+
+  def story_url
+    comment? && story ? story.url : nil
+  end
+
+  def comment_text
+    comment? ? text : nil
+  end
+
+  def comment?
+    item_type_cd == Item.comment
+  end
+
+  # [...]
+end
+```
+
 Indexing
 ---------
 

data/Rakefile

@@ -1,24 +1,6 @@
 require 'rubygems'
 require 'rake'
 
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "algoliasearch-rails"
-    gem.summary = %Q{AlgoliaSearch integration to your favorite ORM}
-    gem.description = %Q{AlgoliaSearch integration to your favorite ORM}
-    gem.homepage = "http://github.com/algolia/algoliasearch-rails"
-    gem.email = "contact@algolia.com"
-    gem.authors = ["Algolia"]
-    gem.files.exclude 'spec/integration_spec.rb'
-    gem.license = "MIT"
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-  end
-  Jeweler::RubygemsDotOrgTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
-end
-
 require 'rdoc/task'
 Rake::RDocTask.new do |rdoc|
   version = File.exist?('VERSION') ? File.read('VERSION') : ""

data/VERSION

@@ -1 +1 @@
-1.7.0
+1.7.1

data/algoliasearch-rails.gemspec

@@ -6,7 +6,7 @@
 
 Gem::Specification.new do |s|
   s.name = "algoliasearch-rails"
-  s.version = "1.7.0"
+  s.version = "1.7.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Algolia"]

data/lib/algoliasearch-rails.rb

@@ -36,8 +36,10 @@ module AlgoliaSearch
       @included_in << klass
       @included_in.uniq!
 
-      klass.send :include, InstanceMethods
-      klass.extend ClassMethods
+      klass.class_eval do
+        extend ClassMethods
+        include InstanceMethods
+      end
     end
 
   end
@@ -49,7 +51,8 @@ module AlgoliaSearch
       :minWordSizefor2Typos, :hitsPerPage, :attributesToRetrieve,
       :attributesToHighlight, :attributesToSnippet, :attributesToIndex,
       :ranking, :customRanking, :queryType, :attributesForFaceting,
-      :separatorsToIndex, :optionalWords, :attributeForDistinct]
+      :separatorsToIndex, :optionalWords, :attributeForDistinct,
+      :if, :unless]
     OPTIONS.each do |k|
       define_method k do |v|
         instance_variable_set("@#{k}", v)
@@ -117,126 +120,145 @@ module AlgoliaSearch
   # these are the class methods added when AlgoliaSearch is included
   module ClassMethods
 
+    def self.extended(base)
+      class <<base
+        alias_method :without_auto_index, :algolia_without_auto_index unless method_defined? :without_auto_index
+        alias_method :reindex!, :algolia_reindex! unless method_defined? :reindex!
+        alias_method :index!, :algolia_index! unless method_defined? :index!
+        alias_method :remove_from_index!, :algolia_remove_from_index! unless method_defined? :remove_from_index!
+        alias_method :clear_index!, :algolia_clear_index! unless method_defined? :clear_index!
+        alias_method :search, :algolia_search unless method_defined? :search
+        alias_method :index, :algolia_index unless method_defined? :index
+        alias_method :index_name, :algolia_index_name unless method_defined? :index_name
+        alias_method :must_reindex?, :algolia_must_reindex? unless method_defined? :must_reindex?
+      end
+    end
+
     def algoliasearch(options = {}, &block)
-      @index_settings = IndexSettings.new(block_given? ? Proc.new : nil)
-      @settings = @index_settings.to_settings
-      @options = { type: full_const_get(model_name.to_s), per_page: @index_settings.get_setting(:hitsPerPage) || 10, page: 1 }.merge(options)
+      @algolia_index_settings = IndexSettings.new(block_given? ? Proc.new : nil)
+      @algolia_settings = @algolia_index_settings.to_settings
+      @algolia_options = { type: algolia_full_const_get(model_name.to_s), per_page: @algolia_index_settings.get_setting(:hitsPerPage) || 10, page: 1 }.merge(options)
 
       attr_accessor :highlight_result
 
       if options[:synchronous] == true
-        after_validation :mark_synchronous if respond_to?(:before_validation)
+        after_validation :algolia_mark_synchronous if respond_to?(:before_validation)
       end
       unless options[:auto_index] == false
-        after_validation :mark_must_reindex if respond_to?(:after_validation)
-        before_save :mark_for_auto_indexing if respond_to?(:before_save)
-        after_save :perform_index_tasks if respond_to?(:after_save)
+        after_validation :algolia_mark_must_reindex if respond_to?(:after_validation)
+        before_save :algolia_mark_for_auto_indexing if respond_to?(:before_save)
+        after_save :algolia_perform_index_tasks if respond_to?(:after_save)
       end
       unless options[:auto_remove] == false
         after_destroy { |searchable| searchable.remove_from_index! } if respond_to?(:after_destroy)
       end
     end
 
-    def without_auto_index(&block)
-      @without_auto_index_scope = true
+    def algolia_without_auto_index(&block)
+      @algolia_without_auto_index_scope = true
       begin
         yield
       ensure
-        @without_auto_index_scope = false
+        @algolia_without_auto_index_scope = false
       end
     end
 
-    def reindex!(batch_size = 1000, synchronous = false)
-      return if @without_auto_index_scope
-      ensure_init
+    def algolia_reindex!(batch_size = 1000, synchronous = false)
+      return if @algolia_without_auto_index_scope
+      algolia_ensure_init
       last_task = nil
       find_in_batches(batch_size: batch_size) do |group|
-        objects = group.map { |o| @index_settings.get_attributes(o).merge 'objectID' => object_id_of(o) }
-        last_task = @index.save_objects(objects)
+        group.select! { |o| algolia_indexable?(o) } if algolia_conditional_index?
+        objects = group.map { |o| @algolia_index_settings.get_attributes(o).merge 'objectID' => algolia_object_id_of(o) }
+        last_task = @algolia_index.save_objects(objects)
       end
-      @index.wait_task(last_task["taskID"]) if last_task and synchronous == true
+      @algolia_index.wait_task(last_task["taskID"]) if last_task and synchronous == true
     end
 
-    def index!(object, synchronous = false)
-      return if @without_auto_index_scope
-      ensure_init
+    def algolia_index!(object, synchronous = false)
+      return if @algolia_without_auto_index_scope || !algolia_indexable?(object)
+      algolia_ensure_init
       if synchronous
-        @index.add_object!(@index_settings.get_attributes(object), object_id_of(object))
+        @algolia_index.add_object!(@algolia_index_settings.get_attributes(object), algolia_object_id_of(object))
       else
-        @index.add_object(@index_settings.get_attributes(object), object_id_of(object))
+        @algolia_index.add_object(@algolia_index_settings.get_attributes(object), algolia_object_id_of(object))
       end
     end
 
-    def remove_from_index!(object, synchronous = false)
-      return if @without_auto_index_scope
-      ensure_init
+    def algolia_remove_from_index!(object, synchronous = false)
+      return if @algolia_without_auto_index_scope
+      algolia_ensure_init
       if synchronous
-        @index.delete_object!(object_id_of(object))
+        @algolia_index.delete_object!(algolia_object_id_of(object))
       else
-        @index.delete_object(object_id_of(object))
+        @algolia_index.delete_object(algolia_object_id_of(object))
       end
     end
 
-    def clear_index!(synchronous = false)
-      ensure_init
-      synchronous ? @index.clear! : @index.clear
-      @index = nil
+    def algolia_clear_index!(synchronous = false)
+      algolia_ensure_init
+      synchronous ? @algolia_index.clear! : @algolia_index.clear
+      @algolia_index = nil
     end
 
-    def search(q, settings = {})
-      ensure_init
-      json = @index.search(q, Hash[settings.map { |k,v| [k.to_s, v.to_s] }])
+    def algolia_search(q, settings = {})
+      algolia_ensure_init
+      json = @algolia_index.search(q, Hash[settings.map { |k,v| [k.to_s, v.to_s] }])
       results = json['hits'].map do |hit|
-        o = @options[:type].where(object_id_method => hit['objectID']).first
-        o.highlight_result = hit['_highlightResult']
-        o
-      end
-      AlgoliaSearch::Pagination.create(results, json['nbHits'].to_i, @options)
+        o = @algolia_options[:type].where(algolia_object_id_method => hit['objectID']).first
+        if o
+          o.highlight_result = hit['_highlightResult']
+          o
+        end
+      end.compact
+      AlgoliaSearch::Pagination.create(results, json['nbHits'].to_i, @algolia_options)
     end
 
-    def ensure_init
-      return if @index
-      @index = Algolia::Index.new(index_name)
-      current_settings = @index.get_settings rescue nil # if the index doesn't exist
-      @index.set_settings(@settings) if index_settings_changed?(current_settings, @settings)
+    def algolia_index
+      algolia_ensure_init
+      @algolia_index
     end
 
-    def index
-      ensure_init
-      @index
+    def algolia_index_name
+      name = @algolia_options[:index_name] || model_name.to_s.gsub('::', '_')
+      name = "#{name}_#{Rails.env.to_s}" if @algolia_options[:per_environment]
+      name
     end
 
-    def must_reindex?(object)
-      return true if object_id_changed?(object)
-      @index_settings.get_attributes(object).each do |k, v|
+    def algolia_must_reindex?(object)
+      return true if algolia_object_id_changed?(object)
+      @algolia_index_settings.get_attributes(object).each do |k, v|
         changed_method = "#{k}_changed?"
         return true if object.respond_to?(changed_method) && object.send(changed_method)
       end
       return false
     end
 
-    def index_name
-      name = @options[:index_name] || model_name.to_s.gsub('::', '_')
-      name = "#{name}_#{Rails.env.to_s}" if @options[:per_environment]
-      name
+    protected
+
+    def algolia_ensure_init
+      return if @algolia_index
+      @algolia_index = Algolia::Index.new(algolia_index_name)
+      current_settings = @algolia_index.get_settings rescue nil # if the index doesn't exist
+      @algolia_index.set_settings(@algolia_settings) if algolia_index_settings_changed?(current_settings, @algolia_settings)
     end
 
     private
 
-    def object_id_method
-      @options[:id] || @options[:object_id] || :id
+    def algolia_object_id_method
+      @algolia_options[:id] || @algolia_options[:object_id] || :id
     end
 
-    def object_id_of(o)
-      o.send(object_id_method).to_s
+    def algolia_object_id_of(o)
+      o.send(algolia_object_id_method).to_s
     end
 
-    def object_id_changed?(o)
-      m = "#{object_id_method}_changed?"
+    def algolia_object_id_changed?(o)
+      m = "#{algolia_object_id_method}_changed?"
       o.respond_to?(m) ? o.send(m) : false
     end
 
-    def index_settings_changed?(prev, current)
+    def algolia_index_settings_changed?(prev, current)
       return true if prev.nil?
       current.each do |k, v|
         prev_v = prev[k.to_s]
@@ -250,7 +272,7 @@ module AlgoliaSearch
       false
     end
 
-    def full_const_get(name)
+    def algolia_full_const_get(name)
       list = name.split('::')
       list.shift if list.first.blank?
       obj = self
@@ -262,43 +284,78 @@ module AlgoliaSearch
       obj
     end
 
+    def algolia_conditional_index?
+      @algolia_options[:if].present? || @algolia_options[:unless].present?
+    end
+
+    def algolia_indexable?(object)
+      if_passes = @algolia_options[:if].blank? || algolia_constraint_passes?(object, @algolia_options[:if])
+      unless_passes = @algolia_options[:unless].blank? || !algolia_constraint_passes?(object, @algolia_options[:unless])
+      if_passes && unless_passes
+    end
+
+    def algolia_constraint_passes?(object, constraint)
+      case constraint
+      when Symbol
+        object.send(constraint)
+      when String
+        object.send(constraint.to_sym)
+      when Enumerable
+        # All constraints must pass
+        constraint.all? { |inner_constraint| algolia_constraint_passes?(object, inner_constraint) }
+      else
+        if constraint.respond_to?(:call) # Proc
+          constraint.call(object)
+        else
+          raise ArgumentError, "Unknown constraint type: #{constraint} (#{constraint.class})"
+        end
+      end
+    end
   end
 
   # these are the instance methods included
   module InstanceMethods
-    def index!
-      self.class.index!(self, synchronous?)
+
+    def self.included(base)
+      base.instance_eval do
+        alias_method :index!, :algolia_index! unless method_defined? :index!
+        alias_method :remove_from_index!, :algolia_remove_from_index! unless method_defined? :remove_from_index!
+      end
+    end
+
+    def algolia_index!
+      self.class.algolia_index!(self, algolia_synchronous?)
     end
 
-    def remove_from_index!
-      self.class.remove_from_index!(self, synchronous?)
+    def algolia_remove_from_index!
+      self.class.algolia_remove_from_index!(self, algolia_synchronous?)
     end
 
     private
 
-    def synchronous?
-      @synchronous == true
+    def algolia_synchronous?
+      @algolia_synchronous == true
     end
 
-    def mark_synchronous
-      @synchronous = true
+    def algolia_mark_synchronous
+      @algolia_synchronous = true
     end
 
-    def mark_for_auto_indexing
-      @auto_indexing = true
+    def algolia_mark_for_auto_indexing
+      @algolia_auto_indexing = true
     end
 
-    def mark_must_reindex
-      @must_reindex = new_record? || self.class.must_reindex?(self)
+    def algolia_mark_must_reindex
+      @algolia_must_reindex = new_record? || self.class.algolia_must_reindex?(self)
       true
     end
 
-    def perform_index_tasks
-      return if !@auto_indexing || @must_reindex == false
-      index!
-      remove_instance_variable(:@auto_indexing) if instance_variable_defined?(:@auto_indexing)
-      remove_instance_variable(:@synchronous) if instance_variable_defined?(:@synchronous)
-      remove_instance_variable(:@must_reindex) if instance_variable_defined?(:@must_reindex)
+    def algolia_perform_index_tasks
+      return if !@algolia_auto_indexing || @algolia_must_reindex == false
+      algolia_index!
+      remove_instance_variable(:@algolia_auto_indexing) if instance_variable_defined?(:@algolia_auto_indexing)
+      remove_instance_variable(:@algolia_synchronous) if instance_variable_defined?(:@algolia_synchronous)
+      remove_instance_variable(:@algolia_must_reindex) if instance_variable_defined?(:@algolia_must_reindex)
     end
   end
 end

data/spec/spec_helper.rb

@@ -15,4 +15,6 @@ AlgoliaSearch.configuration = { application_id: ENV['ALGOLIA_APPLICATION_ID'], a
 
 RSpec.configure do |c|
   c.mock_with :rspec
+  c.filter_run focus: true
+  c.run_all_when_everything_filtered = true
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: algoliasearch-rails
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.7.1
 platform: ruby
 authors:
 - Algolia