ssickles-tire 0.4.2.7 → 0.4.3

data/lib/tire.rb

@@ -1,12 +1,17 @@
 require 'rest_client'
 require 'multi_json'
+#require 'active_model'
 require 'hashr'
 require 'cgi'
-require 'escape_utils'
 
-require 'active_support/core_ext'
+require 'active_support'
 
-require 'tire/rubyext/to_json'
+# Ruby 1.8 compatibility
+require 'tire/rubyext/ruby_1_8' if defined?(RUBY_VERSION) && RUBY_VERSION < '1.9'
+
+require 'tire/rubyext/hash'
+require 'tire/rubyext/symbol'
+require 'tire/utils'
 require 'tire/logger'
 require 'tire/configuration'
 require 'tire/http/response'
@@ -24,6 +29,16 @@ require 'tire/results/item'
 require 'tire/index'
 require 'tire/alias'
 require 'tire/dsl'
+require 'tire/model/naming'
+require 'tire/model/callbacks'
+require 'tire/model/percolate'
+require 'tire/model/indexing'
+require 'tire/model/import'
+require 'tire/model/search'
+require 'tire/model/persistence/finders'
+require 'tire/model/persistence/attributes'
+require 'tire/model/persistence/storage'
+require 'tire/model/persistence'
 require 'tire/tasks'
 
 module Tire

data/lib/tire/alias.rb

@@ -74,7 +74,6 @@ module Tire
     def initialize(attributes={}, &block)
       raise ArgumentError, "Please pass a Hash-like object" unless attributes.respond_to?(:each_pair)
 
-      @url = attributes.delete(:url) || Configuration.url
       @attributes = { :indices => IndexCollection.new([]) }
 
       attributes.each_pair do |key, value|
@@ -88,57 +87,34 @@ module Tire
       block.arity < 1 ? instance_eval(&block) : block.call(self) if block_given?
     end
 
-    attr_accessor :url
-
     # Returns a collection of Tire::Alias objects for all aliases defined in the cluster, or for a specific index.
     #
-    def self.all(url=nil, index=nil)
-      if url and url !~ /^https?:\/\//i
-        index, url = url, Configuration.url
-      elsif url.nil?
-        url = Configuration.url
-      end
+    def self.all(index=nil)
+      @response = Configuration.client.get [Configuration.url, index, '_aliases'].compact.join('/')
 
-      @response = Configuration.client.get [url, index, '_aliases'].compact.join('/')
-
-      aliases = MultiJson.decode(@response.body).inject({}) do |result, (name, value)|
+      aliases = MultiJson.decode(@response.body).inject({}) do |result, (index, value)|
         # 1] Skip indices without aliases
         next result if value['aliases'].empty?
 
         # 2] Build a reverse map of hashes (alias => indices, config)
-        value['aliases'].each do |key, v| (result[key] ||= { 'indices' => [] }).update(v)['indices'].push(name) end
+        value['aliases'].each do |key, value| (result[key] ||= { 'indices' => [] }).update(value)['indices'].push(index) end
         result
       end
 
       # 3] Build a collection of Alias objects from hashes
       aliases.map do |key, value|
-        self.new(value.update('name' => key, :url => url))
+        self.new(value.update('name' => key))
       end
 
     ensure
       # FIXME: Extract the `logged` method
-      Alias.new.logged '_aliases', %Q|curl "#{url}/_aliases"|
+      Alias.new.logged '_aliases', %Q|curl "#{Configuration.url}/_aliases"|
     end
 
     # Returns an alias by name
     #
-    # Examples
-    #
-    #   Alias.find( url, name )
-    #   Alias.find( name )
-    #
-    def self.find(*args, &block)
-      case args.length
-      when 2
-        url, name = args
-      when 1
-        url = Configuration.url
-        name = args.first
-      else
-        raise ArgumentError, "wrong number of arguments (#{args.length} for 2)"
-      end
-
-      a = all(url).select { |b| b.name == name }.first
+    def self.find(name, &block)
+      a = all.select { |a| a.name == name }.first
       block.call(a) if block_given?
       return a
     end
@@ -183,10 +159,10 @@ module Tire
     # Save the alias in _ElasticSearch_
     #
     def save
-      @response = Configuration.client.post "#{url}/_aliases", to_json
+      @response = Configuration.client.post "#{Configuration.url}/_aliases", to_json
 
     ensure
-      logged '_aliases', %Q|curl -X POST "#{url}/_aliases" -d '#{to_json}'|
+      logged '_aliases', %Q|curl -X POST "#{Configuration.url}/_aliases" -d '#{to_json}'|
     end
 
     # Return a Hash suitable for JSON serialization
@@ -211,7 +187,7 @@ module Tire
     # Return alias serialized in JSON for _ElasticSearch_
     #
     def to_json(options=nil)
-      MultiJson.encode(as_json)
+      as_json.to_json
     end
 
     def inspect

data/lib/tire/index.rb

@@ -1,27 +1,15 @@
 module Tire
   class Index
 
-    attr_reader :name, :response, :url
-
-    def initialize(*args, &block)
-      case args.length
-      when 2
-        @name = args.last
-        self.url = args.first
-      when 1
-        @name = args.first
-        self.url = Configuration.url
-      else
-        raise ArgumentError, "wrong number of arguments (#{args.length} for 2)"
-      end
+    attr_reader :name, :response
 
+    def initialize(name, &block)
+      @name = name
       block.arity < 1 ? instance_eval(&block) : block.call(self) if block_given?
     end
 
-    def url=( url )
-      @base_url = url.dup
-      @url = "#@base_url/#@name"
-      @percolator_url = "#@base_url/_percolator/#@name"
+    def url
+      "#{Configuration.url}/#{@name}"
     end
 
     def exists?
@@ -53,15 +41,15 @@ module Tire
     end
 
     def add_alias(alias_name, configuration={})
-      Alias.create(configuration.merge( :name => alias_name, :index => @name, :url => @base_url ) )
+      Alias.create(configuration.merge( :name => alias_name, :index => @name ) )
     end
 
     def remove_alias(alias_name)
-      Alias.find(@base_url, alias_name) { |a| a.indices.delete @name }.save
+      Alias.find(alias_name) { |a| a.indices.delete @name }.save
     end
 
     def aliases(alias_name=nil)
-      alias_name ? Alias.all(@base_url, @name).select { |a| a.name == alias_name }.first : Alias.all(@base_url, @name)
+      alias_name ? Alias.all(@name).select { |a| a.name == alias_name }.first : Alias.all(@name)
     end
 
     def mapping
@@ -75,24 +63,23 @@ module Tire
     end
 
     def store(*args)
-      document, params = args
-      id      = get_id_from_document(document)
-      type    = get_type_from_document(document)
-      routing = get_routing_from_document(document)
-      parent  = get_parent_from_document(document)
-
-      params ||= {}
-      params[:routing] = routing if routing
-      params[:parent]  = parent  if parent
-      params[:percolate] = '*' if params[:percolate] === true
+      document, options = args
+      type = get_type_from_document(document)
 
-      url = id ? "#{self.url}/#{type}/#{id}" : "#{self.url}/#{type}"
-      url << "?#{params.to_param}" unless params.empty?
+      if options
+        percolate = options[:percolate]
+        percolate = "*" if percolate === true
+      end
 
+      id       = get_id_from_document(document)
       document = convert_document_to_json(document)
 
+      url  = id ? "#{self.url}/#{type}/#{id}" : "#{self.url}/#{type}/"
+      url += "?percolate=#{percolate}" if percolate
+
       @response = Configuration.client.post url, document
       MultiJson.decode(@response.body)
+
     ensure
       curl = %Q|curl -X POST "#{url}" -d '#{document}'|
       logged([type, id].join('/'), curl)
@@ -172,7 +159,7 @@ module Tire
     def remove(*args)
       if args.size > 1
         type, document = args
-        type           = EscapeUtils.escape_url(type.to_s)
+        type           = Utils.escape(type)
         id             = get_id_from_document(document) || document
       else
         document = args.pop
@@ -181,25 +168,20 @@ module Tire
       end
       raise ArgumentError, "Please pass a document ID" unless id
 
-      routing = get_routing_from_document(document)
-
-      url = "#{self.url}/#{type}/#{id}"
-      url << "?routing=#{EscapeUtils.escape_url(routing)}" if routing
-
+      url    = "#{self.url}/#{type}/#{id}"
       result = Configuration.client.delete url
       MultiJson.decode(result.body) if result.success?
+
     ensure
       curl = %Q|curl -X DELETE "#{url}"|
       logged(id, curl)
     end
 
-    def retrieve(type, id, params = {})
+    def retrieve(type, id)
       raise ArgumentError, "Please pass a document ID" unless id
 
-      type = EscapeUtils.escape_url(type.to_s)
-      url  = "#{self.url}/#{type}/#{id}"
-      url << "?#{params.to_param}" unless params.empty?
-
+      type      = Utils.escape(type)
+      url       = "#{self.url}/#{type}/#{id}"
       @response = Configuration.client.get url
 
       h = MultiJson.decode(@response.body)
@@ -257,22 +239,20 @@ module Tire
     def register_percolator_query(name, options={}, &block)
       options[:query] = Search::Query.new(&block).to_hash if block_given?
 
-      url = "#@percolator_url/#{name}"
-      @response = Configuration.client.put url, MultiJson.encode(options)
+      @response = Configuration.client.put "#{Configuration.url}/_percolator/#{@name}/#{name}", MultiJson.encode(options)
       MultiJson.decode(@response.body)['ok']
 
     ensure
-      curl = %Q|curl -X PUT "#{url}?pretty=true" -d '#{MultiJson.encode(options)}'|
+      curl = %Q|curl -X PUT "#{Configuration.url}/_percolator/#{@name}/?pretty=1" -d '#{MultiJson.encode(options)}'|
       logged('_percolator', curl)
     end
 
     def unregister_percolator_query(name)
-      url = "#@percolator_url/#{name}"
-      @response = Configuration.client.delete url
+      @response = Configuration.client.delete "#{Configuration.url}/_percolator/#{@name}/#{name}"
       MultiJson.decode(@response.body)['ok']
 
     ensure
-      curl = %Q|curl -X DELETE "#{url}"|
+      curl = %Q|curl -X DELETE "#{Configuration.url}/_percolator/#{@name}"|
       logged('_percolator', curl)
     end
 
@@ -322,10 +302,10 @@ module Tire
 
       old_verbose, $VERBOSE = $VERBOSE, nil # Silence Object#type deprecation warnings
       type = case
-        when document.is_a?(Hash)
-          document.delete(:_type) || document.delete('_type') || document[:type] || document['type']
         when document.respond_to?(:document_type)
           document.document_type
+        when document.is_a?(Hash)
+          document[:_type] || document['_type'] || document[:type] || document['type']
         when document.respond_to?(:_type)
           document._type
         when document.respond_to?(:type) && document.type != document.class
@@ -333,15 +313,15 @@ module Tire
         end
       $VERBOSE = old_verbose
 
-      type = type ? type.to_s : 'document'
-      options[:escape] ? EscapeUtils.escape_url(type) : type
+      type ||= 'document'
+      options[:escape] ? Utils.escape(type) : type
     end
 
     def get_id_from_document(document)
       old_verbose, $VERBOSE = $VERBOSE, nil # Silence Object#id deprecation warnings
       id = case
         when document.is_a?(Hash)
-          document.delete(:_id) || document.delete('_id') || document[:id] || document['id']
+          document[:_id] || document['_id'] || document[:id] || document['id']
         when document.respond_to?(:id) && document.id != document.object_id
           document.id
       end
@@ -349,28 +329,6 @@ module Tire
       id
     end
 
-    def get_routing_from_document(document)
-      case
-      when document.is_a?(Hash)
-        document.delete(:_routing) || document.delete('_routing')
-      when document.respond_to?(:routing)
-        document.routing
-      when document.respond_to?(:_routing)
-        document._routing
-      end
-    end
-
-    def get_parent_from_document(document)
-      case
-      when document.is_a?(Hash)
-        document.delete(:_parent) || document.delete('_parent')
-      when document.respond_to?(:parent)
-        document.parent
-      when document.respond_to?(:_parent)
-        document._parent
-      end
-    end
-
     def convert_document_to_json(document)
       document = case
         when document.is_a?(String)

data/lib/tire/model/callbacks.rb

@@ -0,0 +1,40 @@
+module Tire
+  module Model
+
+    # Main module containing the infrastructure for automatic updating
+    # of the _ElasticSearch_ index on model instance create, update or delete.
+    #
+    # Include it in your model: `include Tire::Model::Callbacks`
+    #
+    # The model must respond to `after_save` and `after_destroy` callbacks
+    # (ActiveModel and ActiveRecord models do so, by default).
+    #
+    module Callbacks
+
+      # A hook triggered by the `include Tire::Model::Callbacks` statement in the model.
+      #
+      def self.included(base)
+        # Update index on model instance change or destroy.
+        #
+        if base.respond_to?(:after_save) && base.respond_to?(:after_destroy)
+          base.class_eval do
+            after_save    lambda { tire.update_index }
+            after_destroy lambda { tire.update_index }
+          end
+        end
+
+        # Add neccessary infrastructure for the model, when missing in
+        # some half-baked ActiveModel implementations.
+        #
+        if base.respond_to?(:before_destroy) && !base.instance_methods.map(&:to_sym).include?(:destroyed?)
+          base.class_eval do
+            before_destroy  { @destroyed = true }
+            def destroyed?; !!@destroyed; end
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/tire/model/import.rb

@@ -0,0 +1,26 @@
+
+module Tire
+  module Model
+
+    # Provides support for easy importing of large ActiveRecord- and ActiveModel-bound
+    # recordsets into model index.
+    #
+    # Relies on pagination support in your model, namely the `paginate` class method.
+    #
+    # Please refer to the relevant of the README for more information.
+    #
+    module Import
+
+      module ClassMethods
+
+        def import options={}, &block
+          options = { :method => 'paginate' }.update options
+          index.import klass, options, &block
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/tire/model/indexing.rb

@@ -0,0 +1,128 @@
+module Tire
+  module Model
+
+    # Contains logic for definition of index settings and mappings.
+    #
+    module Indexing
+
+      module ClassMethods
+
+        # Define [_settings_](http://www.elasticsearch.org/guide/reference/api/admin-indices-create-index.html)
+        # for the corresponding index, such as number of shards and replicas, custom analyzers, etc.
+        #
+        # Usage:
+        #
+        #     class Article
+        #       # ...
+        #       settings :number_of_shards => 1 do
+        #         mapping do
+        #           # ...
+        #         end
+        #       end
+        #     end
+        #
+        def settings(*args)
+          @settings ||= {}
+          args.empty?  ? (return @settings) : @settings = args.pop
+          yield if block_given?
+        end
+
+        # Define the [_mapping_](http://www.elasticsearch.org/guide/reference/mapping/index.html)
+        # for the corresponding index, telling _ElasticSearch_ how to understand your documents:
+        # what type is which property, whether it is analyzed or no, which analyzer to use, etc.
+        #
+        # You may pass the top level mapping properties (such as `_source` or `_all`) as a Hash.
+        #
+        # Usage:
+        #
+        #     class Article
+        #       # ...
+        #       mapping :_source => { :compress => true } do
+        #         indexes :id,    :index    => :not_analyzed
+        #         indexes :title, :analyzer => 'snowball', :boost => 100
+        #         indexes :words, :as       => 'content.split(/\W/).length'
+        #
+        #         indexes :comments do
+        #           indexes :body
+        #           indexes :author do
+        #             indexes :name
+        #           end
+        #         end
+        #
+        #         # ...
+        #       end
+        #     end
+        #
+        def mapping(*args)
+          @mapping ||= {}
+          if block_given?
+            @mapping_options = args.pop
+            yield
+            create_elasticsearch_index
+          else
+            @mapping
+          end
+        end
+
+        # Define mapping for the property passed as the first argument (`name`)
+        # using definition from the second argument (`options`).
+        #
+        # `:type` is optional and defaults to `'string'`.
+        #
+        # Usage:
+        #
+        # * Index property but do not analyze it: `indexes :id, :index    => :not_analyzed`
+        #
+        # * Use different analyzer for indexing a property: `indexes :title, :analyzer => 'snowball'`
+        #
+        # * Use the `:as` option to dynamically define the serialized property value, eg:
+        #
+        #       :as => 'content.split(/\W/).length'
+        #
+        # Please refer to the
+        # [_mapping_ documentation](http://www.elasticsearch.org/guide/reference/mapping/index.html)
+        # for more information.
+        #
+        def indexes(name, options = {}, &block)
+          mapping[name] = options
+
+          if block_given?
+            mapping[name][:type]       ||= 'object'
+            mapping[name][:properties] ||= {}
+
+            previous = @mapping
+            @mapping = mapping[name][:properties]
+            yield
+            @mapping = previous
+          end
+
+          mapping[name][:type] ||= 'string'
+
+          self
+        end
+
+        # Creates the corresponding index with desired settings and mappings, when it does not exists yet.
+        #
+        def create_elasticsearch_index
+          unless index.exists?
+            index.create :mappings => mapping_to_hash, :settings => settings
+          end
+        rescue Errno::ECONNREFUSED => e
+          STDERR.puts "Skipping index creation, cannot connect to ElasticSearch",
+                      "(The original exception was: #{e.inspect})"
+        end
+
+        def mapping_options
+          @mapping_options || {}
+        end
+
+        def mapping_to_hash
+          { document_type.to_sym => mapping_options.merge({ :properties => mapping }) }
+        end
+
+      end
+
+    end
+
+  end
+end