searchkick 0.8.5 → 0.8.6

data/lib/searchkick/model.rb

@@ -1,9 +1,13 @@
 module Searchkick
+  module Reindex; end # legacy for Searchjoy
+
   module Model
 
     def searchkick(options = {})
       raise "Only call searchkick once per model" if respond_to?(:searchkick_index)
 
+      Searchkick.models << self
+
       class_eval do
         cattr_reader :searchkick_options, :searchkick_klass
 
@@ -14,32 +18,51 @@ module Searchkick
         class_variable_set :@@searchkick_callbacks, callbacks
         class_variable_set :@@searchkick_index, options[:index_name] || [options[:index_prefix], model_name.plural, Searchkick.env].compact.join("_")
 
-        def self.searchkick_index
-          index = class_variable_get :@@searchkick_index
-          index = index.call if index.respond_to? :call
-          Searchkick::Index.new(index)
+        define_singleton_method(Searchkick.search_method_name) do |term = nil, options={}, &block|
+          searchkick_index.search_model(self, term, options, &block)
         end
+        extend Searchkick::Reindex # legacy for Searchjoy
 
-        define_singleton_method(Searchkick.search_method_name) do |term = nil, options={}, &block|
-          query = Searchkick::Query.new(self, term, options)
-          if block
-            block.call(query.body)
+        class << self
+
+          def searchkick_index
+            index = class_variable_get :@@searchkick_index
+            index = index.call if index.respond_to? :call
+            Searchkick::Index.new(index, searchkick_options)
           end
-          if options[:execute] == false
-            query
-          else
-            query.execute
+
+          def enable_search_callbacks
+            class_variable_set :@@searchkick_callbacks, true
           end
-        end
-        extend Searchkick::Reindex
-        include Searchkick::Similar
 
-        def reindex_async
-          if defined?(Searchkick::ReindexV2Job)
-            Searchkick::ReindexV2Job.perform_later(self.class.name, id.to_s)
-          else
-            Delayed::Job.enqueue Searchkick::ReindexJob.new(self.class.name, id.to_s)
+          def disable_search_callbacks
+            class_variable_set :@@searchkick_callbacks, false
           end
+
+          def search_callbacks?
+            class_variable_get(:@@searchkick_callbacks) && Searchkick.callbacks?
+          end
+
+          def reindex(options = {})
+            searchkick_index.reindex_scope(searchkick_klass, options)
+          end
+
+          def clean_indices
+            searchkick_index.clean_indices
+          end
+
+          def searchkick_import(options = {})
+            (options[:index] || searchkick_index).import_scope(searchkick_klass)
+          end
+
+          def searchkick_create_index
+            searchkick_index.create_index
+          end
+
+          def searchkick_index_options
+            searchkick_index.index_options
+          end
+
         end
 
         if callbacks
@@ -52,38 +75,25 @@ module Searchkick
           end
         end
 
-        def self.enable_search_callbacks
-          class_variable_set :@@searchkick_callbacks, true
-        end
-
-        def self.disable_search_callbacks
-          class_variable_set :@@searchkick_callbacks, false
-        end
-
-        def self.search_callbacks?
-          class_variable_get(:@@searchkick_callbacks) && Searchkick.callbacks?
-        end
+        def reindex
+          self.class.searchkick_index.reindex_record(self)
+        end unless method_defined?(:reindex)
 
-        def should_index?
-          true
-        end
+        def reindex_async
+          self.class.searchkick_index.reindex_record_async(self)
+        end unless method_defined?(:reindex_async)
 
-        def reindex
-          index = self.class.searchkick_index
-          if destroyed? or !should_index?
-            begin
-              index.remove self
-            rescue Elasticsearch::Transport::Transport::Errors::NotFound
-              # do nothing
-            end
-          else
-            index.store self
-          end
-        end
+        def similar(options = {})
+          self.class.searchkick_index.similar_record(self, options)
+        end unless method_defined?(:similar)
 
         def search_data
           respond_to?(:to_hash) ? to_hash : serializable_hash
-        end
+        end unless method_defined?(:search_data)
+
+        def should_index?
+          true
+        end unless method_defined?(:should_index?)
 
       end
     end

data/lib/searchkick/query.rb

@@ -28,7 +28,7 @@ module Searchkick
               k, v = value.is_a?(Hash) ? value.to_a.first : [value, :word]
               k2, boost = k.to_s.split("^", 2)
               field = "#{k2}.#{v == :word ? "analyzed" : v}"
-              boost_fields[field] = boost.to_i if boost
+              boost_fields[field] = boost.to_f if boost
               field
             end
           end
@@ -195,20 +195,21 @@ module Searchkick
           boost_where[personalize_field] = options[:user_id]
         end
         if options[:personalize]
-          boost_where.merge!(options[:personalize])
+          boost_where = boost_where.merge(options[:personalize])
         end
         boost_where.each do |field, value|
-          if value.is_a?(Hash)
+          if value.is_a?(Array) and value.first.is_a?(Hash)
+            value.each do |value_factor|
+              value, factor = value_factor[:value], value_factor[:factor]
+              custom_filters << custom_filter(field, value, factor)
+            end
+          elsif value.is_a?(Hash)
             value, factor = value[:value], value[:factor]
+            custom_filters << custom_filter(field, value, factor)
           else
             factor = 1000
+            custom_filters << custom_filter(field, value, factor)
           end
-          custom_filters << {
-            filter: {
-              term: {field => value}
-            },
-            boost_factor: factor
-          }
         end
 
         boost_by_distance = options[:boost_by_distance]
@@ -317,7 +318,7 @@ module Searchkick
 
           # intersection
           if options[:fields]
-            suggest_fields = suggest_fields & options[:fields].map{|v| (v.is_a?(Hash) ? v.keys.first : v).to_s }
+            suggest_fields = suggest_fields & options[:fields].map{|v| (v.is_a?(Hash) ? v.keys.first : v).to_s.split("^", 2).first }
           end
 
           if suggest_fields.any?
@@ -535,5 +536,12 @@ module Searchkick
       end
     end
 
+    def custom_filter(field, value, factor)
+      {
+        filter: term_filters(field, value),
+        boost_factor: factor
+      }
+    end
+
   end
 end

data/lib/searchkick/results.rb

@@ -24,7 +24,11 @@ module Searchkick
           hits.group_by{|hit, i| hit["_type"] }.each do |type, grouped_hits|
             records = type.camelize.constantize
             if options[:includes]
-              records = records.includes(options[:includes])
+              if defined?(NoBrainer::Document) and records < NoBrainer::Document
+                records = records.preload(options[:includes])
+              else
+                records = records.includes(options[:includes])
+              end
             end
             results[type] = results_query(records, grouped_hits)
           end
@@ -143,6 +147,9 @@ module Searchkick
       elsif records.respond_to?(:queryable)
         # Mongoid 3+
         records.queryable.for_ids(grouped_hits.map{|hit| hit["_id"] }).to_a
+      elsif records.respond_to?(:unscoped) and records.all.respond_to?(:preload)
+        # Nobrainer
+        records.unscoped.where(:id.in => grouped_hits.map{|hit| hit["_id"] }).to_a
       else
         raise "Not sure how to load records"
       end

data/lib/searchkick/tasks.rb

@@ -22,7 +22,7 @@ namespace :searchkick do
       desc "reindex all models"
       task :all => :environment do
         Rails.application.eager_load!
-        (Searchkick::Reindex.instance_variable_get(:@descendents) || []).each do |model|
+        Searchkick.models.each do |model|
           puts "Reindexing #{model.name}..."
           model.reindex
         end

data/lib/searchkick/version.rb

@@ -1,3 +1,3 @@
 module Searchkick
-  VERSION = "0.8.5"
+  VERSION = "0.8.6"
 end

data/test/boost_test.rb

@@ -75,6 +75,14 @@ class TestBoost < Minitest::Test
     assert_order "red", ["Red", "White"], fields: ["name^10", "color"]
   end
 
+  def test_boost_fields_decimal
+    store [
+      {name: "Red", color: "White"},
+      {name: "White", color: "Red Red Red"}
+    ]
+    assert_order "red", ["Red", "White"], fields: ["name^10.5", "color"]
+  end
+
   def test_boost_fields_word_start
     store [
       {name: "Red", color: "White"},
@@ -96,12 +104,14 @@ class TestBoost < Minitest::Test
   def test_boost_where
     store [
       {name: "Tomato A"},
-      {name: "Tomato B", user_ids: [1, 2, 3]},
-      {name: "Tomato C"},
-      {name: "Tomato D"}
+      {name: "Tomato B", user_ids: [1, 2]},
+      {name: "Tomato C", user_ids: [3]}
     ]
     assert_first "tomato", "Tomato B", boost_where: {user_ids: 2}
+    assert_first "tomato", "Tomato B", boost_where: {user_ids: [1, 4]}
     assert_first "tomato", "Tomato B", boost_where: {user_ids: {value: 2, factor: 10}}
+    assert_first "tomato", "Tomato B", boost_where: {user_ids: {value: [1, 4], factor: 10}}
+    assert_order "tomato", ["Tomato C", "Tomato B", "Tomato A"], boost_where: {user_ids: [{value: 1, factor: 10}, {value: 3, factor: 20}]}
   end
 
   def test_boost_by_distance

data/test/facets_test.rb

@@ -1,4 +1,5 @@
 require_relative "test_helper"
+require "active_support/core_ext"
 
 class TestFacets < Minitest::Test
 

data/test/sql_test.rb

@@ -312,7 +312,7 @@ class TestSql < Minitest::Test
   end
 
   # TODO see if Mongoid is loaded
-  if !defined?(Mongoid)
+  unless defined?(Mongoid) or defined?(NoBrainer)
     def test_include
       store_names ["Product A"]
       assert Product.search("product", include: [:store]).first.association(:store).loaded?

data/test/suggest_test.rb

@@ -18,6 +18,7 @@ class TestSuggest < Minitest::Test
   end
 
   def test_without_option
+    store_names ["hi"] # needed to prevent ElasticsearchException - seed 668
     assert_raises(RuntimeError){ Product.search("hi").suggestions }
   end
 
@@ -57,11 +58,16 @@ class TestSuggest < Minitest::Test
     assert_suggest "shar", "shark", fields: [:name, :unknown]
   end
 
-  def test_fields_word_start
+  def test_fields_partial_match
     store_names ["Great White Shark", "Hammerhead Shark", "Tiger Shark"]
     assert_suggest "How Big is a Tigre Shar", "how big is a tiger shark", fields: [{name: :word_start}]
   end
 
+  def test_fields_partial_match_boost
+    store_names ["Great White Shark", "Hammerhead Shark", "Tiger Shark"]
+    assert_suggest "How Big is a Tigre Shar", "how big is a tiger shark", fields: [{"name^2" => :word_start}]
+  end
+
   protected
 
   def assert_suggest(term, expected, options = {})

data/test/test_helper.rb

@@ -71,6 +71,45 @@ if defined?(Mongoid)
   class Dog < Animal
   end
 
+  class Cat < Animal
+  end
+elsif defined?(NoBrainer)
+  NoBrainer.configure do |config|
+    config.app_name = :searchkick
+    config.environment = :test
+  end
+
+  class Product
+    include NoBrainer::Document
+    include NoBrainer::Document::Timestamps
+
+    field :name,         type: String
+    field :store_id,     type: Integer
+    field :in_stock,     type: Boolean
+    field :backordered,  type: Boolean
+    field :orders_count, type: Integer
+    field :price,        type: Integer
+    field :color,        type: String
+    field :latitude
+    field :longitude
+    field :description,  type: String
+  end
+
+  class Store
+    include NoBrainer::Document
+
+    field :name, type: String
+  end
+
+  class Animal
+    include NoBrainer::Document
+
+    field :name, type: String
+  end
+
+  class Dog < Animal
+  end
+
   class Cat < Animal
   end
 else
@@ -86,6 +125,8 @@ else
   # migrations
   ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
 
+  ActiveRecord::Base.raise_in_transactional_callbacks = true if ActiveRecord::Base.respond_to?(:raise_in_transactional_callbacks=)
+
   ActiveRecord::Migration.create_table :products do |t|
     t.string :name
     t.integer :store_id
@@ -97,7 +138,7 @@ else
     t.decimal :latitude, precision: 10, scale: 7
     t.decimal :longitude, precision: 10, scale: 7
     t.text :description
-    t.timestamps
+    t.timestamps null: true
   end
 
   ActiveRecord::Migration.create_table :stores do |t|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: searchkick
 version: !ruby/object:Gem::Version
-  version: 0.8.5
+  version: 0.8.6
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-11 00:00:00.000000000 Z
+date: 2015-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -108,22 +108,23 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- ci/before_install.sh
 - gemfiles/activerecord31.gemfile
 - gemfiles/activerecord32.gemfile
 - gemfiles/activerecord40.gemfile
+- gemfiles/activerecord41.gemfile
 - gemfiles/mongoid2.gemfile
 - gemfiles/mongoid3.gemfile
 - gemfiles/mongoid4.gemfile
+- gemfiles/nobrainer.gemfile
 - lib/searchkick.rb
 - lib/searchkick/index.rb
 - lib/searchkick/logging.rb
 - lib/searchkick/model.rb
 - lib/searchkick/query.rb
-- lib/searchkick/reindex.rb
 - lib/searchkick/reindex_job.rb
 - lib/searchkick/reindex_v2_job.rb
 - lib/searchkick/results.rb
-- lib/searchkick/similar.rb
 - lib/searchkick/tasks.rb
 - lib/searchkick/version.rb
 - searchkick.gemspec
@@ -164,7 +165,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Searchkick learns what your users are looking for. As more people search,

data/lib/searchkick/reindex.rb

@@ -1,339 +0,0 @@
-module Searchkick
-  module Reindex
-
-    # https://gist.github.com/jarosan/3124884
-    # http://www.elasticsearch.org/blog/changing-mapping-with-zero-downtime/
-    def reindex(options = {})
-      skip_import = options[:import] == false
-
-      alias_name = searchkick_index.name
-      new_name = "#{alias_name}_#{Time.now.strftime('%Y%m%d%H%M%S%L')}"
-      index = Searchkick::Index.new(new_name)
-
-      clean_indices
-
-      index.create searchkick_index_options
-
-      # check if alias exists
-      if Searchkick.client.indices.exists_alias(name: alias_name)
-        # import before swap
-        searchkick_import(index: index) unless skip_import
-
-        # get existing indices to remove
-        old_indices = Searchkick.client.indices.get_alias(name: alias_name).keys
-        actions = old_indices.map{|name| {remove: {index: name, alias: alias_name}} } + [{add: {index: new_name, alias: alias_name}}]
-        Searchkick.client.indices.update_aliases body: {actions: actions}
-        clean_indices
-      else
-        searchkick_index.delete if searchkick_index.exists?
-        Searchkick.client.indices.update_aliases body: {actions: [{add: {index: new_name, alias: alias_name}}]}
-
-        # import after swap
-        searchkick_import(index: index) unless skip_import
-      end
-
-      index.refresh
-
-      true
-    end
-
-    # remove old indices that start w/ index_name
-    def clean_indices
-      all_indices = Searchkick.client.indices.get_aliases
-      indices = all_indices.select{|k, v| (v.empty? || v["aliases"].empty?) && k =~ /\A#{Regexp.escape(searchkick_index.name)}_\d{14,17}\z/ }.keys
-      indices.each do |index|
-        Searchkick::Index.new(index).delete
-      end
-      indices
-    end
-
-    def self.extended(klass)
-      @descendents ||= []
-      @descendents << klass unless @descendents.include?(klass)
-    end
-
-    def searchkick_import(options = {})
-      index = options[:index] || searchkick_index
-      batch_size = searchkick_options[:batch_size] || 1000
-
-      # use scope for import
-      scope = searchkick_klass
-      scope = scope.search_import if scope.respond_to?(:search_import)
-      if scope.respond_to?(:find_in_batches)
-        scope.find_in_batches batch_size: batch_size do |batch|
-          index.import batch.select{|item| item.should_index? }
-        end
-      else
-        # https://github.com/karmi/tire/blob/master/lib/tire/model/import.rb
-        # use cursor for Mongoid
-        items = []
-        scope.all.each do |item|
-          items << item if item.should_index?
-          if items.length == batch_size
-            index.import items
-            items = []
-          end
-        end
-        index.import items
-      end
-    end
-
-    def searchkick_index_options
-      options = searchkick_options
-
-      if options[:mappings] and !options[:merge_mappings]
-        settings = options[:settings] || {}
-        mappings = options[:mappings]
-      else
-        settings = {
-          analysis: {
-            analyzer: {
-              searchkick_keyword: {
-                type: "custom",
-                tokenizer: "keyword",
-                filter: ["lowercase", "searchkick_stemmer"]
-              },
-              default_index: {
-                type: "custom",
-                tokenizer: "standard",
-                # synonym should come last, after stemming and shingle
-                # shingle must come before searchkick_stemmer
-                filter: ["standard", "lowercase", "asciifolding", "searchkick_index_shingle", "searchkick_stemmer"]
-              },
-              searchkick_search: {
-                type: "custom",
-                tokenizer: "standard",
-                filter: ["standard", "lowercase", "asciifolding", "searchkick_search_shingle", "searchkick_stemmer"]
-              },
-              searchkick_search2: {
-                type: "custom",
-                tokenizer: "standard",
-                filter: ["standard", "lowercase", "asciifolding", "searchkick_stemmer"]
-              },
-              # https://github.com/leschenko/elasticsearch_autocomplete/blob/master/lib/elasticsearch_autocomplete/analyzers.rb
-              searchkick_autocomplete_index: {
-                type: "custom",
-                tokenizer: "searchkick_autocomplete_ngram",
-                filter: ["lowercase", "asciifolding"]
-              },
-              searchkick_autocomplete_search: {
-                type: "custom",
-                tokenizer: "keyword",
-                filter: ["lowercase", "asciifolding"]
-              },
-              searchkick_word_search: {
-                type: "custom",
-                tokenizer: "standard",
-                filter: ["lowercase", "asciifolding"]
-              },
-              searchkick_suggest_index: {
-                type: "custom",
-                tokenizer: "standard",
-                filter: ["lowercase", "asciifolding", "searchkick_suggest_shingle"]
-              },
-              searchkick_text_start_index: {
-                type: "custom",
-                tokenizer: "keyword",
-                filter: ["lowercase", "asciifolding", "searchkick_edge_ngram"]
-              },
-              searchkick_text_middle_index: {
-                type: "custom",
-                tokenizer: "keyword",
-                filter: ["lowercase", "asciifolding", "searchkick_ngram"]
-              },
-              searchkick_text_end_index: {
-                type: "custom",
-                tokenizer: "keyword",
-                filter: ["lowercase", "asciifolding", "reverse", "searchkick_edge_ngram", "reverse"]
-              },
-              searchkick_word_start_index: {
-                type: "custom",
-                tokenizer: "standard",
-                filter: ["lowercase", "asciifolding", "searchkick_edge_ngram"]
-              },
-              searchkick_word_middle_index: {
-                type: "custom",
-                tokenizer: "standard",
-                filter: ["lowercase", "asciifolding", "searchkick_ngram"]
-              },
-              searchkick_word_end_index: {
-                type: "custom",
-                tokenizer: "standard",
-                filter: ["lowercase", "asciifolding", "reverse", "searchkick_edge_ngram", "reverse"]
-              }
-            },
-            filter: {
-              searchkick_index_shingle: {
-                type: "shingle",
-                token_separator: ""
-              },
-              # lucky find http://web.archiveorange.com/archive/v/AAfXfQ17f57FcRINsof7
-              searchkick_search_shingle: {
-                type: "shingle",
-                token_separator: "",
-                output_unigrams: false,
-                output_unigrams_if_no_shingles: true
-              },
-              searchkick_suggest_shingle: {
-                type: "shingle",
-                max_shingle_size: 5
-              },
-              searchkick_edge_ngram: {
-                type: "edgeNGram",
-                min_gram: 1,
-                max_gram: 50
-              },
-              searchkick_ngram: {
-                type: "nGram",
-                min_gram: 1,
-                max_gram: 50
-              },
-              searchkick_stemmer: {
-                type: "snowball",
-                language: options[:language] || "English"
-              }
-            },
-            tokenizer: {
-              searchkick_autocomplete_ngram: {
-                type: "edgeNGram",
-                min_gram: 1,
-                max_gram: 50
-              }
-            }
-          }
-        }
-
-        if Searchkick.env == "test"
-          settings.merge!(number_of_shards: 1, number_of_replicas: 0)
-        end
-
-        settings.deep_merge!(options[:settings] || {})
-
-        # synonyms
-        synonyms = options[:synonyms] || []
-        if synonyms.any?
-          settings[:analysis][:filter][:searchkick_synonym] = {
-            type: "synonym",
-            synonyms: synonyms.select{|s| s.size > 1 }.map{|s| s.join(",") }
-          }
-          # choosing a place for the synonym filter when stemming is not easy
-          # https://groups.google.com/forum/#!topic/elasticsearch/p7qcQlgHdB8
-          # TODO use a snowball stemmer on synonyms when creating the token filter
-
-          # http://elasticsearch-users.115913.n3.nabble.com/synonym-multi-words-search-td4030811.html
-          # I find the following approach effective if you are doing multi-word synonyms (synonym phrases):
-          # - Only apply the synonym expansion at index time
-          # - Don't have the synonym filter applied search
-          # - Use directional synonyms where appropriate. You want to make sure that you're not injecting terms that are too general.
-          settings[:analysis][:analyzer][:default_index][:filter].insert(4, "searchkick_synonym")
-          settings[:analysis][:analyzer][:default_index][:filter] << "searchkick_synonym"
-        end
-
-        if options[:wordnet]
-          settings[:analysis][:filter][:searchkick_wordnet] = {
-            type: "synonym",
-            format: "wordnet",
-            synonyms_path: Searchkick.wordnet_path
-          }
-
-          settings[:analysis][:analyzer][:default_index][:filter].insert(4, "searchkick_wordnet")
-          settings[:analysis][:analyzer][:default_index][:filter] << "searchkick_wordnet"
-        end
-
-        if options[:special_characters] == false
-          settings[:analysis][:analyzer].each do |analyzer, analyzer_settings|
-            analyzer_settings[:filter].reject!{|f| f == "asciifolding" }
-          end
-        end
-
-        mapping = {}
-
-        # conversions
-        if options[:conversions]
-          mapping[:conversions] = {
-            type: "nested",
-            properties: {
-              query: {type: "string", analyzer: "searchkick_keyword"},
-              count: {type: "integer"}
-            }
-          }
-        end
-
-        mapping_options = Hash[
-          [:autocomplete, :suggest, :text_start, :text_middle, :text_end, :word_start, :word_middle, :word_end, :highlight]
-            .map{|type| [type, (options[type] || []).map(&:to_s)] }
-        ]
-
-        mapping_options.values.flatten.uniq.each do |field|
-          field_mapping = {
-            type: "multi_field",
-            fields: {
-              field => {type: "string", index: "not_analyzed"},
-              "analyzed" => {type: "string", index: "analyzed"}
-              # term_vector: "with_positions_offsets" for fast / correct highlighting
-              # http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-highlighting.html#_fast_vector_highlighter
-            }
-          }
-
-          mapping_options.except(:highlight).each do |type, fields|
-            if fields.include?(field)
-              field_mapping[:fields][type] = {type: "string", index: "analyzed", analyzer: "searchkick_#{type}_index"}
-            end
-          end
-
-          if mapping_options[:highlight].include?(field)
-            field_mapping[:fields]["analyzed"][:term_vector] = "with_positions_offsets"
-          end
-
-          mapping[field] = field_mapping
-        end
-
-        (options[:locations] || []).map(&:to_s).each do |field|
-          mapping[field] = {
-            type: "geo_point"
-          }
-        end
-
-        (options[:unsearchable] || []).map(&:to_s).each do |field|
-          mapping[field] = {
-            type: "string",
-            index: "no"
-          }
-        end
-
-        mappings = {
-          _default_: {
-            properties: mapping,
-            # https://gist.github.com/kimchy/2898285
-            dynamic_templates: [
-              {
-                string_template: {
-                  match: "*",
-                  match_mapping_type: "string",
-                  mapping: {
-                    # http://www.elasticsearch.org/guide/reference/mapping/multi-field-type/
-                    type: "multi_field",
-                    fields: {
-                      # analyzed field must be the default field for include_in_all
-                      # http://www.elasticsearch.org/guide/reference/mapping/multi-field-type/
-                      # however, we can include the not_analyzed field in _all
-                      # and the _all index analyzer will take care of it
-                      "{name}" => {type: "string", index: "not_analyzed"},
-                      "analyzed" => {type: "string", index: "analyzed"}
-                    }
-                  }
-                }
-              }
-            ]
-          }
-        }.deep_merge(options[:mappings] || {})
-      end
-
-      {
-        settings: settings,
-        mappings: mappings
-      }
-    end
-
-  end
-end