tire-erez 0.5.4

data/lib/tire.rb

@@ -0,0 +1,59 @@
+require 'rest_client'
+require 'multi_json'
+require 'active_model'
+require 'hashr'
+require 'cgi'
+
+require 'active_support/core_ext/object/to_param'
+require 'active_support/core_ext/object/to_query'
+require 'active_support/core_ext/hash/except.rb'
+
+# Ruby 1.8 compatibility
+require 'tire/rubyext/ruby_1_8' if defined?(RUBY_VERSION) && RUBY_VERSION < '1.9'
+
+require 'tire/version'
+require 'tire/rubyext/hash'
+require 'tire/rubyext/symbol'
+require 'tire/utils'
+require 'tire/logger'
+require 'tire/configuration'
+require 'tire/http/response'
+require 'tire/http/client'
+require 'tire/search'
+require 'tire/search/query'
+require 'tire/search/queries/match'
+require 'tire/search/sort'
+require 'tire/search/facet'
+require 'tire/search/filter'
+require 'tire/search/highlight'
+require 'tire/search/scan'
+require 'tire/search/script_field'
+require 'tire/multi_search'
+require 'tire/count'
+require 'tire/results/pagination'
+require 'tire/results/collection'
+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
+  extend DSL
+
+  def warn(message)
+    line = caller.detect { |line| line !~ %r|lib\/tire\/| }.sub(/:in .*/, '')
+    STDERR.puts  "", "\e[31m[DEPRECATION WARNING] #{message}", "(Called from #{line})", "\e[0m"
+  end
+  module_function :warn
+end

data/lib/tire/alias.rb

@@ -0,0 +1,296 @@
+module Tire
+
+  # Represents an *alias* in _Elasticsearch_. An alias may point to one or multiple
+  # indices, for instance to separate physical indices into logical entities, where
+  # each user has a "virtual index" or for setting up "sliding window" scenarios.
+  #
+  # See: http://www.elasticsearch.org/guide/reference/api/admin-indices-aliases.html
+  #
+  class Alias
+
+    # Create an alias pointing to multiple indices:
+    #
+    #     Tire::Alias.create name: 'my_alias', indices: ['index_1', 'index_2']
+    #
+    # Pass the routing and/or filtering configuration in the options Hash:
+    #
+    #     a = Tire::Alias.new name:    'index_anne',
+    #                     indices: ['index_2012_04', 'index_2012_03', 'index_2012_02'],
+    #                     routing: 1,
+    #                     filter:  { :terms => { :user => 'anne' } }
+    #     a.save
+    #
+    # You may configure the alias in an imperative manner:
+    #
+    #     a = Tire::Alias.new
+    #     a.name('index_anne')
+    #     a.index('index_2012_04')
+    #     a.index('index_2012_03')
+    #     # ...
+    #     a.save
+    #
+    # or more declaratively, with a block:
+    #
+    #     Tire::Alias.new name: 'my_alias' do
+    #       index 'index_A'
+    #       index 'index_B'
+    #       filter :terms, username: 'mary'
+    #     end
+    #
+    # To update an existing alias, find it by name, configure it and save it:
+    #
+    #     a = Tire::Alias.find('my_alias')
+    #     a.indices.delete 'index_A'
+    #     a.indices.add    'index_B'
+    #     a.indices.add    'index_C'
+    #     a.save
+    #
+    # Or do it with a block:
+    #
+    #     Tire::Alias.find('articles_aliased') do |a|
+    #       a.indices.remove 'articles_2'
+    #       puts '---', "#{a.name} says: /me as JSON >", a.as_json, '---'
+    #       a.save
+    #     end
+    #
+    # To remove indices from alias, you may want to use the `delete_all` method:
+    #
+    #
+    #     require 'active_support/core_ext/numeric'
+    #     require 'active_support/core_ext/date/calculations'
+    #
+    #     a = Tire::Alias.find('articles_aliased')
+    #     a.indices.delete_if do |i|
+    #       Time.parse( i.gsub(/articles_/, '') ) < 4.weeks.ago rescue false
+    #     end
+    #     a.save
+    #
+    # To get all aliases, use the `Tire::Alias.all` method:
+    #
+    #     Tire::Alias.all.each do |a|
+    #      puts "#{a.name.rjust(30)} points to: #{a.indices}"
+    #    end
+    #
+    def initialize(attributes={}, &block)
+      raise ArgumentError, "Please pass a Hash-like object" unless attributes.respond_to?(:each_pair)
+
+      @attributes = { :indices => IndexCollection.new([]) }
+
+      attributes.each_pair do |key, value|
+        if ['index','indices'].include? key.to_s
+          @attributes[:indices] = IndexCollection.new(value)
+        else
+          @attributes[key.to_sym] = value
+        end
+      end
+
+      block.arity < 1 ? instance_eval(&block) : block.call(self) if block_given?
+    end
+
+    # Returns a collection of Tire::Alias objects for all aliases defined in the cluster, or for a specific index.
+    #
+    def self.all(index=nil)
+      @response = Configuration.client.get [Configuration.url, index, '_aliases'].compact.join('/')
+
+      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, 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))
+      end
+
+    ensure
+      # FIXME: Extract the `logged` method
+      Alias.new.logged '_aliases', %Q|curl "#{Configuration.url}/_aliases"|
+    end
+
+    # Returns an alias by name
+    #
+    def self.find(name, &block)
+      a = all.select { |a| a.name == name }.first
+      block.call(a) if block_given?
+      return a
+    end
+
+    # Create new alias
+    #
+    def self.create(attributes={}, &block)
+      new(attributes, &block).save
+    end
+
+    # Delegate to the `@attributes` Hash
+    #
+    def method_missing(method_name, *arguments)
+      @attributes.has_key?(method_name.to_sym) ? @attributes[method_name.to_sym] : super
+    end
+
+    # Get or set the alias name
+    #
+    def name(value=nil)
+      value ? (@attributes[:name] = value and return self) : @attributes[:name]
+    end
+
+    # Get or set the alias indices
+    #
+    def indices(*names)
+      names = Array(names).flatten
+      names.compact.empty? ? @attributes[:indices] : (names.each { |n| @attributes[:indices].push(n) } and return self)
+    end
+    alias_method :index, :indices
+
+    # Get or set the alias routing
+    #
+    def routing(value=nil)
+      value ? (@attributes[:routing] = value and return self) : @attributes[:routing]
+    end
+
+    # Get or set the alias routing
+    def filter(type=nil, *options)
+      type ? (@attributes[:filter] = Search::Filter.new(type, *options).to_hash and return self ) : @attributes[:filter]
+    end
+
+    # Save the alias in _Elasticsearch_
+    #
+    def save
+      @response = Configuration.client.post "#{Configuration.url}/_aliases", to_json
+
+    ensure
+      logged '_aliases', %Q|curl -X POST "#{Configuration.url}/_aliases" -d '#{to_json}'|
+    end
+
+    # Return a Hash suitable for JSON serialization
+    #
+    def as_json(options=nil)
+      actions = []
+      indices.add_indices.each do |index|
+        operation = { :index => index, :alias => name }
+        operation.update( { :routing => routing } ) if respond_to?(:routing) and routing
+        operation.update( { :filter  => filter } )  if respond_to?(:filter)  and filter
+        actions.push( { :add => operation } )
+      end
+
+      indices.remove_indices.each do |index|
+        operation = { :index => index, :alias => name }
+        actions.push( { :remove => operation } )
+      end
+
+      { :actions => actions }
+    end
+
+    # Return alias serialized in JSON for _Elasticsearch_
+    #
+    def to_json(options=nil)
+      as_json.to_json
+    end
+
+    def inspect
+      %Q|<#{self.class} #{@attributes.inspect}>|
+    end
+
+    def to_s
+      name
+    end
+
+    def logged(endpoint='/', curl='')
+      # FIXME: Extract the `logged` method into module and mix it into classes
+      if Configuration.logger
+        error = $!
+
+        Configuration.logger.log_request endpoint, @name, curl
+
+        code = @response ? @response.code : error.class rescue 200
+
+        if Configuration.logger.level.to_s == 'debug'
+          body = if @response
+            MultiJson.encode(@response.body, :pretty => Configuration.pretty)
+          else
+            error.message rescue ''
+          end
+        else
+          body = ''
+        end
+
+        Configuration.logger.log_response code, nil, body
+      end
+    end
+
+    # Thin wrapper around array representing a collection of indices for a specific alias,
+    # which allows hooking into adding/removing indices.
+    #
+    # It keeps track of which aliases to add and which to remove in two separate collections,
+    # `add_indices` and `remove_indices`.
+    #
+    # It delegates Enumerable-like methods to the `add_indices` collection.
+    #
+    class IndexCollection
+      include Enumerable
+      attr_reader :add_indices, :remove_indices
+
+      def initialize(*values)
+        @add_indices    = Array.new(values).flatten.compact
+        @remove_indices = []
+      end
+
+      def push(value)
+        @add_indices |= [value]
+        @remove_indices.delete value
+      end
+      alias_method :add, :push
+
+      def delete(value)
+        @add_indices.delete value
+        @remove_indices |= [value]
+      end
+      alias_method :remove, :delete
+
+      def delete_if(&block)
+        @add_indices.clone.each do |name|
+          delete(name) if block.call(name)
+        end
+      end
+
+      def each(&block)
+        @add_indices.each(&block)
+      end
+
+      def empty?
+        @add_indices.empty?
+      end
+
+      def clear
+        @remove_indices = @add_indices.clone
+        @add_indices.clear
+      end
+
+      def [](index)
+        @add_indices[index]
+      end
+
+      def size
+        @add_indices.size
+      end
+
+      def to_ary
+        @add_indices
+      end
+
+      def to_s
+        @add_indices.join(', ')
+      end
+
+      def inspect
+        %Q|<#{self.class} #{@add_indices.map{|i| "\"#{i}\""}.join(', ')}>|
+      end
+
+    end
+
+  end
+
+end

data/lib/tire/configuration.rb

@@ -0,0 +1,38 @@
+module Tire
+
+  class Configuration
+
+    def self.url(value=nil)
+      @url = (value ? value.to_s.gsub(%r|/*$|, '') : nil) || @url || ENV['ELASTICSEARCH_URL'] || "http://localhost:9200"
+    end
+
+    def self.client(klass=nil)
+      @client = klass || @client || HTTP::Client::RestClient
+    end
+
+    def self.wrapper(klass=nil)
+      @wrapper = klass || @wrapper || Results::Item
+    end
+
+    def self.logger(device=nil, options={})
+      return @logger = Logger.new(device, options) if device
+      @logger || nil
+    end
+
+    def self.pretty(value=nil, options={})
+      if value === false
+        return @pretty = false
+      else
+        @pretty.nil? ? true : @pretty
+      end
+    end
+
+    def self.reset(*properties)
+      reset_variables = properties.empty? ? instance_variables : instance_variables.map { |p| p.to_s} & \
+                                                                 properties.map         { |p| "@#{p}" }
+      reset_variables.each { |v| instance_variable_set(v.to_sym, nil) }
+    end
+
+  end
+
+end

data/lib/tire/count.rb

@@ -0,0 +1,85 @@
+module Tire
+  module Search
+    class CountRequestFailed < StandardError; end
+
+    class Count
+
+      attr_reader :indices, :types, :query, :response, :json
+
+      def initialize(indices=nil, options={}, &block)
+        @indices = Array(indices)
+        @types   = Array(options.delete(:type)).map { |type| Utils.escape(type) }
+        @options = options
+
+        @path    = ['/', @indices.join(','), @types.join(','), '_count'].compact.join('/').squeeze('/')
+
+        if block_given?
+          @query = Query.new
+          block.arity < 1 ? @query.instance_eval(&block) : block.call(@query)
+        end
+      end
+
+      def url
+        Configuration.url + @path
+      end
+
+      def params
+        options = @options.except(:wrapper)
+        options.empty? ? '' : '?' + options.to_param
+      end
+
+      def perform
+        @response = Configuration.client.get self.url + self.params, self.to_json
+        if @response.failure?
+          STDERR.puts "[REQUEST FAILED] #{self.to_curl}\n"
+          raise CountRequestFailed, @response.to_s
+        end
+        @json     = MultiJson.decode(@response.body)
+        @value    = @json['count']
+        return self
+      ensure
+        logged
+      end
+
+      def value
+        @value || (perform and return @value)
+      end
+
+      def to_json(options={})
+        @query.to_json if @query
+      end
+
+      def to_curl
+        if to_json
+          to_json_escaped = to_json.gsub("'",'\u0027')
+          %Q|curl -X GET '#{url}#{params.empty? ? '?' : params.to_s + '&'}pretty' -d '#{to_json_escaped}'|
+        else
+          %Q|curl -X GET '#{url}#{params.empty? ? '?' : params.to_s + '&'}pretty'|
+        end
+      end
+
+      def logged(endpoint='_count')
+        if Configuration.logger
+
+          Configuration.logger.log_request endpoint, indices, to_curl
+
+          code = @response.code rescue nil
+
+          if Configuration.logger.level.to_s == 'debug'
+            body = if @json
+              MultiJson.encode( @json, :pretty => Configuration.pretty)
+            else
+              MultiJson.encode( MultiJson.load(@response.body), :pretty => Configuration.pretty) rescue ''
+            end
+          else
+            body = ''
+          end
+
+          Configuration.logger.log_response code || 'N/A', 'N/A', body || 'N/A'
+        end
+      end
+
+    end
+
+  end
+end