algoliasearch-rails 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6ee0ab3d41af8ec0e02fcb7a3e2acb2c96c3b153
+  data.tar.gz: 654676f81691005bae28254f6be4d5f35327b69f
+SHA512:
+  metadata.gz: 245cc2983eeea49a46882d31970e217e6e585aa44027a655201b5f08a565e28df009e5ccc14c72061ed4f0365eb951012ee353d0a99ff1e2a4c54dc1d7a4e89b
+  data.tar.gz: fefd2ae377a28c164af784b57608c937dafc5b9c6cbfa7c5b476132cd439772d027729bac98d63aa26615c69c02a0334808c4a29c6edee5c466085b4bf38aa27

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,20 @@
+source "http://rubygems.org"
+
+gem 'json', '>= 1.5.1'
+gem 'algoliasearch', '>= 1.0.2'
+
+group :test do 
+  gem 'rspec', '>= 2.5.0'
+  gem 'activerecord', '>= 3.0.7'
+  gem 'sqlite3'
+  gem 'autotest'
+  gem 'autotest-fsevent'
+  gem 'redgreen'
+  gem 'autotest-growl'
+end
+
+group :development do
+  gem 'jeweler'
+  gem 'will_paginate', '>= 2.3.15'
+  gem 'kaminari'
+end

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Algolia
+http://www.algolia.com/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,167 @@
+Algolia Search for Rails
+==================
+
+This gem let you easily integrate the Algolia Search API to your favorite ORM. It's based on the [algoliasearch-client-ruby](https://github.com/algolia/algoliasearch-client-ruby) gem.
+
+Table of Content
+-------------
+**Get started**
+
+1. [Install](#install)
+1. [Setup](#setup)
+1. [Quick Start](#quick-start)
+1. [Options](#options)
+1. [Indexing](#indexing)
+1. [Search settings](#search-settings)
+1. [Note on testing](#note-on-testing)
+
+Install
+-------------
+
+```sh
+gem install algoliasearch-rails
+```
+
+If you are using Rails 3, add the gem to your <code>Gemfile</code>:
+
+```ruby
+gem "algoliasearch-rails"
+```
+
+And run:
+
+```sh
+bundle install
+```
+
+Setup
+-------------
+Create a new file <code>config/initializers/algoliasearch.rb</code> to setup your <code>APPLICATION_ID</code> and <code>API_KEY</code>.
+
+
+```ruby
+AlgoliaSearch.configuration = { application_id: 'YourApplicationID', api_key: 'YourAPIKey' }
+```
+
+We support both [will_paginate](https://github.com/mislav/will_paginate) and [kaminari](https://github.com/amatsuda/kaminari) as pagination backend. For example to use <code>:will_paginate</code>, specify the <code>:pagination_backend</code> as follow:
+
+```ruby
+AlgoliaSearch.configuration = { application_id: 'YourApplicationID', api_key: 'YourAPIKey', pagination_backend: :will_paginate }
+```
+
+Quick Start
+-------------
+
+The following code will create a <code>contact</code> index and add search capabilities to your <code>Contact</code> model:
+
+```ruby
+class Contact < ActiveRecord::Base
+  include AlgoliaSearch
+
+  algoliasearch do
+    attribute :first_name, :last_name, :email
+  end
+end
+```
+
+You can either specify the attributes to send (here we restrict to <code>:first_name, :last_name, :email</code>) or not (in that case, all attributes are sent).
+
+```ruby
+class Product < ActiveRecord::Base
+  include AlgoliaSearch
+
+  algoliasearch do
+    # all attributes will be sent
+  end
+end
+```
+
+```ruby
+p Contact.search("jon doe")
+```
+
+Options
+----------
+
+Each time a record is saved; it will be - synchronously - indexed. In the other hand, each time a record is destroyed, it will be - synchronoulsy - removed from the index.
+
+You can disable auto-indexing and auto-removing setting the following options:
+
+```ruby
+class Contact < ActiveRecord::Base
+  include AlgoliaSearch
+
+  algoliasearch auto_index: false, auto_remove: false do
+    attribute :first_name, :last_name, :email
+  end
+end
+```
+
+You can force indexing and removing to be asynchronous by setting the following option:
+
+```ruby
+class Contact < ActiveRecord::Base
+  include AlgoliaSearch
+
+  algoliasearch synchronous: false do
+    attribute :first_name, :last_name, :email
+  end
+end
+```
+
+Indexing
+---------
+
+You can trigger indexing using the <code>index!</code> instance method.
+
+```ruby
+c = Contact.create!(params[:contact])
+c.index!
+```
+
+And trigger index removing using the <code>remove_from_index!</code> instance method.
+
+```ruby
+c.remove_from_index!
+c.destroy
+```
+
+To reindex all your records, use the <code>reindex!</code> class method:
+
+```ruby
+Contact.reindex!
+```
+
+To clear an index, use the <code>clear_index!</code> class method:
+
+```ruby
+Contact.clear_index!
+```
+
+
+Search settings
+----------
+
+All [settings](https://github.com/algolia/algoliasearch-client-ruby#index-settings) can be specified either statically in your model or dynamically at search time using [search options](https://github.com/algolia/algoliasearch-client-ruby#search):
+
+```ruby
+class Contact < ActiveRecord::Base
+  include AlgoliaSearch
+
+  algoliasearch auto_index: false, auto_remove: false do
+    attribute :first_name, :last_name, :email
+    minWordSizeForApprox1 2
+    minWordSizeForApprox2 5
+    hitsPerPage 42
+  end
+end
+```
+
+```ruby
+p Contact.search("jon doe", hitsPerPage: 5, page: 2)
+```
+
+Note on testing
+-----------------
+
+To run the specs, please set the <code>ALGOLIA_APPLICATION_ID</code> and <code>ALGOLIA_API_KEY</code> environment variables. Since the tests are creating and removing indexes, DO NOT use your production account.

data/Rakefile

@@ -0,0 +1,51 @@
+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 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 "rspec/core/rake_task"
+# RSpec 2.0
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/{algoliasearch,utilities}_spec.rb'
+  spec.rspec_opts = ['--backtrace']
+end
+task :default => :spec
+
+desc "Generate code coverage"
+RSpec::Core::RakeTask.new(:coverage) do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
+end
+
+desc "Run Integration Specs"
+RSpec::Core::RakeTask.new(:integration) do |t|
+  t.pattern = "spec/integration_spec.rb" # don't need this, it's default.
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
+end
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "AlgoliaSearch Rails #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/algoliasearch-rails.gemspec

@@ -0,0 +1,68 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "algoliasearch-rails"
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Algolia"]
+  s.date = "2013-09-18"
+  s.description = "AlgoliaSearch integration to your favorite ORM"
+  s.email = "contact@algolia.com"
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "LICENSE",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "algoliasearch-rails.gemspec",
+    "lib/algoliasearch-rails.rb",
+    "lib/algoliasearch/configuration.rb",
+    "lib/algoliasearch/pagination.rb",
+    "lib/algoliasearch/pagination/kaminari.rb",
+    "lib/algoliasearch/pagination/will_paginate.rb",
+    "lib/algoliasearch/railtie.rb",
+    "lib/algoliasearch/tasks/algoliasearch.rake",
+    "lib/algoliasearch/utilities.rb",
+    "spec/spec_helper.rb",
+    "spec/utilities_spec.rb"
+  ]
+  s.homepage = "http://github.com/algolia/algoliasearch-rails"
+  s.require_paths = ["lib"]
+  s.rubygems_version = "2.0.3"
+  s.summary = "AlgoliaSearch integration to your favorite ORM"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<json>, [">= 1.5.1"])
+      s.add_runtime_dependency(%q<algoliasearch>, [">= 1.0.2"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<will_paginate>, [">= 2.3.15"])
+      s.add_development_dependency(%q<kaminari>, [">= 0"])
+    else
+      s.add_dependency(%q<json>, [">= 1.5.1"])
+      s.add_dependency(%q<algoliasearch>, [">= 1.0.2"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<will_paginate>, [">= 2.3.15"])
+      s.add_dependency(%q<kaminari>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<json>, [">= 1.5.1"])
+    s.add_dependency(%q<algoliasearch>, [">= 1.0.2"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<will_paginate>, [">= 2.3.15"])
+    s.add_dependency(%q<kaminari>, [">= 0"])
+  end
+end
+

data/lib/algoliasearch-rails.rb

@@ -0,0 +1,185 @@
+begin
+  require "rubygems"
+  require "bundler"
+
+  Bundler.setup :default
+rescue => e
+  puts "AlgoliaSearch: #{e.message}"
+end
+require 'algoliasearch'
+
+require 'algoliasearch/utilities'
+
+if defined? Rails
+  begin
+    require 'algoliasearch/railtie'
+  rescue LoadError
+  end
+end
+
+module AlgoliaSearch
+
+  class NotConfigured < StandardError; end
+  class BadConfiguration < StandardError; end
+  class NoBlockGiven < StandardError; end
+
+  autoload :Configuration, 'algoliasearch/configuration'
+  extend Configuration
+
+  autoload :Pagination, 'algoliasearch/pagination'
+
+  class << self
+    attr_reader :included_in
+
+    def included(klass)
+      @included_in ||= []
+      @included_in << klass
+      @included_in.uniq!
+
+      klass.send :include, InstanceMethods
+      klass.extend ClassMethods
+    end
+
+  end
+
+  class IndexOptions
+
+    # AlgoliaSearch settings
+    OPTIONS = [:attributesToIndex, :minWordSizeForApprox1,
+      :minWordSizeForApprox2, :hitsPerPage, :attributesToRetrieve,
+      :attributesToHighlight, :attributesToSnippet, :attributesToIndex,
+      :ranking, :customRanking, :queryType]
+    attr_accessor *OPTIONS
+
+    # attributes to consider
+    attr_accessor :attributes
+
+    def initialize(block)
+      instance_exec(&block) if block
+    end
+
+    def attribute(*names)
+      self.attributes ||= []
+      self.attributes += names
+    end
+
+    def to_settings
+      settings = {}
+      OPTIONS.each do |k|
+        v = send(k)
+        settings[k] = v if !v.nil?
+      end
+      settings
+    end
+  end
+
+  # these are the class methods added when AlgoliaSearch is included
+  module ClassMethods
+    def algoliasearch(options = {}, &block)
+      @index_options = IndexOptions.new(block_given? ? Proc.new : nil)
+      attr_accessor :highlight_result
+
+      unless options[:synchronous] == false
+        before_save :mark_synchronous if respond_to?(:before_save)
+      end
+      unless options[:auto_index] == false
+        before_save :mark_for_auto_indexing if respond_to?(:before_save)
+        after_save :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
+
+      @options = { type: model_name, per_page: @index_options.hitsPerPage || 10, page: 1 }.merge(options)
+      init
+    end
+
+    def reindex!(batch_size = 1000, synchronous = true)
+      find_in_batches(batch_size: batch_size) do |group|
+        objects = group.map { |o| attributes(o).merge 'objectID' => o.id.to_s }
+        if synchronous == true
+          @index.save_objects!(objects)
+        else
+          @index.save_objects(objects)
+        end
+      end
+    end
+
+    def index!(object, synchronous = true)
+      if synchronous
+        @index.add_object!(attributes(object), object.id.to_s)
+      else
+        @index.add_object(attributes(object), object.id.to_s)
+      end
+    end
+
+    def remove_from_index!(object, synchronous = true)
+      if synchronous
+        @index.delete_object!(object.id.to_s)
+      else
+        @index.delete_object(object.id.to_s)
+      end
+    end
+
+    def clear_index!
+      @index.delete
+      @index = nil
+      init
+    end
+
+    def search(q, settings = {})
+      json = @index.search(q, Hash[settings.map { |k,v| [k.to_s, v.to_s] }])
+      results = json['hits'].map do |hit|
+        o = Object.const_get(@options[:type]).find(hit['objectID'])
+        o.highlight_result = hit['_highlightResult']
+        o
+      end
+      AlgoliaSearch::Pagination.create(results, json['nbHits'].to_i, @options)
+    end
+
+    def init
+      @index ||= Algolia::Index.new(model_name)
+      @index.set_settings(@index_options.to_settings)
+    end
+
+    private
+
+    def attributes(object)
+      return object.attributes if @index_options.attributes.nil? or @index_options.attributes.length == 0
+      Hash[@index_options.attributes.map { |attr| [attr.to_s, object.send(attr)] }]
+    end
+
+  end
+
+  # these are the instance methods included
+  module InstanceMethods
+    def index!
+      self.class.index!(self, synchronous?)
+    end
+
+    def remove_from_index!
+      self.class.remove_from_index!(self, synchronous?)
+    end
+
+    private
+
+    def synchronous?
+      @synchronous.nil? || @synchronous == true
+    end
+
+    def mark_synchronous
+      @synchronous = true
+    end
+
+    def mark_for_auto_indexing
+      @auto_indexing = true
+    end
+
+    def perform_index_tasks
+      return if !@auto_indexing
+      index!
+      remove_instance_variable :@auto_indexing
+      remove_instance_variable :@synchronous
+    end
+  end
+end

data/lib/algoliasearch/configuration.rb

@@ -0,0 +1,12 @@
+module AlgoliaSearch
+  module Configuration
+    def configuration
+      @@configuration || raise(NotConfigured, "Please configure AlgoliaSearch. Set AlgoliaSearch.configuration = {application_id: 'YOUR_APPLICATION_ID', api_key: 'YOUR_API_KEY'}")
+    end
+
+    def configuration=(configuration)
+      @@configuration = configuration
+      Algolia.init application_id: @@configuration[:application_id], api_key: @@configuration[:api_key]
+    end
+  end
+end

data/lib/algoliasearch/pagination.rb

@@ -0,0 +1,19 @@
+module AlgoliaSearch
+  module Pagination
+
+    autoload :WillPaginate, 'algoliasearch/pagination/will_paginate'
+    autoload :Kaminari, 'algoliasearch/pagination/kaminari'
+
+    def self.create(results, total_hits, options = {})
+      return results if AlgoliaSearch.configuration[:pagination_backend].nil?
+      begin
+        backend = AlgoliaSearch.configuration[:pagination_backend].to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase } # classify pagination backend name
+        page = Object.const_get(:AlgoliaSearch).const_get(:Pagination).const_get(backend).create(results, total_hits, options)
+        page
+      rescue NameError
+        raise(BadConfiguration, "Unknown pagination backend")
+      end
+    end
+    
+  end
+end

data/lib/algoliasearch/pagination/kaminari.rb

@@ -0,0 +1,39 @@
+unless defined? Kaminari
+  raise(AlgoliaSearch::BadConfiguration, "AlgoliaSearch: Please add 'kaminari' to your Gemfile to use kaminari pagination backend")
+end
+
+module AlgoliaSearch
+  module Pagination
+    class Kaminari < Array
+      include ::Kaminari::ConfigurationMethods::ClassMethods
+      include ::Kaminari::PageScopeMethods
+
+      attr_reader :limit_value, :offset_value, :total_count
+
+      def initialize(original_array, limit_val, offset_val, total_count)
+        @limit_value = limit_val || default_per_page
+        @offset_value, @total_count = offset_val, total_count
+        super(original_array)
+      end
+
+      def page(num = 1)
+        self
+      end
+
+      def limit(num)
+        self
+      end
+
+      def current_page
+        offset_value+1
+      end
+
+      class << self
+        def create(results, total_hits, options = {})
+          instance = new(results, options[:per_page], options[:page]-1, total_hits)
+          instance
+        end
+      end
+    end
+  end
+end

data/lib/algoliasearch/pagination/will_paginate.rb

@@ -0,0 +1,15 @@
+begin
+  require 'will_paginate/collection'
+rescue LoadError
+  raise(AlgoliaSearch::BadConfiguration, "AlgoliaSearch: Please add 'will_paginate' to your Gemfile to use will_paginate pagination backend")
+end
+
+module AlgoliaSearch
+  module Pagination
+    class WillPaginate
+      def self.create(results, total_hits, options = {})
+        ::WillPaginate::Collection.create(options[:page], options[:per_page], total_hits) { |pager| pager.replace results }
+      end
+    end
+  end
+end

data/lib/algoliasearch/railtie.rb

@@ -0,0 +1,9 @@
+require 'rails'
+
+module AlgoliaSearch
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "algoliasearch/tasks/algoliasearch.rake"
+    end
+  end
+end

data/lib/algoliasearch/tasks/algoliasearch.rake

@@ -0,0 +1,29 @@
+namespace :algoliasearch do
+ 
+  desc "Reindex all models"
+  task :reindex => :environment do
+    puts "reindexing all models"
+    load_models
+    AlgoliaSearch::Utilities.reindex_all_models
+  end
+  
+  desc "Clear all indexes"
+  task :clear_indexes => :environment do
+    puts "clearing all indexes"
+    load_models
+    AlgoliaSearch::Utilities.clear_all_indexes
+  end
+  
+  def load_models
+    app_root = Rails.root
+    dirs = ["#{app_root}/app/models/"] + Dir.glob("#{app_root}/vendor/plugins/*/app/models/")
+    
+    dirs.each do |base|
+      Dir["#{base}**/*.rb"].each do |file|
+        model_name = file.gsub(/^#{base}([\w_\/\\]+)\.rb/, '\1')
+        next if model_name.nil?
+        model_name.camelize.constantize
+      end
+    end
+  end
+end

data/lib/algoliasearch/utilities.rb

@@ -0,0 +1,22 @@
+module AlgoliaSearch
+  module Utilities
+    class << self
+      def get_model_classes
+        AlgoliaSearch.included_in ? AlgoliaSearch.included_in : []
+      end
+
+      def clear_all_indexes
+        get_model_classes.each do |klass|
+          klass.clear_index!
+        end
+      end
+
+      def reindex_all_models
+        get_model_classes.each do |klass|
+          klass.reindex!
+        end
+      end
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+Bundler.setup :test
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'algoliasearch-rails'
+require 'rspec'
+
+raise "missing ALGOLIA_APPLICATION_ID or ALGOLIA_API_KEY environment variables" if ENV['ALGOLIA_APPLICATION_ID'].nil? || ENV['ALGOLIA_API_KEY'].nil?
+
+AlgoliaSearch.configuration = { application_id: ENV['ALGOLIA_APPLICATION_ID'], api_key: ENV['ALGOLIA_API_KEY'] }
+
+RSpec.configure do |c|
+  c.mock_with :rspec
+end

data/spec/utilities_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe AlgoliaSearch::Utilities do
+
+  before(:each) do
+    @included_in = AlgoliaSearch.instance_variable_get :@included_in
+    AlgoliaSearch.instance_variable_set :@included_in, []
+
+    class Dummy
+      include AlgoliaSearch
+
+      def self.model_name
+        "dummy"
+      end
+
+      algoliasearch
+    end
+  end
+
+  after(:each) do
+    AlgoliaSearch.instance_variable_set :@included_in, @included_in
+  end
+
+  it "should get the models where AlgoliaSearch module was included" do
+    (AlgoliaSearch::Utilities.get_model_classes - [Dummy]).should == []
+  end
+
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: algoliasearch-rails
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Algolia
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.1
+- !ruby/object:Gem::Dependency
+  name: algoliasearch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: will_paginate
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.15
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.15
+- !ruby/object:Gem::Dependency
+  name: kaminari
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: AlgoliaSearch integration to your favorite ORM
+email: contact@algolia.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- .document
+- .rspec
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- algoliasearch-rails.gemspec
+- lib/algoliasearch-rails.rb
+- lib/algoliasearch/configuration.rb
+- lib/algoliasearch/pagination.rb
+- lib/algoliasearch/pagination/kaminari.rb
+- lib/algoliasearch/pagination/will_paginate.rb
+- lib/algoliasearch/railtie.rb
+- lib/algoliasearch/tasks/algoliasearch.rake
+- lib/algoliasearch/utilities.rb
+- spec/spec_helper.rb
+- spec/utilities_spec.rb
+homepage: http://github.com/algolia/algoliasearch-rails
+licenses: []
+metadata: {}
+post_install_message: 
+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.3
+signing_key: 
+specification_version: 4
+summary: AlgoliaSearch integration to your favorite ORM
+test_files: []