elastic_ransack 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f63dff989c1fc3d17945abaa3bdea9dbde2d5481
+  data.tar.gz: 567674e6eb6459ca4bda929cb9829c8698741289
+SHA512:
+  metadata.gz: 007262a391eb9046e8acdd188fd60b5c890a81f6f74784ac0beeae71d5392dcbbfe239b7c99058944cad5d851bc840b779ab87628b47159368bc843d4b0ae13c
+  data.tar.gz: e56a8010464704f31371314aa69f70b03b111ad483437ae68b4738dfee974a5876bcbd2a7b92d5c889fbe19da1be5e7232e90a248dd6961b83ae22eb20203000

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+.idea
+.rvmrc
+.rspec
+TODO

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in elastic_ransack.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Alex Leschenko
+
+MIT License
+
+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,47 @@
+# ElasticRansack
+
+ElasticRansack provides condition predicate searching to your elasticsearch models like ransack or meta_search gems.
+Your can just create serach form with `name_cont` or `created_at_gt` fields and elastic_ransack build a search query for you.
+It is compatible with most of the Ransack helper methods and predicates.
+
+It uses [Tire](https://github.com/karmi/tire) and [Elasticsearch](http://www.elasticsearch.org/) for searching.
+
+Inspired by [Ransack](https://github.com/ernie/ransack) gem.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'elastic_ransack'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install elastic_ransack
+
+## Usage
+
+Include ElasticRansack extension to your model:
+
+```ruby
+class User < ActiveRecord::Base
+  include ElasticRansack::Model
+end
+```
+
+Search with `elastic_ransack` method. It return `Tire::Results::Collection` instance:
+
+```ruby
+User.elastic_ransack({name_cont: 'alex', role_id_eq: 1, state_id_in: [2, 3], created_at_gt: 1.day.ago})
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/elastic_ransack.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'elastic_ransack/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'elastic_ransack'
+  spec.version       = ElasticRansack::VERSION
+  spec.authors       = ['Alex Leschenko']
+  spec.email         = %w(leschenko.al@gmail.com)
+  spec.summary       = %q{Conditions searching adapter for elasticsearch models like ransack}
+  spec.description   = %q{Conditions searching using predicates such as 'name_cont' or 'created_at_gt' for elasticsearch models}
+  spec.homepage      = 'https://github.com/leschenko/elastic_ransack'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = %w(lib)
+
+  spec.add_dependency 'tire', '~> 0.6.0'
+
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'bundler', '~> 1.3'
+end

data/lib/elastic_ransack.rb

@@ -0,0 +1,45 @@
+require 'tire'
+require 'elastic_ransack/version'
+require 'elastic_ransack/core_ext'
+require 'elastic_ransack/predicate'
+require 'elastic_ransack/naming'
+require 'elastic_ransack/search'
+require 'elastic_ransack/model'
+
+module ElasticRansack
+  mattr_accessor :predicates
+  self.predicates = []
+
+  BASE_PREDICATES = [
+      ['eq', {query: proc { |attr, v| {term: {attr => v}} }}],
+      ['in', {query: proc { |attr, v| {terms: {attr => ElasticRansack.val_to_array(v)}} }}],
+      ['in_all', {query: proc { |attr, v| {terms: {attr => ElasticRansack.val_to_array(v), execution: 'and'}} }}],
+      ['gt', {query: proc { |attr, v| {range: {attr => {gt: v}}} }}],
+      ['lt', {query: proc { |attr, v| {range: {attr => {lt: v}}} }}],
+      ['gteq', {query: proc { |attr, v| {range: {attr => {gte: v}}} }}],
+      ['lteq', {query: proc { |attr, v| {range: {attr => {lte: v}}} }}]
+  ]
+
+  class << self
+    def setup
+      yield self
+    end
+
+    def add_predicate(*args)
+      self.predicates << Predicate.new(*args)
+    end
+
+    def val_to_array(val)
+      return [] unless val
+      return val if val.is_a?(Array)
+      val.to_s.split(',').map(&:to_i).reject(&:zero?)
+    end
+  end
+end
+
+ElasticRansack.setup do |config|
+  ElasticRansack::BASE_PREDICATES.each do |args|
+    config.add_predicate *args
+  end
+end
+

data/lib/elastic_ransack/core_ext.rb

@@ -0,0 +1,9 @@
+class String
+  # http://lucene.apache.org/core/old_versioned_docs/versions/2_9_1/queryparsersyntax.html
+  LUCENE_ESCAPE_REGEX = /(\+|-|&&|\|\||!|\(|\)|{|}|\[|\]|\^|"|~|\*|\?|:|\\|\/)/
+
+
+  def lucene_escape
+    self.gsub(LUCENE_ESCAPE_REGEX, "\\\\\\1")
+  end
+end

data/lib/elastic_ransack/model.rb

@@ -0,0 +1,50 @@
+module ElasticRansack
+  module Model
+
+    def self.included(base)
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+
+      # === options
+      # [:s]
+      #   sorting column
+      #   can contain sort mode separated by space
+      #   example: 'id desc'
+      # [:q_cont]
+      #   search against _all fields
+      #
+      # ==== condition predicates:
+      #   '_cont'    contains string value
+      #   '_eq'      equal value
+      #   '_in'      include any of the values
+      #   '_in_all'  include all values
+      #   '_gt'      greater then value
+      #   '_lt'      less then value
+      #   '_gteq'    greater or equal the value
+      #   '_lteq '   less or equal the value
+      #
+      # === search_options
+      # [:globalize]
+      #   For search on localized attributes like 'name_en' via 'translations_' prefixed field
+      #   example: <code>User.elastic_ransack({translations_name_cont: 'text'}, globalize: true)</code>
+      #   will search on 'name_en' field (depending on current locale)
+      #
+      # === Examples
+      #   Product.elastic_ransack(name_cont: 'alex', category_id_eq: 1, tag_ids_in: [2, 3])
+      #   Product.elastic_ransack(tag_ids_in: '2,3,4')
+      #   Product.elastic_ransack(created_at_gt: 1.day.ago)
+      #   Product.elastic_ransack(q_cont: 'table')
+      #   Product.elastic_ransack(s: 'price desc')
+      #   Product.elastic_ransack({translations_name_cont: 'chair'}, globalize: true)
+      #
+      def elastic_ransack(options={}, search_options={})
+        elastic_ransack = Search.new(self, options, search_options)
+        elastic_ransack.search
+        elastic_ransack
+      end
+    end
+
+  end
+end

data/lib/elastic_ransack/naming.rb

@@ -0,0 +1,52 @@
+module ElasticRansack
+  module Naming
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def persisted?
+      false
+    end
+
+    def to_key
+      nil
+    end
+
+    def to_param
+      nil
+    end
+
+    def to_model
+      self
+    end
+  end
+
+  class Name < String
+    attr_reader :singular, :plural, :element, :collection, :partial_path, :human, :param_key, :route_key, :i18n_key
+    alias_method :cache_key, :collection
+
+    def initialize
+      super('Search')
+      @singular = 'search'.freeze
+      @plural = 'searches'.freeze
+      @element = 'search'.freeze
+      @human = 'Search'.freeze
+      @collection = 'elastic_ransack/searches'.freeze
+      @partial_path = "#{@collection}/#{@element}".freeze
+      @param_key = 'q'.freeze
+      @route_key = 'searches'.freeze
+      @i18n_key = :elastic_ransack
+    end
+  end
+
+  module ClassMethods
+    def model_name
+      @_model_name ||= Name.new
+    end
+
+    def i18n_scope
+      :elastic_ransack
+    end
+  end
+end

data/lib/elastic_ransack/predicate.rb

@@ -0,0 +1,12 @@
+module ElasticRansack
+  class Predicate
+    attr_reader :name, :regexp, :query
+
+    def initialize(name, opts={})
+      @name = name
+      @regexp = opts[:regexp] || Regexp.new("^(.+)_#{@name}$")
+      @query = opts[:query]
+      raise(ArgumentError, ':query option is required') unless @query
+    end
+  end
+end

data/lib/elastic_ransack/search.rb

@@ -0,0 +1,103 @@
+module ElasticRansack
+  class Search
+    include ::ElasticRansack::Naming
+    include Enumerable
+
+    attr_reader :options, :search_options, :model, :search_results, :sorts, :globalize
+
+    delegate :results, :each, :empty?, :size, :[], to: :search_results
+    delegate :total_entries, :per_page, :total_pages, :current_page, :previous_page, :next_page, :offset, :out_of_bounds?,
+             to: :search_results
+
+    alias_method :klass, :model
+
+    DATETIME_REGEXP = /\d{2}\.\d{2}.\d{4} \d{2}\:\d{2}/
+    DATE_REGEXP = /\d{2}\.\d{2}.\d{4}/
+
+    def initialize(model, options, search_options)
+      search_options ||= {}
+      search_options.reverse_merge!(globalize: true)
+      @model = model
+      @options = options.stringify_keys
+      @search_options = search_options || {}
+      @sorts = []
+      @globalize = @search_options.delete(:globalize)
+      sorting = @options.delete('s')
+      if sorting.blank?
+        add_sort('id', 'desc')
+      else
+        sorting_split = sorting.split(/\s+/, 2)
+        add_sort(sorting_split[0], sorting_split[1] || 'asc')
+      end
+    end
+
+    def add_sort(name, dir)
+      @sorts << OpenStruct.new(name: name, dir: dir)
+    end
+
+    def search
+      @search_results ||= begin
+        that = self
+        query_string = []
+        tire.search(@search_options) do
+          and_filters = []
+          sort do
+            that.sorts.each do |s|
+              by s.name, s.dir
+            end
+          end
+
+          that.options.each do |k, v|
+            next if v.blank?
+
+            if k == 'q_cont' || k == 'q_eq'
+              query_string << "#{v.lucene_escape}" if v.present?
+              next
+            end
+
+            if k =~ /^(.+)_cont$/
+              attr = $1
+              attr = "#{$1.sub(/^translations_/, '')}_#{I18n.locale}" if that.globalize && attr =~ /^translations_(.+)/
+              attr_query = [
+                  v.split.map { |part| "#{attr}:*#{part.lucene_escape}*" }.join(' AND '),
+                  v.split.map { |part| "#{attr}:\"#{part.lucene_escape}\"" }.join(' AND ')
+              ]
+              query_string << attr_query.map { |q| "(#{q})" }.join(' OR ')
+              next
+            else
+              v = that.format_value(v)
+            end
+
+            ElasticRansack.predicates.each do |predicate|
+              if k =~ predicate.regexp
+                and_filters << predicate.query.call($1, v)
+              end
+            end
+          end
+
+          query { string query_string.join(' ') } unless query_string.blank?
+          filter(:and, filters: and_filters) unless and_filters.blank?
+        end
+      end
+    end
+
+
+    def translate(*args)
+      model.human_attribute_name(args.first)
+    end
+
+    def format_value(v)
+      if v =~ DATETIME_REGEXP
+        Date.parse(v)
+      elsif v =~ DATE_REGEXP
+        Time.parse(v)
+      else
+        v
+      end
+    end
+
+    def method_missing(*args, &block)
+      @model.send(*args, &block)
+    end
+  end
+end

data/lib/elastic_ransack/version.rb

@@ -0,0 +1,3 @@
+module ElasticRansack
+  VERSION = '0.0.1'
+end

data/spec/elastic_ransack/base_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe ElasticRansack do
+  subject { ModelSearch }
+
+  before :all do
+    ModelSearch.setup_index
+  end
+
+  it 'setup yields ElasticRansack' do
+    ElasticRansack.setup do |config|
+      config.should == ElasticRansack
+    end
+  end
+
+  it 'add predicates' do
+    expect do
+      ElasticRansack.add_predicate 'test', {query: proc {}}
+    end.to change { ElasticRansack.predicates.size }.by(1)
+
+    ElasticRansack.predicates.last.name.should == 'test'
+  end
+
+  it 'add elastic_ransack method' do
+    should respond_to(:elastic_ransack)
+  end
+
+  describe '#val_to_array' do
+    it 'convert comma separated string to array' do
+      ElasticRansack.val_to_array('2,3,4').should == [2, 3, 4]
+    end
+
+    it 'return if array' do
+      array = [1, 2, 3]
+      ElasticRansack.val_to_array(array).should == array
+    end
+
+    it 'return empty array if value evaluates to false' do
+      ElasticRansack.val_to_array(nil).should == []
+    end
+  end
+end

data/spec/elastic_ransack/core_ext_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe 'string lucene query escaping' do
+  it do
+    'string'.should respond_to(:lucene_escape)
+  end
+
+  %w( + - && || ! ( ) { } [ ] ^ " ~ * ? : / ).each do |char|
+    it "escape #{char}" do
+      "abc #{char} edf".lucene_escape.should == "abc \\#{char} edf"
+    end
+  end
+
+  it 'escape \ ' do
+    "abc \\ edf".lucene_escape.should == "abc \\\\ edf"
+  end
+
+end

data/spec/elastic_ransack/predicate_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe ElasticRansack::Predicate do
+  it 'require :query option' do
+    expect { ElasticRansack::Predicate.new('test', {}) }.to raise_error(ArgumentError, ':query option is required')
+  end
+
+  it 'creates regexp based on name' do
+    predicate = ElasticRansack::Predicate.new('test', {query: proc {} })
+    predicate.regexp.should == /^(.+)_test$/
+  end
+end

data/spec/elastic_ransack/search_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe 'predicates' do
+  before :all do
+    @model = ModelSearch
+    @model.setup_index
+  end
+
+  it 'delegate methods to model' do
+    [:results, :each, :empty?, :size, :[], :total_entries, :per_page, :total_pages,
+     :current_page, :previous_page, :next_page, :offset, :out_of_bounds?].each do |meth|
+      @model.elastic_ransack.should.respond_to?(meth)
+    end
+  end
+
+  context 'string fields' do
+    it '_cont' do
+      @model.elastic_ransack(text_cont: 'test').map(&:id).map(&:to_i).should =~ [1, 3]
+    end
+
+    it '_cont localized' do
+      I18n.locale = :ru
+      @model.elastic_ransack({translations_text_cont: 'alexandr'}, {globalize: true}).map(&:id).map(&:to_i).should =~ [1]
+    end
+
+    it 'q_cont param search on _all fields' do
+      @model.elastic_ransack(q_cont: 'test').map(&:id).map(&:to_i).should =~ [1, 3]
+    end
+  end
+
+  it '_eq' do
+    @model.elastic_ransack(one_assoc_id_eq: 2).map(&:id).map(&:to_i).should =~ [2, 3]
+  end
+
+  it '_in' do
+    @model.elastic_ransack(many_assoc_ids_in: [3, 99]).map(&:id).map(&:to_i).should =~ [1, 2]
+  end
+
+  it '_in_all' do
+    @model.elastic_ransack(many_assoc_ids_in_all: [4, 5]).map(&:id).map(&:to_i).should =~ [2]
+  end
+
+  context '_gt' do
+    it 'integer' do
+      @model.elastic_ransack(int_attr_gt: 20).map(&:id).map(&:to_i).should =~ [3]
+    end
+
+    it 'datetime' do
+      @model.elastic_ransack(created_at_gt: 2.days.ago).map(&:id).map(&:to_i).should =~ [1, 3]
+    end
+
+    it 'datetime string' do
+      @model.elastic_ransack(created_at_gt: 2.days.ago.strftime('%d.%m.%Y %H:%M')).map(&:id).map(&:to_i).should =~ [1, 3]
+    end
+
+    it 'date' do
+      @model.elastic_ransack(created_at_gt: Date.yesterday).map(&:id).map(&:to_i).should =~ [1, 3]
+    end
+
+    it 'date string' do
+      @model.elastic_ransack(created_at_gt: Date.yesterday.strftime('%d.%m.%Y')).map(&:id).map(&:to_i).should =~ [1, 3]
+    end
+  end
+
+  context '_lt' do
+    it 'integer' do
+      @model.elastic_ransack(int_attr_lt: 20).map(&:id).map(&:to_i).should =~ [1]
+    end
+
+    it 'datetime' do
+      @model.elastic_ransack(created_at_lt: 2.days.ago).map(&:id).map(&:to_i).should =~ [2]
+    end
+
+    it 'datetime string' do
+      @model.elastic_ransack(created_at_lt: 2.days.ago.strftime('%d.%m.%Y %H:%M')).map(&:id).map(&:to_i).should =~ [2]
+    end
+
+    it 'date' do
+      @model.elastic_ransack(created_at_lt: Date.yesterday).map(&:id).map(&:to_i).should =~ [2]
+    end
+
+    it 'date string' do
+      @model.elastic_ransack(created_at_lt: Date.yesterday.strftime('%d.%m.%Y')).map(&:id).map(&:to_i).should =~ [2]
+    end
+  end
+
+  it '_gteq' do
+    @model.elastic_ransack(int_attr_gteq: 20).map(&:id).map(&:to_i).should =~ [2, 3]
+  end
+
+  it '_lteq' do
+    @model.elastic_ransack(int_attr_lteq: 20).map(&:id).map(&:to_i).should =~ [1, 2]
+  end
+
+end

data/spec/elastic_ransack/sorting_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe 'sorting' do
+  before :all do
+    @model = ModelSearch
+    @model.setup_index
+  end
+
+  it 'default sort by id desc' do
+    @model.elastic_ransack.map(&:id).map(&:to_i).should =~ [3, 2, 1]
+  end
+
+  it 'custom sort' do
+    @model.elastic_ransack(s: 'float_attr').map(&:id).map(&:to_i).should =~ [1, 3, 2]
+  end
+
+  it 'custom sort mode' do
+    @model.elastic_ransack(s: 'float_attr desc').map(&:id).map(&:to_i).should =~ [2, 3, 1]
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,103 @@
+require 'active_model'
+require 'tire'
+require 'active_support/core_ext'
+require 'elastic_ransack'
+
+Tire.configure do
+  logger 'tmp/elasticsearch.log'  # Commented out logger line here so that it doesn't break specs when tmp directory doesn't exist.
+  url 'http://localhost:9200'
+  pretty 1
+end
+
+class ActiveModelBase
+  include ActiveModel::AttributeMethods
+  include ActiveModel::Serialization
+  include ActiveModel::Serializers::JSON
+  include ActiveModel::Naming
+
+  extend ActiveModel::Callbacks
+  define_model_callbacks :save, :destroy
+
+  attr_reader :attributes
+  attr_accessor :id, :created_at
+
+  def initialize(attributes = {})
+    @attributes = attributes
+  end
+
+  def to_indexed_json
+    @attributes.to_json
+  end
+
+  def method_missing(id, *args, &block)
+    attributes[id.to_sym] || attributes[id.to_s] || super
+  end
+
+  def persisted?
+    true
+  end
+
+  def save
+    _run_save_callbacks do
+    end
+  end
+
+  def destroy
+    _run_destroy_callbacks do
+      @destroyed = true
+    end
+  end
+
+  def destroyed?
+    !!@destroyed
+  end
+end
+
+
+class ModelSearch < ActiveModelBase
+  include Tire::Model::Search
+  include Tire::Model::Callbacks
+
+  include ElasticRansack::Model
+
+  mapping do
+    indexes :id, type: 'integer'
+    indexes :int_attr, type: 'integer'
+  end
+
+  def self.setup_index
+    tire.index.delete
+    tire.create_elasticsearch_index
+    populate
+    tire.index.refresh
+  end
+
+  def self.test_data
+    [
+        {
+            id: 1, text: 'alex test', text_ru: 'alexandr',
+            one_assoc_id: 1, many_assoc_ids: [2, 3, 4],
+            int_attr: 10, float_attr: 5.5, created_at: 1.day.ago
+        },
+        {
+            id: 2, text: 'andrey black', text_ru: 'andrey rus',
+            one_assoc_id: 2, many_assoc_ids: [3, 4, 5, 6],
+            int_attr: 20, float_attr: 27.5, created_at: 1.month.ago
+        },
+        {
+            id: 3, text: 'mike test', text_ru: 'mike rus',
+            one_assoc_id: 2, many_assoc_ids: [10, 14, 17],
+            int_attr: 80, float_attr: 7.5, created_at: 1.hour.ago
+        }
+    ]
+  end
+
+  def self.populate
+    test_data.each do |attrs|
+      u = new(attrs)
+      u.id = attrs[:id]
+      u.save
+    end
+  end
+
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: elastic_ransack
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alex Leschenko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tire
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: rspec
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Conditions searching using predicates such as 'name_cont' or 'created_at_gt'
+  for elasticsearch models
+email:
+- leschenko.al@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- elastic_ransack.gemspec
+- lib/elastic_ransack.rb
+- lib/elastic_ransack/core_ext.rb
+- lib/elastic_ransack/model.rb
+- lib/elastic_ransack/naming.rb
+- lib/elastic_ransack/predicate.rb
+- lib/elastic_ransack/search.rb
+- lib/elastic_ransack/version.rb
+- spec/elastic_ransack/base_spec.rb
+- spec/elastic_ransack/core_ext_spec.rb
+- spec/elastic_ransack/predicate_spec.rb
+- spec/elastic_ransack/search_spec.rb
+- spec/elastic_ransack/sorting_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/leschenko/elastic_ransack
+licenses:
+- MIT
+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: Conditions searching adapter for elasticsearch models like ransack
+test_files:
+- spec/elastic_ransack/base_spec.rb
+- spec/elastic_ransack/core_ext_spec.rb
+- spec/elastic_ransack/predicate_spec.rb
+- spec/elastic_ransack/search_spec.rb
+- spec/elastic_ransack/sorting_spec.rb
+- spec/spec_helper.rb