[MODEL] Added mappings and settings method to set up index options for the model

Example:

    class Article
      mapping dynamic: 'strict' do
        indexes :foo do
          indexes :bar
        end
        indexes :baz
      end
    end

    > Article.mapping.to_hash
    # => {:article =>
      {:dynamic=>"strict",
       :properties=>
        {:foo=>{:type=>"object", :properties=>{:bar=>{:type=>"string"}}},
         :baz=>{:type=>"string"}}}}

When the model would define the `mapping(s)` or `settings` method, access
the interface through the `__elasticsearch__` proxy:

    class Article
      __elasticsearch__ do
        mapping dynamic: 'strict' do
          indexes :foo do
            indexes :bar
          end
          indexes :baz
        end
      end
    end

Of course, you can call the method directly:

Article.mapping(dynamic: 'strict') { indexes :foo, type: 'long' }

> Article.mapping.to_hash
      { :dynamic=>"strict",
        :properties=>{:foo=>{:type=>"long"}}}}

Author: karmi

elasticsearch-model/lib/elasticsearch/model.rb

@@ -81,7 +81,9 @@ def self.included(base)
         end
 
         extend  Support::Forwardable
-        forward :'self.__elasticsearch__', :search unless respond_to?(:search)
+        forward :'self.__elasticsearch__', :search   unless respond_to?(:search)
+        forward :'self.__elasticsearch__', :mapping  unless respond_to?(:mapping)
+        forward :'self.__elasticsearch__', :settings unless respond_to?(:settings)
       end
     end
 

elasticsearch-model/lib/elasticsearch/model/indexing.rb

@@ -1,12 +1,162 @@
 module Elasticsearch
   module Model
+
+    # This module provides the necessary support to set up index options (mappings, settings)
+    # as well as instance methods to create, update or delete documents in the index.
+    #
     module Indexing
 
+      # Wraps the [index settings](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/setup-configuration.html#configuration-index-settings)
+      #
+      class Settings
+        attr_accessor :settings
+
+        def initialize(settings={})
+          @settings = settings
+        end
+
+        def to_hash
+          @settings
+        end
+
+        def as_json(options={})
+          to_hash
+        end
+      end
+
+      # Wraps the [index mappings](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/mapping.html)
+      #
+      class Mappings
+        attr_accessor :options
+
+        def initialize(type, options={})
+          @type    = type
+          @options = options
+          @mapping = {}
+        end
+
+        def indexes(name, options = {}, &block)
+          @mapping[name] = options
+
+          if block_given?
+            @mapping[name][:type]       ||= 'object'
+            @mapping[name][:properties] ||= {}
+
+            previous = @mapping
+            begin
+              @mapping = @mapping[name][:properties]
+              self.instance_eval(&block)
+            ensure
+              @mapping = previous
+            end
+          end
+
+          # Set the `type` to string by default
+          #
+          @mapping[name][:type] ||= 'string'
+
+          self
+        end
+
+        def to_hash
+          { @type.to_sym => @options.merge( properties: @mapping ) }
+        end
+
+        def as_json(options={})
+          to_hash
+        end
+      end
+
       module ClassMethods
+
+        # Defines mappings for the index
+        #
+        # @example Define mapping for model
+        #
+        #     class Article
+        #       mapping dynamic: 'strict' do
+        #         indexes :foo do
+        #           indexes :bar
+        #         end
+        #         indexes :baz
+        #       end
+        #     end
+        #
+        #     Article.mapping.to_hash
+        #
+        #     # => { :article =>
+        #     #        { :dynamic => "strict",
+        #     #          :properties=>
+        #     #            { :foo => {
+        #     #                :type=>"object",
+        #     #                :properties => {
+        #     #                  :bar => { :type => "string" }
+        #     #                }
+        #     #              }
+        #     #            },
+        #     #           :baz => { :type=> "string" }
+        #     #        }
+        #     #    }
+        #
+        # @example Define index settings and mappings
+        #
+        #     class Article
+        #       settings number_of_shards: 1 do
+        #         mappings do
+        #           indexes :foo
+        #         end
+        #       end
+        #     end
+        #
+        # @example Call the mapping method directly
+        #
+        #     Article.mapping(dynamic: 'strict') { indexes :foo, type: 'long' }
+        #
+        #     Article.mapping.to_hash
+        #
+        #     # => {:article=>{:dynamic=>"strict", :properties=>{:foo=>{:type=>"long"}}}}
+        #
+        # The `mappings` and `settings` methods are accessible directly on the model class,
+        # when it doesn't already defines them. Use the `__elasticsearch__` proxy otherwise.
+        #
+        def mapping(options={}, &block)
+          @mapping ||= Mappings.new(document_type, options)
+
+          if block_given?
+            @mapping.options.update(options)
+
+            @mapping.instance_eval(&block)
+            return self
+          else
+            @mapping
+          end
+        end; alias_method :mappings, :mapping
+
+        # Define settings for the index
+        #
+        # @example Define index settings
+        #
+        #     Article.settings(index: { number_of_shards: 1 })
+        #
+        #     Article.settings.to_hash
+        #
+        #     # => {:index=>{:number_of_shards=>1}}
+        #
+        def settings(settings={}, &block)
+          @settings ||= Settings.new(settings)
+
+          @settings.settings.update(settings) unless settings.empty?
+
+          if block_given?
+            self.instance_eval(&block)
+            return self
+          else
+            @settings
+          end
+        end
       end
 
       module InstanceMethods
-
         def index_document(options={})
           document = self.as_indexed_json
 
@@ -31,7 +181,6 @@ def update_document(options={})
           #       to perform update by partial doc.
           index_document(options)
         end
-
       end
 
     end