rubberband 0.0.6 → 0.0.7

data/CONTRIBUTORS

@@ -0,0 +1,9 @@
+Maintainer:
+  Grant Rodgers <grantr at gmail dot com>
+
+Contributors:
+  Ernie Makris
+  jeroig
+  mootpointer
+  Ryan Sonnek
+  speedmax

data/README.rdoc

@@ -10,8 +10,8 @@ Copyright 2010 Grant Rodgers. See included LICENSE file.
 == Features
 
 * Automatic failover, retry, and peer discovery
-* Multiple transports (HTTP, Thrift, Memcached TODO)
-* Multiple encodings (JSON (Yajl), Smile TODO)
+* Support for multiple transports (HTTP, Thrift, Memcached TODO)
+* Support for multiple encodings (JSON (Yajl), Smile TODO)
 
 == Usage
 

data/lib/elasticsearch/client/admin_index.rb

@@ -11,6 +11,13 @@ module ElasticSearch
           execute(:index_status, indices, options)
         end
 
+        def index_mapping(*args)
+          options = args.last.is_a?(Hash) ? args.pop : {}
+          indices = args.empty? ? [(default_index || :all)] : args.flatten
+          indices.collect! { |i| PSEUDO_INDICES.include?(i) ? "_#{i}" : i }
+          execute(:index_mapping, indices, options)
+        end
+
         # options: number_of_shards, number_of_replicas
         def create_index(index, create_options={}, options={})
           unless create_options[:index]
@@ -50,12 +57,10 @@ module ElasticSearch
 
         # options: ignore_conflicts
         def update_mapping(mapping, options={})
-          set_default_scope!(options)
-          raise "index and type or defaults required" unless options[:index] && options[:type]
+          index, type, options = extract_required_scope(options)
 
           options = options.dup
-          indices = Array(options.delete(:index))
-          type = options.delete(:type)
+          indices = Array(index)
           unless mapping[type]
             mapping = { type => mapping }
           end

data/lib/elasticsearch/client/default_scope.rb

@@ -19,10 +19,17 @@ module ElasticSearch
 
       private
 
-      def set_default_scope!(options)
-        options[:index] ||= default_index
-        options[:type] ||= default_type
-        nil
+      def extract_scope(options)
+        options = options.dup
+        index = options.delete(:index) || default_index
+        type = options.delete(:type) || default_type
+        [index, type, options]
+      end
+
+      def extract_required_scope(options)
+        scope = extract_scope(options)
+        raise "index and type or defaults required" unless scope[0] && scope[1]
+        scope
       end
     end
   end

data/lib/elasticsearch/client/index.rb

@@ -4,8 +4,7 @@ module ElasticSearch
   module Api
     module Index
       def index(document, options={})
-        set_default_scope!(options)
-        raise "index and type or defaults required" unless options[:index] && options[:type]
+        index, type, options = extract_required_scope(options)
         # type
         # index
         # id (optional)
@@ -13,11 +12,12 @@ module ElasticSearch
         # timeout (optional)
         # document (optional)
 
+        id = options.delete(:id)
         if @batch
-          @batch << { :index => { :_index => options[:index], :_type => options[:type], :_id => options[:id] }}
+          @batch << { :index => { :_index => index, :_type => type, :_id => id }}
           @batch << document
         else
-          result = execute(:index, options[:index], options[:type], options[:id], document, options)
+          result = execute(:index, index, type, id, document, options)
           if result["ok"]
             result["_id"]
           else
@@ -27,27 +27,25 @@ module ElasticSearch
       end
 
       def get(id, options={})
-        set_default_scope!(options)
-        raise "index and type or defaults required" unless options[:index] && options[:type]
+        index, type, options = extract_required_scope(options)
         # index
         # type
         # id
         # fields
         
-        hit = execute(:get, options[:index], options[:type], id, options)
+        hit = execute(:get, index, type, id, options)
         if hit
           Hit.new(hit).freeze
         end
       end
 
       def delete(id, options={})
-        set_default_scope!(options)
-        raise "index and type or defaults required" unless options[:index] && options[:type]
+        index, type, options = extract_required_scope(options)
 
         if @batch
-          @batch << { :delete => { :_index => options[:index], :_type => options[:type], :_id => id }}
+          @batch << { :delete => { :_index => index, :_type => type, :_id => id }}
         else
-          result = execute(:delete, options[:index], options[:type], id, options)
+          result = execute(:delete, index, type, id, options)
           result["ok"]
         end
       end
@@ -65,37 +63,37 @@ module ElasticSearch
       #scroll Get a scroll id to continue paging through the search results. Value is the time to keep a scroll request around, e.g. 5m
       #ids_only Return ids instead of hits
       def search(query, options={})
-        set_default_scope!(options)
+        index, type, options = extract_scope(options)
 
-        #TODO this doesn't work for facets, because they have a valid query key as element. need a list of valid toplevel keys in the search dsl
-        #query = {:query => query} if query.is_a?(Hash) && !query[:query] # if there is no query element, wrap query in one
+        options[:size] ||= (options[:per_page] || options[:limit] || 10)
+        options[:from] ||= options[:size] * (options[:page].to_i-1) if options[:page] && options[:page].to_i > 1
+        options[:from] ||= options[:offset] if options[:offset]
 
-        search_options = slice_hash(options, :df, :analyzer, :default_operator, :explain, :fields, :field, :sort, :from, :size, :search_type, :limit, :per_page, :page, :offset, :scroll)
+        options[:fields] = "_id" if options[:ids_only]
 
-        search_options[:size] ||= (search_options[:per_page] || search_options[:limit] || 10)
-        search_options[:from] ||= search_options[:size] * (search_options[:page].to_i-1) if search_options[:page] && search_options[:page].to_i > 1
-        search_options[:from] ||= search_options[:offset] if search_options[:offset]
+        # options that hits take: per_page, page, ids_only
+        hits_options = options.select { |k, v| [:per_page, :page, :ids_only].include?(k) }
 
-        search_options[:fields] = "_id" if options[:ids_only]
+        # options that elasticsearch doesn't recognize: page, per_page, ids_only, limit, offset
+        options.reject! { |k, v| [:page, :per_page, :ids_only, :limit, :offset].include?(k) }
 
-        response = execute(:search, options[:index], options[:type], query, search_options)
-        Hits.new(response, slice_hash(options, :per_page, :page, :ids_only)).freeze #ids_only returns array of ids instead of hits
+        response = execute(:search, index, type, query, options)
+        Hits.new(response, hits_options).freeze #ids_only returns array of ids instead of hits
       end
 
       #ids_only Return ids instead of hits
       def scroll(scroll_id, options={})
         response = execute(:scroll, scroll_id)
-        Hits.new(response, slice_hash(options, :ids_only)).freeze
+        Hits.new(response, { :ids_only => options[:ids_only] }).freeze
       end 
 
       #df	 The default field to use when no field prefix is defined within the query.
       #analyzer	 The analyzer name to be used when analyzing the query string.
       #default_operator	 The default operator to be used, can be AND or OR. Defaults to OR.
       def count(query, options={})
-        set_default_scope!(options)
+        index, type, options = extract_scope(options)
 
-        count_options = slice_hash(options, :df, :analyzer, :default_operator)
-        response = execute(:count, options[:index], options[:type], query, count_options)
+        response = execute(:count, index, type, query, options)
         response["count"].to_i #TODO check if count is nil
       end
 
@@ -109,14 +107,6 @@ module ElasticSearch
         @batch = nil
       end
 
-      private
-
-      def slice_hash(hash, *keys)
-        h = {}
-        keys.each { |k| h[k] = hash[k] if hash.has_key?(k) }
-        h
-      end
-
     end
   end
 end

data/lib/elasticsearch/transport/base_protocol.rb

@@ -4,16 +4,16 @@ module ElasticSearch
       def index(index, type, id, document, options={})
         body = encoder.is_encoded?(document) ? document : encoder.encode(document)
         if id.nil?
-          response = request(:post, {:index => index, :type => type}, {}, body)
+          response = request(:post, {:index => index, :type => type}, options, body)
         else
-          response = request(:put, {:index => index, :type => type, :id => id}, {}, body)
+          response = request(:put, {:index => index, :type => type, :id => id}, options, body)
         end
         handle_error(response) unless response.status == 200
         encoder.decode(response.body)
       end
 
       def get(index, type, id, options={})
-        response = request(:get, {:index => index, :type => type, :id => id})
+        response = request(:get, {:index => index, :type => type, :id => id}, options)
         return nil if response.status == 404
 
         handle_error(response) unless response.status == 200
@@ -24,7 +24,7 @@ module ElasticSearch
       end
 
       def delete(index, type, id, options={})
-        response = request(:delete,{:index => index, :type => type, :id => id})
+        response = request(:delete,{:index => index, :type => type, :id => id}, options)
         handle_error(response) unless response.status == 200 # ElasticSearch always returns 200 on delete, even if the object doesn't exist
         encoder.decode(response.body)
       end
@@ -98,6 +98,10 @@ module ElasticSearch
         standard_request(:put, {:index => index, :type => type, :op => "_mapping"}, options, encoder.encode(mapping))
       end
 
+      def index_mapping(index_list, options={})
+        standard_request(:get, {:index => index_list, :op => "_mapping"})
+      end
+
       def flush(index_list, options={})
         standard_request(:post, {:index => index_list, :op => "_flush"}, options, "")
       end

data/lib/elasticsearch/version.rb

@@ -2,9 +2,8 @@ module ElasticSearch
   module Version
     MAJOR = 0
     MINOR = 0
-    PATCH = 6
-    BUILD = nil
+    PATCH = 7
 
-    STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
+    STRING = [MAJOR, MINOR, PATCH].compact.join('.')
   end
 end

data/rubberband.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rubberband}
-  s.version = "0.0.6"
+  s.version = "0.0.7"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["grantr"]
-  s.date = %q{2011-01-07}
+  s.date = %q{2011-02-08}
   s.description = %q{An ElasticSearch client with ThriftClient-like failover handling.}
   s.email = %q{grantr@gmail.com}
   s.extra_rdoc_files = [
@@ -18,6 +18,7 @@ Gem::Specification.new do |s|
     "TODO"
   ]
   s.files = [
+    "CONTRIBUTORS",
     "Gemfile",
     "Gemfile.lock",
     "LICENSE",
@@ -49,8 +50,10 @@ Gem::Specification.new do |s|
     "lib/elasticsearch/version.rb",
     "lib/rubberband.rb",
     "rubberband.gemspec",
+    "test/admin_test.rb",
     "test/elasticsearch_test.rb",
     "test/hits_test.rb",
+    "test/index_test.rb",
     "test/test_helper.rb",
     "test/type_test.rb",
     "vendor/elasticsearch/elasticsearch.thrift"
@@ -61,8 +64,10 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.7}
   s.summary = %q{An ElasticSearch client.}
   s.test_files = [
+    "test/admin_test.rb",
     "test/elasticsearch_test.rb",
     "test/hits_test.rb",
+    "test/index_test.rb",
     "test/test_helper.rb",
     "test/type_test.rb"
   ]

data/test/admin_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+class BasicTest < Test::Unit::TestCase
+  context "basic ops" do
+
+    setup do
+      @first_index = 'first-' + Time.now.to_i.to_s
+      @client = ElasticSearch.new('127.0.0.1:9200', :index => @first_index, :type => "tweet")
+    end
+
+    teardown do
+      @client.delete_index(@first_index)
+      sleep(1)
+    end
+
+    #TODO this test fails randomly, there's some kind of timing issue here
+    should "get and update mappings" do
+      @client.index({:foo => "bar"}, :id => "1", :refresh => true)
+      
+      assert_equal({@first_index => {"tweet" => { "properties" => { "foo" => {"type" => "string" }}}}}, @client.index_mapping(@first_index))
+      @client.update_mapping({"tweet" => {:properties => {:bar => {:type => "string"}}}})
+      assert_equal({@first_index => {"tweet" => { "properties" => { "foo" => {"type" => "string" }, "bar" => { "type" => "string"}}}}}, @client.index_mapping(@first_index))
+    end
+  end
+end

data/test/index_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+class IndexTest < Test::Unit::TestCase
+  context "index ops" do
+
+    setup do
+      @first_index = 'first-' + Time.now.to_i.to_s
+      @client = ElasticSearch.new('127.0.0.1:9200', :index => @first_index, :type => "tweet")
+    end
+
+    teardown do
+      @client.delete_index(@first_index)
+      sleep(1)
+    end
+
+    should "do basic ops on a document" do
+      @client.index({:foo => "bar"}, :id => "1", :refresh => true)
+
+      assert_equal "bar", @client.get("1").foo
+      assert_equal true, @client.delete("1", :refresh => true)
+      assert_equal nil, @client.get("1")
+
+      @client.index({:foo => "bar"}, :id => "1")
+      @client.index({:foo => "baz"}, :id => "2")
+      @client.index({:foo => "baz also"}, :id => "3")
+      @client.refresh(@first_index)
+
+      assert_equal 1, @client.search("bar").size
+      assert_equal 1, @client.count("bar")
+
+      assert_equal 2, @client.search(:query => { :term => { :foo => 'baz' }}).size
+      assert_equal 2, @client.count(:term => { :foo => 'baz' })
+    end
+  end
+end

data/test/type_test.rb

@@ -2,43 +2,46 @@ require 'test_helper'
 
 class TypeTest < Test::Unit::TestCase
   context "Test with differents Types" do
-    #TODO figure out how to have one setup and one teardown
+
     setup do
-      @client = ElasticSearch.new('127.0.0.1:9200', :index => "twitter", :type => "tweet")
-      @client.index({:user => "kimchy"}, :id => 1)
-      @client.index({:user => "kimchy"}, :id => 2, :type => "grillo")
-      @client.index({:user => "kimchy"}, :id => 3, :type => "cote")
-      @client.index({:user => "kimchy"}, :id => 4, :index => "cotes", :type => "cote")
-      @client.index({:user => "kimchy"}, :id => 5, :index => "menchos", :type => "mencho")
-      @client.index({:user => "kimchy"}, :id => 6, :index => "menchos", :type => "cote")
-      @client.refresh("twitter", "cotes", "menchos")
+      @first_index = 'first-' + Time.now.to_i.to_s
+      @second_index = 'second-' + Time.now.to_i.to_s
+      @third_index = 'third-' + Time.now.to_i.to_s
+      @username = 'kimchy' + Time.now.to_i.to_s
+      @client = ElasticSearch.new('127.0.0.1:9200', :index => @first_index, :type => "tweet")
+      @client.index({:user => @username}, :id => 1)
+      @client.index({:user => @username}, :id => 2, :type => "grillo")
+      @client.index({:user => @username}, :id => 3, :type => "cote")
+      @client.index({:user => @username}, :id => 4, :index => @second_index, :type => "cote")
+      @client.index({:user => @username}, :id => 5, :index => @third_index, :type => "mencho")
+      @client.index({:user => @username}, :id => 6, :index => @third_index, :type => "cote")
+      @client.refresh(@first_index, @second_index, @third_index)
     end
 
     teardown do
-      #@client.delete_index("twitter")
-      #@client.delete_index("cotes")
-      #@client.delete_index("menchos")
+      @client.delete_index(@first_index)
+      @client.delete_index(@second_index)
+      @client.delete_index(@third_index)
+      sleep(1)
     end
 
-    should "search in all indexes" do
-      assert_equal @client.count("kimchy",{:index => "", :type => ""}), 6
-    end
-    
-    should "search in all types with index twitter" do
-      assert_equal @client.count("kimchy",{:index => "twitter", :type => ""}), 3
-    end
-    
-    should "search in index twitter with types tweet,cote" do
-      assert_equal @client.count("kimchy",{:index => "twitter", :type => "tweet,cote"}), 2
+    should "Test different stages using indexes and types" do
+      # Search in all indexes
+      assert_equal @client.count(@username,{:index => "", :type => ""}), 6
+      
+      # Search in all types with index first
+      assert_equal @client.count(@username,{:index => @first_index, :type => ""}), 3
+      
+      # Search in first index with types tweet,cote
+      assert_equal @client.count(@username,{:index => @first_index, :type => "tweet,cote"}), 2
+      
+      # Search in index first and second
+      @first_and_second = @first_index + ',' + @second_index  
+      assert_equal @client.count(@username,{:index => @first_and_second,  :type => ""}), 4
+      
+      # Search in types grillo,cote of all indexes" do
+      assert_equal @client.count(@username,{:index => "",  :type => "grillo,cote"}), 4
     end
-    
-    should "search in index twitter,cotes" do
-      assert_equal @client.count("kimchy",{:index => "twitter,cotes",  :type => ""}), 4
-    end
-    
-    should "search in types grillo,cote of all indexes" do
-      assert_equal @client.count("kimchy",{:index => "",  :type => "grillo,cote"}), 4
-    end
-    
+
   end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 6
-  version: 0.0.6
+  - 7
+  version: 0.0.7
 platform: ruby
 authors: 
 - grantr
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-07 00:00:00 -08:00
+date: 2011-02-08 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -110,6 +110,7 @@ extra_rdoc_files:
 - README.rdoc
 - TODO
 files: 
+- CONTRIBUTORS
 - Gemfile
 - Gemfile.lock
 - LICENSE
@@ -141,8 +142,10 @@ files:
 - lib/elasticsearch/version.rb
 - lib/rubberband.rb
 - rubberband.gemspec
+- test/admin_test.rb
 - test/elasticsearch_test.rb
 - test/hits_test.rb
+- test/index_test.rb
 - test/test_helper.rb
 - test/type_test.rb
 - vendor/elasticsearch/elasticsearch.thrift
@@ -160,7 +163,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -3014120754088484755
+      hash: -4380067439050607353
       segments: 
       - 0
       version: "0"
@@ -180,7 +183,9 @@ signing_key:
 specification_version: 3
 summary: An ElasticSearch client.
 test_files: 
+- test/admin_test.rb
 - test/elasticsearch_test.rb
 - test/hits_test.rb
+- test/index_test.rb
 - test/test_helper.rb
 - test/type_test.rb