elastic_record 0.0.1

data/README.rdoc

@@ -0,0 +1,23 @@
+Expects that your model implements find(*ids)
+
+  class Widgets
+    include ElasticRecord::Model
+  end
+
+  scope = Widgets.filter(color: 'red').order(:price)
+
+  scope.count
+  scope.first
+  scope.last
+  scope.all
+  scope.each
+
+Class methods are executed within scopes:
+
+  class Widgets
+    def self.ouput_to_screen
+      all.each do { |widget| puts widget }
+    end
+  end
+
+  scope.output_to_screen

data/lib/elastic_record.rb

@@ -0,0 +1,15 @@
+module ElasticRecord
+  autoload :Config, 'elastic_record/config'
+  autoload :Connection, 'elastic_record/connection'
+
+  autoload :Relation, 'elastic_record/relation'
+  autoload :Batches, 'elastic_record/relation/batches'
+  autoload :Delegation, 'elastic_record/relation/delegation'
+  autoload :FinderMethods, 'elastic_record/relation/finder_methods'
+  autoload :Merging, 'elastic_record/relation/merging'
+  autoload :SearchMethods, 'elastic_record/relation/search_methods'
+
+  autoload :Searching, 'elastic_record/searching'
+
+  autoload :Model, 'elastic_record/model'
+end

data/lib/elastic_record/config.rb

@@ -0,0 +1,21 @@
+module ElasticRecord
+  class Config
+    class << self
+      def servers=(value)
+        @servers = value
+      end
+
+      def servers
+        @servers
+      end
+
+      def connection_options
+        @connection_options ||= {}
+      end
+
+      def connection_options=(options)
+        @connection_options = options
+      end
+    end
+  end
+end

data/lib/elastic_record/connection.rb

@@ -0,0 +1,15 @@
+module ElasticRecord
+  module Connection
+    def elastic_connection
+      ElasticRecord::Config.connection_options
+      @elastic_connection ||= ElasticSearch.new(
+        ElasticRecord::Config.servers,
+        ElasticRecord::Config.connection_options.merge(index: model_name.collection, type: model_name.element)
+      )
+    end
+
+    def elastic_connection=(connection)
+      @elastic_connection = connection
+    end
+  end
+end

data/lib/elastic_record/model.rb

@@ -0,0 +1,21 @@
+module ElasticRecord
+  module Model
+    def self.included(base)
+      base.class_eval do
+        extend Connection
+        extend Searching
+        extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+      def relation
+        ElasticRecord::Relation.new(self, arelastic)
+      end
+
+      def arelastic
+        @arelastic ||= Arelastic::Builders::Search.new
+      end
+    end
+  end
+end

data/lib/elastic_record/orm/active_record.rb

@@ -0,0 +1,4 @@
+module ElasticRecord
+  module ActiveRecord
+  end
+end

data/lib/elastic_record/relation.rb

@@ -0,0 +1,61 @@
+# require 'elastic_record/relation/delegation'
+# require 'elastic_record/relation/finder_methods'
+# require 'elastic_record/relation/merging'
+# require 'elastic_record/relation/search_methods'
+
+module ElasticRecord
+  class Relation
+    MULTI_VALUE_METHODS  = [:extending, :filter, :facet, :order]
+    SINGLE_VALUE_METHODS = [:query, :limit, :offset]
+
+    include Batches, Delegation, FinderMethods, Merging, SearchMethods
+
+    attr_reader :klass, :arelastic, :values
+
+    def initialize(klass, arelastic)
+      @klass = klass
+      @arelastic = arelastic
+      @values = {}
+    end
+
+    def count
+      to_hits.total_entries
+    end
+
+    def facets
+      to_hits.facets
+    end
+
+    def to_a
+      @records ||= klass.find(to_ids)
+    end
+
+    def to_ids
+      to_hits.to_a.map(&:id)
+    end
+
+    def to_hits
+      @hits ||= klass.elastic_connection.search(as_elastic)#, ids_only: true)
+    end
+
+    def ==(other)
+      case other
+      when Relation
+        other.as_elastic == as_elastic
+      when Array
+        to_a == other
+      end
+    end
+
+    def inspect
+      to_a.inspect
+    end
+
+    def scoping
+      previous, klass.current_elastic_search = klass.current_elastic_search, self
+      yield
+    ensure
+      klass.current_elastic_search = previous
+    end
+  end
+end

data/lib/elastic_record/relation/batches.rb

@@ -0,0 +1,14 @@
+module ElasticRecord
+  module Batches
+    def find_each
+      options = {scroll: '20m', size: 100, search_type: 'scan'}
+
+      hits = klass.elastic_connection.search(as_elastic, options)
+
+      klass.elastic_connection.scroll(hits.scroll_id, scroll: options[:scroll], ids_only: true) do |hits|
+        records = klass.find(hits.to_a)
+        records.each { |record| yield record }
+      end
+    end
+  end
+end

data/lib/elastic_record/relation/delegation.rb

@@ -0,0 +1,18 @@
+module ElasticRecord
+  module Delegation
+    def to_ary
+      to_a.to_ary
+    end
+
+    private
+      def method_missing(method, *args, &block)
+        if klass.respond_to?(method)
+          scoping { klass.send(method, *args, &block) }
+        elsif Array.method_defined?(method)
+          to_a.send(method, *args, &block)
+        else
+          super
+        end
+      end
+  end
+end

data/lib/elastic_record/relation/finder_methods.rb

@@ -0,0 +1,25 @@
+module ElasticRecord
+  module FinderMethods
+    def find(id)
+      filter(arelastic.filter.ids(id)).to_a.first
+    end
+
+    def first
+      find_one order('_uid')
+    end
+
+    def last
+      find_one order('color' => 'reverse')
+    end
+
+    def all
+      to_a
+    end
+
+    private
+
+    def find_one(relation)
+      relation.limit(1).to_a.first
+    end
+  end
+end

data/lib/elastic_record/relation/merging.rb

@@ -0,0 +1,34 @@
+module ElasticRecord
+  module Merging
+    def merge!(other)
+      Merger.new(self, other).merge
+    end
+
+    def merge(other)
+      clone.merge!(other)
+    end
+
+    private
+      class Merger
+        attr_accessor :relation, :values
+
+        def initialize(relation, other)
+          @relation = relation
+          @values = other.values
+        end
+
+        def normal_values
+          Relation::MULTI_VALUE_METHODS + Relation::SINGLE_VALUE_METHODS
+        end
+
+        def merge
+          normal_values.each do |name|
+            value = values[name]
+            relation.send("#{name}!", value) unless value.blank?
+          end
+
+          relation
+        end
+      end
+  end
+end

data/lib/elastic_record/relation/search_methods.rb

@@ -0,0 +1,185 @@
+module ElasticRecord
+  module SearchMethods
+    Relation::MULTI_VALUE_METHODS.each do |name|
+      class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}_values                   # def filter_values
+          @values[:#{name}] || []            #   @values[:filter] || []
+        end                                  # end
+                                             #
+        def #{name}_values=(values)          # def filter_values=(values)
+          @values[:#{name}] = values         #   @values[:filter] = values
+        end                                  # end
+      CODE
+    end
+
+    Relation::SINGLE_VALUE_METHODS.each do |name|
+      class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}_value                    # def offset_value
+          @values[:#{name}]                  #   @values[:offset]
+        end                                  # end
+
+        def #{name}_value=(value)            # def offset_value=(value)
+          @values[:#{name}] = value          #   @values[:offset] = value
+        end                                  # end
+      CODE
+    end
+    
+    def query!(value)
+      self.query_value = value
+      self
+    end
+
+    def query(value)
+      clone.query! value
+    end
+
+    def filter!(*args)
+      self.filter_values += args.flatten
+      self
+    end
+
+    def filter(*args)
+      clone.filter!(*args)
+    end
+
+    def limit!(value)
+      self.limit_value = value
+      self
+    end
+
+    def limit(value)
+      clone.limit!(value)
+    end
+
+    def offset!(value)
+      self.offset_value = value
+      self
+    end
+
+    def offset(value)
+      clone.offset! value
+    end
+
+    def facet!(name_or_facet, options = {})
+      if name_or_facet.is_a?(String)
+        self.facet_values += [arelastic.facet[name_or_facet].terms(name_or_facet, options)]
+      else
+        self.facet_values += [name_or_facet]
+      end
+
+      self
+    end
+
+    def facet(facet_or_name, options = {})
+      clone.facet! facet_or_name, options = {}
+    end
+
+    def order!(*args)
+      self.order_values += args.flatten
+      self
+    end
+
+    def order(*args)
+      clone.order! *args
+    end
+
+    def extending!(*modules, &block)
+      modules << Module.new(&block) if block_given?
+
+      self.extending_values += modules.flatten
+      extend(*extending_values)
+
+      self
+    end
+
+    def extending(*modules, &block)
+      clone.extending!(*modules, &block)
+    end
+
+    def as_elastic
+      build_search.as_elastic
+    end
+
+    private
+      def build_search
+        searches = [
+          build_query_and_filter(query_value, filter_values),
+          build_limit(limit_value),
+          build_offset(offset_value),
+          build_facets(facet_values),
+          build_orders(order_values)
+        ].compact
+
+        Arelastic::Nodes::HashGroup.new searches
+      end
+
+      def build_query_and_filter(query, filters)
+        query = build_query(query)
+        filter = build_filter(filters)
+        if query && filter
+          arelastic.query.filtered(query, filter)
+        elsif query
+          query
+        elsif filter
+          arelastic.query.constant_score(filter)
+        else
+          arelastic.query.match_all
+        end
+      end
+
+      def build_query(query)
+        if query.is_a?(String)
+          query = Arelastic::Queries::QueryString.new query
+        end
+
+        if query
+          Arelastic::Searches::Query.new query
+        end
+      end
+
+      def build_filter(filters)
+        nodes = []
+
+        filters.map do |filter|
+          if filter.is_a?(Arelastic::Filters::Filter)
+            nodes << filter
+          else
+            filter.each do |field, terms|
+              case terms
+              when Array, Range
+                nodes << arelastic[field].in(terms)
+              else
+                nodes << arelastic[field].eq(terms)
+              end
+            end
+          end
+        end
+
+        if nodes.size == 1
+          Arelastic::Searches::Filter.new nodes.first
+        elsif nodes.size > 1
+          Arelastic::Searches::Filter.new Arelastic::Filters::And.new(nodes)
+        end
+      end
+
+      def build_limit(limit)
+        if limit
+          Arelastic::Searches::Size.new(limit)
+        end
+      end
+
+      def build_offset(offset)
+        if offset
+          Arelastic::Searches::From.new(offset)
+        end
+      end
+
+      def build_facets(facets)
+        Arelastic::Searches::Facets.new(facets) unless facets.empty?
+      end
+
+      def build_orders(orders)
+        Arelastic::Searches::Sort.new(orders) unless orders.empty?
+      end
+  end
+end

data/lib/elastic_record/searching.rb

@@ -0,0 +1,30 @@
+module ElasticRecord
+  module Searching
+    def elastic_search
+      if current_elastic_search
+        current_elastic_search.clone
+      else
+        relation
+      end
+    end
+
+    def elastic_scope(name, body, &block)
+      extension = Module.new(&block) if block
+
+      singleton_class.send(:define_method, name) do |*args|
+        relation = body.call(*args)
+        relation = elastic_search.merge(relation)
+
+        extension ? relation.extending(extension) : relation
+      end
+    end
+
+    def current_elastic_search #:nodoc:
+      Thread.current["#{self}_current_elastic_search"]
+    end
+
+    def current_elastic_search=(relation) #:nodoc:
+      Thread.current["#{self}_current_elastic_search"] = relation
+    end
+  end
+end

data/test/elastic_record/config_test.rb

@@ -0,0 +1,4 @@
+require 'helper'
+
+class ElasticRecord::ConfigTest < MiniTest::Spec
+end

data/test/elastic_record/connection_test.rb

@@ -0,0 +1,10 @@
+require 'helper'
+
+class ElasticRecord::ConnectionTest < MiniTest::Spec
+  def test_elastic_connection
+    connection = Widget.elastic_connection
+
+    assert_equal 'widget', connection.default_type
+    assert_equal 'widgets', connection.default_index
+  end
+end

data/test/elastic_record/model_test.rb

@@ -0,0 +1,10 @@
+require 'helper'
+
+class ElasticRecord::ModelTest < MiniTest::Spec
+  def test_relation
+    relation = Widget.relation
+
+    assert_equal Widget, relation.klass
+    assert_equal Widget.arelastic, relation.arelastic
+  end
+end

data/test/elastic_record/relation/batches_test.rb

@@ -0,0 +1,33 @@
+require 'helper'
+
+class ElasticRecord::Relation::BatchesTest < MiniTest::Spec
+  def setup
+    Widget.reset_index!
+    create_widgets
+  end
+
+  def test_find_each
+    results = []
+    Widget.relation.find_each do |widget|
+      results << widget.id
+    end
+    assert_equal ['5', '10', '15'].to_set, results.to_set
+  end
+
+  def test_find_each_with_scope
+    results = []
+    Widget.relation.filter(color: %w(red blue)).find_each do |widget|
+      results << widget.id
+    end
+    assert_equal ['5', '10'].to_set, results.to_set
+  end
+
+  private
+    def create_widgets
+      Widget.elastic_connection.index({'widget' => {'color' => 'red'}}, {index: 'widgets', type: 'widget', id: 5})
+      Widget.elastic_connection.index({'widget' => {'color' => 'blue'}}, {index: 'widgets', type: 'widget', id: 10})
+      Widget.elastic_connection.index({'widget' => {'color' => 'green'}}, {index: 'widgets', type: 'widget', id: 15})
+      
+      Widget.elastic_connection.refresh
+    end
+end

data/test/elastic_record/relation/delegation_test.rb

@@ -0,0 +1,32 @@
+require 'helper'
+
+class ElasticRecord::Relation::DelegationTest < MiniTest::Spec
+  def setup
+    Widget.reset_index!
+  end
+
+  def test_delegate_to_array
+    Widget.elastic_connection.index({'widget' => {'color' => 'red'}}, {index: 'widgets', type: 'widget', id: 5})
+    Widget.elastic_connection.refresh
+    
+    records = []
+    Widget.relation.each do |record|
+      records << record
+    end
+
+    assert_equal 1, records.size
+  end
+
+  def test_delegate_to_klass
+    model = Class.new(Widget) do
+      def self.do_it
+        elastic_search.as_elastic
+      end
+    end
+
+    result = model.relation.filter('foo' => 'bar').do_it
+
+    expected = {"query"=>{"constant_score"=>{"filter"=>{"term"=>{"foo"=>"bar"}}}}}
+    assert_equal expected, result 
+  end
+end

data/test/elastic_record/relation/finder_methods_test.rb

@@ -0,0 +1,42 @@
+require 'helper'
+
+class ElasticRecord::Relation::FinderMethodsTest < MiniTest::Spec
+  def setup
+    Widget.reset_index!
+    create_widgets
+  end
+
+  def test_find
+    refute_nil Widget.relation.find('05')
+    refute_nil Widget.relation.filter('color' => 'red').find('05')
+    assert_nil Widget.relation.filter('color' => 'blue').find('05')
+  end
+
+  def test_first
+    assert_equal '05', Widget.relation.first.id
+    assert_equal '05', Widget.relation.filter('color' => 'red').first.id
+    assert_equal '10', Widget.relation.filter('color' => 'blue').first.id
+    assert_nil Widget.relation.filter('color' => 'green').first
+  end
+
+  def test_last
+    assert_equal '10', Widget.relation.last.id
+    assert_equal '05', Widget.relation.filter('color' => 'red').last.id
+    assert_equal '10', Widget.relation.filter('color' => 'blue').last.id
+    assert_nil Widget.relation.filter('color' => 'green').last
+  end
+
+  def test_all
+    assert_equal 2, Widget.relation.all.size
+    assert_equal 1, Widget.relation.filter('color' => 'red').all.size
+  end
+
+  private
+
+    def create_widgets
+      Widget.elastic_connection.index({'widget' => {'color' => 'red'}}, {index: 'widgets', type: 'widget', id: '05'})
+      Widget.elastic_connection.index({'widget' => {'color' => 'blue'}}, {index: 'widgets', type: 'widget', id: '10'})
+      
+      Widget.elastic_connection.refresh
+    end
+end

data/test/elastic_record/relation/merging_test.rb

@@ -0,0 +1,21 @@
+require 'helper'
+
+class ElasticRecord::Relation::MergingTest < MiniTest::Spec
+  def test_merge_single_values
+    relation = Widget.relation.limit(5)
+    other = Widget.relation.limit(10)
+
+    relation.merge! other
+
+    assert_equal 10, relation.limit_value
+  end
+
+  def test_merge_multi_values
+    relation = Widget.relation.filter(color: 'green')
+    other = Widget.relation.filter(weight: 1.0)
+
+    relation.merge! other
+
+    assert_equal [{color: 'green'}, {weight: 1.0}], relation.filter_values
+  end
+end

data/test/elastic_record/relation/search_methods_test.rb

@@ -0,0 +1,157 @@
+require 'helper'
+
+class ElasticRecord::Relation::SearchMethodsTest < MiniTest::Spec
+  def test_query_with_no_queries
+    expected = {"match_all" => {}}
+
+    assert_equal expected, relation.as_elastic['query']
+  end
+
+  def test_query_with_multiple_filters
+    relation.filter!('foo' => 'bar')
+    relation.filter!(Widget.arelastic['faz'].in ['baz', 'fum'])
+    
+    expected = {
+      "constant_score" => {
+        "filter" => {
+          "and" => [
+            {"term"   => {"foo" => "bar"}},
+            {"terms"  => {"faz" => ["baz", "fum"]}}
+          ]
+        }
+      }
+    }
+
+    assert_equal expected, relation.as_elastic['query']
+  end
+
+  def test_query_with_range_filter
+    relation.filter!(Widget.arelastic['faz'].in 3..5)
+    
+    expected = {
+      "constant_score" => {
+        "filter" => {
+          "range" => {
+            "faz" => {"gte"=>3, "lte"=>5}
+          }
+        }
+      }
+    }
+
+    assert_equal expected, relation.as_elastic['query']
+  end
+
+  def test_query_with_only_query
+    relation.query!('foo')
+
+    expected = {"query_string" => {"query" => "foo"}}
+
+    assert_equal expected, relation.as_elastic['query']
+  end
+
+  def test_query_with_both_filter_and_query
+    relation.query!('field' => {'name' => 'joe'})
+    relation.filter!(Widget.arelastic['name'].prefix "mat")
+
+    expected = {
+      "filtered" => {
+        "query" => {
+          "field" => {
+            "name"=>"joe"
+          },
+        },
+        "filter" => {
+          "prefix" => {
+            "name" => "mat"
+          }
+        }
+      }
+    }
+
+    assert_equal expected, relation.as_elastic['query']
+  end
+
+  def test_facet_with_arelastic
+    relation.facet!(Widget.arelastic.facet['popular_tags'].histogram('field' => 'field_name', 'interval' => 100))
+
+    expected = {
+      "popular_tags" => {
+        "histogram" =>
+        {
+          "field" => "field_name",
+          "interval" => 100
+        }
+      }
+    }
+
+    assert_equal expected, relation.as_elastic['facets']
+  end
+
+  def test_facet_with_string
+    relation.facet!('tags', 'size' => 10)
+
+    expected = {
+      "tags" => {
+        "terms" => {
+          "field" => "tags",
+          "size"  => 10
+        }
+      }
+    }
+
+    assert_equal expected, relation.as_elastic['facets']
+  end
+
+  def test_limit
+    relation.limit!(5)
+
+    expected = 5
+    assert_equal expected, relation.as_elastic['size']
+  end
+
+  def test_offset
+    relation.offset!(42)
+
+    expected = 42
+    assert_equal expected, relation.as_elastic['from']
+  end
+
+  def test_order
+    relation.order! 'foo'
+    relation.order! 'bar' => 'desc'
+
+    expected = [
+      'foo',
+      'bar' => 'desc'
+    ]
+
+    assert_equal expected, relation.as_elastic['sort']
+  end
+
+  def test_extending_with_block
+    relation.extending! do
+      def foo
+        'foo'
+      end
+    end
+
+    assert_equal 'foo', relation.foo
+  end
+
+  def test_extending_with_module
+    mod = Module.new do
+      def bar
+        'bar'
+      end
+    end
+
+    relation.extending! mod
+
+    assert_equal 'bar', relation.bar
+  end
+
+  private
+    def relation
+      @relation ||= Widget.relation
+    end
+end

data/test/elastic_record/relation_test.rb

@@ -0,0 +1,52 @@
+require 'helper'
+
+class ElasticRecord::RelationTest < MiniTest::Spec
+  def setup
+    Widget.reset_index!
+    create_widgets
+  end
+
+  def test_to_hits
+    assert Widget.relation.to_hits.is_a?(ElasticSearch::Api::Hits)
+  end
+
+  def test_to_ids
+    assert_equal ['5', '10'], Widget.relation.to_ids
+  end
+
+  def test_to_a
+    array = Widget.relation.to_a
+
+    assert_equal 2, array.size
+    assert array.first.is_a?(Widget)
+  end
+
+  def test_count
+    assert_equal 2, Widget.relation.count
+  end
+
+  def test_facets
+    facets = Widget.relation.facet(Widget.arelastic.facet['popular_colors'].terms('color')).facets
+
+    assert_equal 2, facets['popular_colors']['total']
+  end
+
+  def test_equal
+    assert(Widget.relation.filter(color: 'green') == Widget.relation.filter(color: 'green'))
+    assert(Widget.relation.filter(color: 'green') != Widget.relation.filter(color: 'blue'))
+
+    assert(Widget.relation.filter(color: 'magenta') == [])
+  end
+
+  def test_inspect
+    assert_equal [].inspect, Widget.relation.filter(color: 'magenta').inspect
+  end
+
+  private
+    def create_widgets
+      Widget.elastic_connection.index({'widget' => {'color' => 'red'}}, {index: 'widgets', type: 'widget', id: 5})
+      Widget.elastic_connection.index({'widget' => {'color' => 'blue'}}, {index: 'widgets', type: 'widget', id: 10})
+      
+      Widget.elastic_connection.refresh
+    end
+end

data/test/elastic_record/searching_test.rb

@@ -0,0 +1,22 @@
+require 'helper'
+
+class ElasticRecord::SearchingTest < MiniTest::Spec
+  def test_elastic_search
+    
+  end
+
+  def test_elastic_scope
+    model = Class.new(Widget) do
+      elastic_scope :by_color, ->(color) { elastic_search.filter(color: color) } do
+        def negative_offset
+          -offset_value
+        end
+      end
+    end
+
+    relation = model.by_color('blue')
+
+    assert_equal model.relation.filter(color: 'blue'), relation
+    assert_equal -5, relation.offset(5).negative_offset
+  end
+end

data/test/helper.rb

@@ -0,0 +1,16 @@
+require 'bundler/setup'
+Bundler.require
+
+require 'minitest/autorun'
+
+require 'rubberband'
+require 'active_support/core_ext/object/blank'
+require 'active_model'
+
+require 'support/widget'
+require 'support/connect'
+
+module MiniTest
+  class Spec
+  end
+end

data/test/support/connect.rb

@@ -0,0 +1 @@
+ElasticRecord::Config.servers = '127.0.0.1:9200'

data/test/support/widget.rb

@@ -0,0 +1,39 @@
+class Widget
+  extend ActiveModel::Naming
+  include ElasticRecord::Model
+
+  class << self
+    def find(ids)
+      ids.map { |id| new(id: id, color: 'red') }
+    end
+
+
+    def reset_index!
+      elastic_connection.delete_index('widgets')
+      elastic_connection.create_index('widgets')
+      elastic_connection.update_mapping(
+        {
+          properties: {
+            color: {
+              type: 'string',
+              index: 'not_analyzed'
+            }
+          },
+          _source: {
+            enabled: false
+          }
+        },  
+        {
+          index: 'widgets'
+        }
+      )
+    end
+  end
+
+  attr_accessor :id, :color
+  def initialize(attributes = {})
+    attributes.each do |key, val|
+      send("#{key}=", val)
+    end
+  end
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: elastic_record
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Matthew Higgins
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: arelastic
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubberband
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Find your records with elastic search
+email: developer@matthewhiggins.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- lib/elastic_record/config.rb
+- lib/elastic_record/connection.rb
+- lib/elastic_record/model.rb
+- lib/elastic_record/orm/active_record.rb
+- lib/elastic_record/relation/batches.rb
+- lib/elastic_record/relation/delegation.rb
+- lib/elastic_record/relation/finder_methods.rb
+- lib/elastic_record/relation/merging.rb
+- lib/elastic_record/relation/search_methods.rb
+- lib/elastic_record/relation.rb
+- lib/elastic_record/searching.rb
+- lib/elastic_record.rb
+- test/elastic_record/config_test.rb
+- test/elastic_record/connection_test.rb
+- test/elastic_record/model_test.rb
+- test/elastic_record/relation/batches_test.rb
+- test/elastic_record/relation/delegation_test.rb
+- test/elastic_record/relation/finder_methods_test.rb
+- test/elastic_record/relation/merging_test.rb
+- test/elastic_record/relation/search_methods_test.rb
+- test/elastic_record/relation_test.rb
+- test/elastic_record/searching_test.rb
+- test/helper.rb
+- test/support/connect.rb
+- test/support/widget.rb
+- README.rdoc
+homepage: http://github.com/matthuhiggins/elastic_record
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.11
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Use Elastic Search with your objects
+test_files: []