stretchie 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 027f752423a87c8f0e75f9d8b137b0a1d3542bed
+  data.tar.gz: be1f1ca84334a7b2a7fdc0456d0263b27d9529ec
+SHA512:
+  metadata.gz: 8362eaead32327b7a0c4c6c1e282bbaa566e364c695b954aec94207695ac1e453f3f0add51895b3251a9bec09300cfbed2bdcf20b0e6d79d8549e330d5b0fc0d
+  data.tar.gz: bac222dde6a7d2cc3406661ec3c3dc63d579173a1b6f820e45506a267b881e0acb38572d51e62203d58a25921e7b3a5a64d50d02e598b77be0dd86b9194dac43

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.DS_Store
+

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--require spec_helper
+--format documentation

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Adam Bregenzer
+
+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,187 @@
+Stretchie
+=========
+
+Comfortable searching pants for ActiveRecord Models. Stretchie simplifies
+using elastic search in your models and provides hooks to ease testing.
+
+
+Defining Indices
+----------------
+
+Stretchie simply builds on elasticsearch-model, allowing you to pull the
+details out into a concern.
+
+With a model like this:
+```ruby
+class User < ActiveRecord::Base
+  attr_accessor :name, :email, :misc_id
+end
+```
+
+Your concern could look like this:
+```ruby
+module Search
+  module User
+    extend ActiveSupport::Concern
+    include Stretchie::Pants
+
+    included do
+      settings index: { number_of_shards: 1 } do
+        mappings dynamic: 'false' do
+          indexes :name, analyzer: 'whitespace', index_options: 'offsets'
+          indexes :email
+          indexes :misc_id
+          indexes :sortable_name
+        end
+      end
+    end
+
+    def as_indexed_json(options={})
+      json = as_json(only: [:name, :email, :misc_id])
+      json['sortable_name'] = self.name.downcase
+      json
+    end
+  end
+end
+```
+
+And you would add this to your model:
+```ruby
+include Search::User
+```
+
+If you have liked models, you can have them re-index automatically with `index_dependent_models`:
+```ruby
+class User < ActiveRecord::Base
+  include Search::User
+  attr_accessor :name, :email
+  has_may :tags
+end
+
+class Tag < ActiveRecord::Base
+  include Search::Tag
+  attr_accessor :name
+
+  belongs_to :user
+end
+
+module Search
+  module Tag
+    extend ActiveSupport::Concern
+    include Stretchie::Pants
+
+    included do
+      settings index: { number_of_shards: 1 } do
+        mappings dynamic: 'false' do
+          indexes :name, analyzer: 'whitespace', index_options: 'offsets'
+          indexes :sortable_name
+        end
+      end
+    end
+
+    def as_indexed_json(options={})
+      json = as_json(only: [:name])
+      json['sortable_name'] = self.name.downcase
+      json
+    end
+
+    def index_dependent_models
+        self.users
+    end
+  end
+end
+```
+
+
+Maintaining Indices
+-------------------
+
+Create / Update your indices:
+```ruby
+Stretchie.update_indices
+Stretchie.update_indices :users
+```
+
+Delete your indices:
+```ruby
+Stretchie.delete_indices
+Stretchie.delete_indices :users
+```
+
+Refresh your indices:
+```ruby
+Stretchie.refresh_indices
+Stretchie.refresh_indices :users
+```
+
+
+Maintaining Documents in the Index
+----------------------------------
+
+To add or update changes:
+```ruby
+user = User.create(name: 'Adam Bregenzer', email: 'adam@bregenzer.net')
+user.update_in_index
+```
+
+To remove:
+```ruby
+user.delete_from_index
+```
+
+
+Searching
+---------
+
+You can do a simple search:
+```ruby
+User.search 'Adam'
+User.search 'Adam', limit: 10, skip: 20, order: {'name' => 'asc'}
+```
+
+You can scope searches:
+```ruby
+Tag.search 'rails', terms: {'user_id': current_user.id}
+```
+
+You can search specific fields:
+```ruby
+User.field_search :email, 'adam@bregenzer.net'
+```
+
+You can search however you want:
+```ruby
+User.query_search {'match' => {'name' => 'Foo'}}
+```
+
+
+Talk to Me!
+-----------
+
+Let me know what you think, if you use it, etc.
+
+
+Installation
+------------
+
+Add this line to your application's Gemfile:
+
+    gem 'stretchie'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install stretchie
+
+
+Contributing
+------------
+
+1. Fork it ( https://github.com/adambregenzer/stretchie/fork )
+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 a new Pull Request

data/Rakefile

@@ -0,0 +1,4 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)

data/lib/stretchie/pants.rb

@@ -0,0 +1,219 @@
+require 'active_support'
+require 'elasticsearch/model'
+
+module Stretchie
+  module Pants
+    extend ActiveSupport::Concern
+
+    included do
+      include Elasticsearch::Model
+
+
+      # Add the current model to the list of searchable models
+      Stretchie::add_model self
+
+      # Have the index name include the rails environment
+      index_name "#{document_type}-#{ENV['RAILS_ENV']}"
+    end
+
+
+    # Update the document in the ElasticSearch index
+    def update_in_index
+      __elasticsearch__.index_document
+
+      index_dependent_models.map(&:update_in_index)
+    end
+
+
+    # Delete the document from the ElasticSearch index
+    def delete_from_index
+      begin
+        __elasticsearch__.delete_document
+      rescue Elasticsearch::Transport::Transport::Errors::NotFound
+        nil
+      end
+
+      index_dependent_models.map(&:update_in_index)
+    end
+
+
+    # Override to trigger dependent models to be re-indexed, should return
+    # an array of models to run .update_in_index on.
+    def index_dependent_models
+      []
+    end
+
+
+    module ClassMethods
+
+      # Search the index for a matching term
+      def search(q, options={})
+        fields = options.fetch(:fields, nil)
+
+        query_string = {'query' => q}
+
+        # If asked, limit the search to specific fields
+        if !fields.nil?
+          if !fields.kind_of? Array
+            fields = [fields.to_s]
+          end
+
+          query_string['fields'] = fields
+        end
+
+        # Perform a default query search
+        query = {
+          'bool' => {
+            'must' => [{'query_string' => query_string}]
+          }
+        }
+
+        begin
+          run_query query, options
+        rescue Elasticsearch::Transport::Transport::Errors::BadRequest
+          # This is probably because the query couldn't be parsed, clean it up
+          # and try again
+          query_string['query'] = sanitize(query_string['query'])
+
+          run_query query, options
+        end
+      end
+
+
+      # Search the specified field for a match
+      def field_search(field, q, options={})
+        # Search for a match based on prefix or a string match as a backup
+        query = {
+          'bool' => {
+            'minimum_should_match' => 1,
+            'should' => [
+              {'prefix' => {field => q}},
+              {'match'  => {field => q}}
+            ]
+          }
+        }
+
+        run_query query, options
+      end
+
+
+      # Execute a query hash in ElasticSearch
+      def query_search(query, options={})
+        run_query query, options
+      end
+
+
+      #
+      # Private Methods
+      #
+
+
+      # Run a query hash in ElasticSearch
+      def run_query(query, options={})
+        query = prepare_query query, options
+
+        # Run the query
+        response = self.__elasticsearch__.search query
+
+        Hashie::Mash.new({
+          records: response.records,
+          total_entries: response.results.total
+        })
+      end
+      private :run_query
+
+
+      # sanitize query string for Lucene. Useful if the original query raises an
+      # exception due to invalid DSL parse.
+      #
+      # http://stackoverflow.com/questions/16205341/symbols-in-query-string-for-elasticsearch
+      #
+      # @return self [Stretchie::QueryString] the modified QueryString.
+      def sanitize(q)
+        # Escape special characters
+        # http://lucene.apache.org/core/4_8_1/queryparser/org/apache/lucene/queryparser/classic/package-summary.html#package_description#Escaping_Special_Characters
+        escaped_characters = Regexp.escape('\\+-&|!(){}[]^~*?:\/')
+        q = q.gsub(/([#{escaped_characters}])/, '\\\\\1')
+
+        # AND, OR and NOT are used by lucene as logical operators. We need
+        # to escape them
+        ['AND', 'OR', 'NOT'].each do |word|
+          escaped_word = word.split('').map {|char| "\\#{char}" }.join('')
+          q = q.gsub(/\s*\b(#{word.upcase})\b\s*/, " #{escaped_word} ")
+        end
+
+        # Escape odd quotes
+        if q.count('"') % 2 == 1
+          q = q.gsub(/(.*)"(.*)/, '\1\"\2')
+        end
+
+        q
+      end
+      private :sanitize
+
+
+      # Prepare a query hash for ElasticSearch
+      def prepare_query(q_hash, options={})
+        terms = options.fetch(:terms, {})
+        limit = options.fetch(:limit, -1)
+        skip  = options.fetch(:skip,  -1)
+        order = options.fetch(:order, {})
+
+        # Load the query but don't return any field data since we don't need it
+        query = {
+          'fields' => [],
+          'query'  => q_hash
+        }
+
+        # If we have terms that must match (such as user_id) set them
+        if terms.length > 0
+          if q_hash.include?('term')
+            q_hash['term'].merge! terms
+          else
+            if q_hash.include?('bool')
+              if !q_hash['bool'].include?('must')
+                q_hash['bool']['must'] = []
+              end
+
+              q_hash['bool']['must'] << {term: terms}
+            else
+              query['query'] = {
+                'bool' => {
+                  'must' => [q_hash]
+                }
+              }
+
+              query['query']['bool']['must'] << {term: terms}
+            end
+          end
+        end
+
+        # Set the limit
+        if limit > 0
+          query['size'] = limit
+        end
+
+        # Set the number of records to skip
+        if skip > 0
+          query['from'] = skip
+        end
+
+        # Set the sort order, sorting by _score last
+        if !query.include? 'sort'
+          query['sort'] = []
+        end
+
+        order.map do |k, v|
+          query['sort'] << {k => v}
+        end
+
+        if query['sort'].select { |x| x.keys.first == '_score' }.count == 0
+          query['sort'] << {'_score' => 'desc'}
+        end
+
+        query
+      end
+      private :prepare_query
+    end
+  end
+end

data/lib/stretchie/version.rb

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

data/lib/stretchie.rb

@@ -0,0 +1,107 @@
+require 'set'
+
+# ElasticSearch
+# require 'elasticsearch'
+
+# Stretchie Core
+require 'stretchie/version'
+
+# Lets put our Stretchie::Pants on
+require 'stretchie/pants'
+
+
+# Defaults
+module Stretchie
+
+  # Set containing all registered models
+  @@models = Set.new
+
+
+  # Add a model to the set
+  def self.add_model model
+    @@models << model
+  end
+
+
+  # Returns a set containing all registered models
+  def self.models
+    @@models
+  end
+
+
+  # Create or update all indices across all registered models
+  def self.update_indices(*args)
+    result = true
+
+    if args.length > 0
+      args = args.map { |m| m.to_s.singularize.capitalize.constantize }
+      _models = models.select { |m| args.include? m }
+    else
+      _models = models
+    end
+
+    _models.map do |m|
+      create = m.__elasticsearch__.create_index!
+      if !create.nil?
+        result &= create['acknowledged']
+      else
+        m.mappings.to_hash.map do |map, body|
+          client = m.__elasticsearch__.client
+          update = client.indices.put_mapping index: m.index_name, type: map,
+            body: {map => body}
+
+          if update.kind_of?(Hash)
+            result &= update['acknowledged']
+          end
+        end
+      end
+    end
+
+    result
+  end
+
+
+  # Refresh all indices across all registered models
+  def self.refresh_indices(*args)
+    result = true
+
+    if args.length > 0
+      args = args.map { |m| m.to_s.singularize.capitalize.constantize }
+      _models = models.select { |m| args.include? m }
+    else
+      _models = models
+    end
+
+    _models.map do |m|
+      refresh = m.__elasticsearch__.refresh_index!
+      if refresh.kind_of?(Hash) && refresh.include?('_shards')
+        result &= refresh['_shards']['failed'] == 0
+      end
+    end
+
+    result
+  end
+
+
+  # Delete all indices across all registered models
+  def self.delete_indices(*args)
+    result = true
+
+    if args.length > 0
+      args = args.map { |m| m.to_s.singularize.capitalize.constantize }
+      _models = models.select { |m| args.include? m }
+    else
+      _models = models
+    end
+
+    _models.map do |m|
+      delete = m.__elasticsearch__.delete_index!
+
+      if !delete.nil?
+        result &= delete['acknowledged']
+      end
+    end
+
+    result
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/spec/'
+end
+
+ENV['RAILS_ENV'] ||= 'test'
+
+require_relative '../lib/stretchie'
+
+pwd = File.expand_path File.dirname(__FILE__)
+Dir[File.join(pwd, 'support/**/*.rb')].each { |f| require_relative f }
+
+RSpec.configure do |config|
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+
+  config.order = :random
+  Kernel.srand config.seed
+end
+

data/spec/stretchie_pants_spec.rb

@@ -0,0 +1,225 @@
+#encoding: UTF-8
+
+describe Stretchie::Pants do
+
+  before :each do
+    @user = User.create(name: 'Foo Bar', email: 'baz@baz.com', misc_id: 100)
+    @user.update_in_index
+    @user1 = User.create(name: 'Red Green', email: 'blue@white.com' )
+    @user1.update_in_index
+    @user2 = User.create(name: 'Red Purple', email: 'red@white.com' )
+    @user2.update_in_index
+    Stretchie.refresh_indices
+  end
+
+
+  context '.delete_from_index' do
+    it 'removes document from index' do
+      @user.delete_from_index
+      Stretchie.refresh_indices
+      results = User.search 'Foo'
+      results = results.records.to_a
+      expect(results.length).to eq(0)
+      expect(results).to eq([])
+      @user.delete_from_index
+    end
+  end
+  context '.update_in_index' do
+    it 'adds documents to the index' do
+      @user.delete_from_index
+      Stretchie.refresh_indices
+      results = User.search 'Foo'
+      results = results.records.to_a
+      expect(results.length).to eq(0)
+      expect(results).to eq([])
+
+      @user.update_in_index
+      Stretchie.refresh_indices
+      results = User.search 'Foo'
+      results = results.records.to_a
+      expect(results.length).to eq(1)
+      expect(results).to eq([@user])
+    end
+  end
+
+  context '.search' do
+
+    it 'searches all fields' do
+      results = User.search 'Foo'
+      results = results.records.to_a
+      expect(results.length).to eq(1)
+      expect(results).to eq([@user])
+
+      results = User.search 'baz@baz.com'
+      results = results.records.to_a
+      expect(results.length).to eq(1)
+      expect(results).to eq([@user])
+    end
+
+    it 'searches all fields with invalid query characters' do
+      results = User.search 'Foo"'
+      results = results.records.to_a
+      expect(results.length).to eq(1)
+      expect(results).to eq([@user])
+    end
+
+    it 'searches specific fields' do
+      results = User.search 'Foo', fields: :name
+      results = results.records.to_a
+      expect(results.length).to eq(1)
+      expect(results).to eq([@user])
+    end
+
+    it 'requires specific terms' do
+      results = User.search 'baz@baz.com', terms: {misc_id: 100}
+      results = results.records.to_a
+      expect(results.length).to eq(1)
+      expect(results).to eq([@user])
+    end
+
+    it 'supports limit' do
+      results = User.search 'Red', limit: 1, order: {'name' => 'asc'}
+      results = results.records.to_a
+      expect(results.length).to eq(1)
+      expect(results).to eq([@user1])
+    end
+
+    it 'supports skip' do
+      results = User.search 'Red', limit: 1, skip: 1, order: {'name' => 'asc'}
+      results = results.records.to_a
+      expect(results.length).to eq(1)
+      expect(results).to eq([@user2])
+    end
+
+    it 'supports order' do
+      results = User.search 'Red', order: {'name' => 'asc'}
+      results = results.records.to_a
+      expect(results.length).to eq(2)
+      expect(results).to eq([@user1, @user2])
+    end
+  end
+
+
+  context '.field_search' do
+    it 'searches all fields' do
+      results = User.field_search :name, 'Foo'
+      results = results.records.to_a
+      expect(results.length).to eq(1)
+      expect(results).to eq([@user])
+
+      results = User.field_search :name, 'baz@baz.com'
+      results = results.records.to_a
+      expect(results.length).to eq(0)
+      expect(results).to eq([])
+    end
+
+    it 'requires specific terms' do
+      results = User.field_search :name, 'Foo', terms: {misc_id: 100}
+      results = results.records.to_a
+      expect(results.length).to eq(1)
+      expect(results).to eq([@user])
+    end
+
+    it 'supports limit' do
+      results = User.field_search :name, 'Red', limit: 1, order: {'name' => 'asc'}
+      results = results.records.to_a
+      expect(results.length).to eq(1)
+      expect(results).to eq([@user1])
+    end
+
+    it 'supports skip' do
+      results = User.field_search :name, 'Red', limit: 1, skip: 1, order: {'name' => 'asc'}
+      results = results.records.to_a
+      expect(results.length).to eq(1)
+      expect(results).to eq([@user2])
+    end
+
+    it 'supports order' do
+      results = User.field_search :name, 'Red', order: {'name' => 'asc'}
+      results = results.records.to_a
+      expect(results.length).to eq(2)
+      expect(results).to eq([@user1, @user2])
+    end
+  end
+
+
+  context '.query_search' do
+    it 'performs a custom search' do
+      query = {
+        'match' => {
+            'name' => 'Foo'
+        }
+      }
+
+      results = User.query_search query
+      results = results.records.to_a
+      expect(results.length).to eq(1)
+      expect(results).to eq([@user])
+    end
+
+    it 'requires specific terms' do
+      query = {
+        'match' => {
+            'name' => 'Foo'
+        }
+      }
+
+      results = User.query_search query, terms: {misc_id: 100}
+      results = results.records.to_a
+      expect(results.length).to eq(1)
+      expect(results).to eq([@user])
+    end
+
+    it 'requires additional terms' do
+      query = {
+        'term' => {
+            'name' => 'Foo'
+        }
+      }
+
+      results = User.query_search query, terms: {misc_id: 100}
+      results = results.records.to_a
+      expect(results.length).to eq(1)
+      expect(results).to eq([@user])
+    end
+
+    it 'supports limit' do
+      query = {
+        'match' => {
+            'name' => 'Red'
+        }
+      }
+
+      results = User.query_search query, limit: 1, order: {'name' => 'asc'}
+      results = results.records.to_a
+      expect(results.length).to eq(1)
+      expect(results).to eq([@user1])
+    end
+
+    it 'supports skip' do
+      query = {
+        'match' => {
+            'name' => 'Red'
+        }
+      }
+
+      results = User.query_search query, limit: 1, skip: 1, order: {'name' => 'asc'}
+      results = results.records.to_a
+      expect(results.length).to eq(1)
+      expect(results).to eq([@user2])
+    end
+
+    it 'supports order' do
+      query = {
+        'match' => {
+            'name' => 'Red'
+        }
+      }
+
+      results = User.query_search query, order: {'name' => 'asc'}
+      results = results.records.to_a
+      expect(results.length).to eq(2)
+      expect(results).to eq([@user1, @user2])
+    end
+  end
+end

data/spec/stretchie_spec.rb

@@ -0,0 +1,83 @@
+#encoding: UTF-8
+
+describe Stretchie do
+
+  context '.update_indices' do
+
+    it 'creates all indices' do
+      Stretchie.delete_indices
+      indices = User.__elasticsearch__.client.indices.status['indices'].keys
+      expect(indices).not_to include(User.index_name)
+      result = Stretchie.update_indices
+      expect(result).to eq(true)
+      indices = User.__elasticsearch__.client.indices.status['indices'].keys
+      expect(indices).to include(User.index_name)
+    end
+
+    it 'creates specific indices' do
+      Stretchie.delete_indices
+      indices = User.__elasticsearch__.client.indices.status['indices'].keys
+      expect(indices).not_to include(User.index_name)
+
+      result = Stretchie.update_indices :users
+      expect(result).to eq(true)
+      indices = User.__elasticsearch__.client.indices.status['indices'].keys
+      expect(indices).to include(User.index_name)
+    end
+
+    it 'updates all indices' do
+      Stretchie.delete_indices
+      indices = User.__elasticsearch__.client.indices.status['indices'].keys
+      expect(indices).not_to include(User.index_name)
+
+      Stretchie.update_indices
+      result = Stretchie.update_indices
+      expect(result).to eq(true)
+      indices = User.__elasticsearch__.client.indices.status['indices'].keys
+      expect(indices).to include(User.index_name)
+    end
+
+    it 'updates specific indices' do
+      Stretchie.delete_indices :users
+      indices = User.__elasticsearch__.client.indices.status['indices'].keys
+      expect(indices).not_to include(User.index_name)
+
+      Stretchie.update_indices :users
+      result = Stretchie.update_indices :users
+      expect(result).to eq(true)
+      indices = User.__elasticsearch__.client.indices.status['indices'].keys
+      expect(indices).to include(User.index_name)
+    end
+  end
+
+
+  context '.delete_indices' do
+
+    it 'deletes all indices' do
+      Stretchie.update_indices
+      Stretchie.delete_indices
+      indices = User.__elasticsearch__.client.indices.status['indices'].keys
+      expect(indices).not_to include(User.index_name)
+    end
+
+    it 'deletes specific indices' do
+      Stretchie.delete_indices :users
+      indices = User.__elasticsearch__.client.indices.status['indices'].keys
+      expect(indices).not_to include(User.index_name)
+    end
+  end
+
+
+  context '.refresh_indices' do
+
+    it 'refreshes all indices' do
+      result = Stretchie.refresh_indices
+      expect(result).to eq(true)
+    end
+
+    it 'refreshes specific indices' do
+      result = Stretchie.refresh_indices :users
+      expect(result).to eq(true)
+    end
+  end
+end

data/spec/support/elastic_search.rb

@@ -0,0 +1,9 @@
+RSpec.configure do |config|
+  config.before(:each) do
+    Stretchie.update_indices
+  end
+
+  config.append_after(:each) do
+    Stretchie.delete_indices
+  end
+end

data/spec/support/model.rb

@@ -0,0 +1,50 @@
+require 'active_record'
+require 'logger'
+
+ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: ':memory:'
+ActiveRecord::Base.logger = Logger.new STDOUT
+ActiveRecord::Base.logger.level = Logger::WARN
+ActiveSupport::LogSubscriber.colorize_logging = false
+
+
+ActiveRecord::Schema.define do
+  self.verbose = false
+
+  create_table :users do |t|
+    t.string  :name
+    t.string  :email
+    t.integer :misc_id
+  end
+end
+
+
+module Search
+  module User
+    extend ActiveSupport::Concern
+    include Stretchie::Pants
+
+    included do
+      settings index: { number_of_shards: 1 } do
+        mappings dynamic: 'false' do
+          indexes :name, analyzer: 'whitespace', index_options: 'offsets'
+          indexes :email
+          indexes :misc_id
+          indexes :sortable_name
+        end
+      end
+    end
+
+
+    def as_indexed_json(options={})
+      json = as_json(only: [:name, :email, :misc_id])
+      json['sortable_name'] = self.name.downcase
+      json
+    end
+  end
+end
+
+
+class User < ActiveRecord::Base
+  include Search::User
+  attr_accessor :name, :email, :misc_id
+end

data/stretchie.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'stretchie/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'stretchie'
+  spec.version       = Stretchie::VERSION
+  spec.authors       = ['Adam Bregenzer']
+  spec.email         = ['adam@bregenzer.net']
+  spec.summary       = 'An ActiveModel concern for integrating ElasticSearch.'
+  spec.description   = 'Comfortable searching pants for ActiveRecord Models. Stretchie simplifies using elastic search in your models and provides hooks to ease testing.'
+  spec.homepage      = 'https://github.com/adambregenzer/stretchie'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'rails', '~> 4.1', '>= 4.1.1'
+  spec.add_dependency 'elasticsearch-model', '~> 0.1', '>= 0.1.4'
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake', '~> 10.3', '>= 10.3.2'
+  spec.add_development_dependency 'rspec', '~> 3.0', '>= 3.0.0'
+  spec.add_development_dependency 'simplecov', '~> 0.8', '>= 0.8.2'
+  spec.add_development_dependency 'sqlite3', '~> 1.3', '>= 1.3.9'
+end

metadata

@@ -0,0 +1,199 @@
+--- !ruby/object:Gem::Specification
+name: stretchie
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Adam Bregenzer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.1.1
+- !ruby/object:Gem::Dependency
+  name: elasticsearch-model
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.4
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.3.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.3.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.9
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.9
+description: Comfortable searching pants for ActiveRecord Models. Stretchie simplifies
+  using elastic search in your models and provides hooks to ease testing.
+email:
+- adam@bregenzer.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/stretchie.rb
+- lib/stretchie/pants.rb
+- lib/stretchie/version.rb
+- spec/spec_helper.rb
+- spec/stretchie_pants_spec.rb
+- spec/stretchie_spec.rb
+- spec/support/elastic_search.rb
+- spec/support/model.rb
+- stretchie.gemspec
+homepage: https://github.com/adambregenzer/stretchie
+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.2.2
+signing_key: 
+specification_version: 4
+summary: An ActiveModel concern for integrating ElasticSearch.
+test_files:
+- spec/spec_helper.rb
+- spec/stretchie_pants_spec.rb
+- spec/stretchie_spec.rb
+- spec/support/elastic_search.rb
+- spec/support/model.rb