riak-client 2.2.0.pre1 → 2.2.0

data/lib/riak/search/result_collection.rb

@@ -8,7 +8,7 @@ module Riak::Search
   class ResultCollection
     # @return [Riak::Client]
     attr_reader :client
-    
+
     # @return [Hash] the de-serialzed hash returned from Solr
     attr_reader :raw
 
@@ -52,13 +52,13 @@ module Riak::Search
     end
 
     # @param [Integer] index the index of the [Riak::RObject] to load and return
-    # @return [Riak::RObject,NilClass] the found object, or nil if the index 
+    # @return [Riak::RObject,NilClass] the found object, or nil if the index
     #   is out of range
     def [](index)
       doc = docs[index]
       return nil if doc.nil?
 
-      doc.robject
+      doc.object
     end
 
     # @return [Riak::RObject,NilClass] the first found object, or nil if the
@@ -67,6 +67,59 @@ module Riak::Search
       self[0]
     end
 
+    # Materializes and returns an array of objects from search results.
+    # You'll probably need to type inspect its members.
+    #
+    # @return [Array] materialized objects
+    def objects
+      @objects ||= docs.map do |doc|
+        next doc.crdt if doc.crdt?
+        doc.robject
+      end
+    end
+
+    # Materializes [Riak::RObject]s from any key-value results. Refuses to
+    # return RObjects for any CRDT results.
+    #
+    # @return [Array<Riak::RObject>] key-value objects
+    def robjects
+      @robjects ||= docs.reject(&:crdt?).map(&:robject)
+    end
+
+    # Materializes [Riak::Crdt::Base] subclasses from any CRDT results.
+    #
+    # @return [Array<Riak::Crdt::Base>] CRDT objects
+    def crdts
+      @crdts ||= docs.select(&:crdt?).map(&:crdt)
+    end
+
+    # Materializes [Riak::Crdt::Counter] results.
+    #
+    # @return [Array<Riak::Crdt::Counter] counter objects
+    def counters
+      @counters ||= docs.
+                  select{ |d| d.type_class == Riak::Crdt::Counter }.
+                  map(&:counter)
+    end
+
+    # Materializes [Riak::Crdt::Map] results.
+    #
+    # @return [Array<Riak::Crdt::Map] map objects
+    def maps
+      @maps ||= docs.
+              select{ |d| d.type_class == Riak::Crdt::Map }.
+              map(&:map)
+    end
+
+    # Materializes [Riak::Crdt::Set] results.
+    #
+    # @return [Array<Riak::Crdt::Set>]
+    def sets
+      @sets ||= docs.
+              select{ |d| d.type_class == Riak::Crdt::Set }.
+              map(&:set)
+    end
+
     # {Enumerable}-compatible iterator method. If a block is given, yields with
     # each {Riak::RObject} in the collection. If no block is given, returns an
     # {Enumerator} over each {Riak::RObject in the collection.

data/lib/riak/search/result_document.rb

@@ -1,7 +1,9 @@
+require 'riak/errors/crdt_error'
+
 module Riak::Search
 
   # A single document from a Riak Search 2 response. Materializes the document
-  # fields into {Riak::BucketType}, {Riak::Bucket}, and {Riak::RObject} 
+  # fields into {Riak::BucketType}, {Riak::Bucket}, and {Riak::RObject}
   # instances on demand.
   class ResultDocument
     # @return [Riak::Client]
@@ -41,6 +43,55 @@ module Riak::Search
       @score ||= Float(raw['score'])
     end
 
+    # Determining if the object is a CRDT or regular K-V object requires
+    # figuring out what data type the bucket type contains. If the bucket type
+    # has no data type, treat it as a regular K-V object.
+    #
+    # @return [Class] the class of the object referred to by the search result
+    def type_class
+      bucket_type.data_type_class || Riak::RObject
+    end
+
+    # @return [Boolean] if the object is a CRDT
+    def crdt?
+      type_class != Riak::RObject
+    end
+
+    # @raise [Riak::CrdtError::NotACrdt] if the result is not a CRDT
+    # @return [Riak::Crdt::Base] the materialized CRDT
+    def crdt
+      fail Riak::CrdtError::NotACrdt unless crdt?
+
+      type_class.new bucket, key, bucket_type
+    end
+
+    # If the result document describes a counter, return it.
+    #
+    # @return [Riak::Crdt::Counter]
+    # @raise [Riak::CrdtError::NotACrdt] if the result is not a CRDT
+    # @raise [Riak::CrdtError::UnexpectedDataType] if the CRDT is not a counter
+    def counter
+      return crdt if check_type_class Riak::Crdt::Counter
+    end
+
+    # If the result document describes a map, return it.
+    #
+    # @return [Riak::Crdt::Map]
+    # @raise [Riak::CrdtError::NotACrdt] if the result is not a CRDT
+    # @raise [Riak::CrdtError::UnexpectedDataType] if the CRDT is not a map
+    def map
+      return crdt if check_type_class Riak::Crdt::Map
+    end
+
+    # If the result document describes a set, return it.
+    #
+    # @return [Riak::Crdt::Set]
+    # @raise [Riak::CrdtError::NotACrdt] if the result is not a CRDT
+    # @raise [Riak::CrdtError::UnexpectedDataType] if the CRDT is not a set
+    def set
+      return crdt if check_type_class Riak::Crdt::Set
+    end
+
     # Provides access to other parts of the result document without
     # materializing them. Useful when querying non-default fields.
     #
@@ -53,7 +104,26 @@ module Riak::Search
     #
     # @return [Riak::RObject]
     def robject
+      if crdt?
+        fail Riak::SearchError::UnexpectedResultError.
+              new(Riak::RObject, type_class)
+      end
+
       @robject ||= bucket.get key
     end
+
+    # Returns an appropriate object, be it CRDT or K-V.
+    def object
+      return crdt if crdt?
+      robject
+    end
+
+    private
+
+    def check_type_class(klass)
+      return true if type_class == klass
+      fail Riak::CrdtError::NotACrdt if type_class == Riak::RObject
+      fail Riak::CrdtError::UnexpectedDataType.new(klass, type_class)
+    end
   end
 end

data/lib/riak/search/schema.rb

@@ -27,23 +27,24 @@ module Riak::Search
     def content
       schema_data.content
     end
-    
+
     # @param [String] content the XML content of this schema
     # @raise [Riak::SearchError::SchemaExistsError] if a schema with the given
     #   name already exists
     def create!(content)
-      raise Riak::SearchError::SchemaExistsError.new name if exists?
+      fail Riak::SearchError::SchemaExistsError.new name if exists?
 
       @client.backend do |b|
         b.create_search_schema name, content
       end
-      
+
       @schema_data = nil
 
       true
     end
 
     private
+
     def schema_data
       return @schema_data if defined?(@schema_data) && @schema_data
 
@@ -57,9 +58,8 @@ module Riak::Search
         return nil if e.not_found?
         raise e
       end
-      
-      return @schema_data = sd
+
+      @schema_data = sd
     end
   end
 end
-

data/lib/riak/secondary_index.rb

@@ -2,6 +2,9 @@ require 'riak/index_collection'
 require 'riak/bucket_typed/bucket'
 
 module Riak
+  # {Riak::SecondaryIndex} provides an object-oriented interface to secondary
+  # index ("2i") functionality in Riak, available on the `memory` and `leveldb`
+  # backends.
   class SecondaryIndex
     include Util::Translation
     include Client::FeatureDetection
@@ -11,7 +14,7 @@ module Riak
     # @param [String] index the index name
     # @param [String,Integer,Range<String,Integer>] query
     #   a single value or range of values to query for
-    def initialize(bucket, index, query, options={})
+    def initialize(bucket, index, query, options = {})
       @bucket = bucket
       @client = @bucket.client
       @index = index
@@ -26,7 +29,7 @@ module Riak
     end
 
     def get_server_version
-      @client.backend{|b| b.send :get_server_version }
+      @client.backend { |b| b.send :get_server_version }
     end
 
     # Get the array of matched keys
@@ -39,17 +42,17 @@ module Riak
 
     # Get the array of values
     def values
-      @values ||= @bucket.get_many(self.keys).values
+      @values ||= @bucket.get_many(keys).values
     end
 
     # Get a new SecondaryIndex fetch for the next page
     def next_page
-      raise t('index.no_next_page') unless keys.continuation
+      fail t('index.no_next_page') unless keys.continuation
 
-      self.class.new(@bucket, 
-                     @index, 
-                     @query, 
-                     @options.merge(:continuation => keys.continuation))
+      self.class.new(@bucket,
+                     @index,
+                     @query,
+                     @options.merge(continuation: keys.continuation))
     end
 
     # Determine whether a SecondaryIndex fetch has a next page available
@@ -58,12 +61,17 @@ module Riak
     end
 
     private
+
     def validate_options
-      raise t('index.pagination_not_available') if paginated? && !index_pagination?
-      raise t('index.return_terms_not_available') if @options[:return_terms] && !index_return_terms?
-      raise t('index.include_terms_is_wrong') if @options[:include_terms]
+      if paginated? && !index_pagination?
+        fail t('index.pagination_not_available')
+      end
+
+      if @options[:return_terms] && !index_return_terms?
+        fail t('index.return_terms_not_available')
+      end
 
-      # raise t('index.streaming_not_available') if @options[:stream] && !index_streaming?
+      fail t('index.include_terms_is_wrong') if @options[:include_terms]
     end
 
     def paginated?

data/lib/riak/serializers.rb

@@ -71,4 +71,3 @@ module Riak
     end
   end
 end
-

data/lib/riak/util/escape.rb

@@ -52,9 +52,9 @@ module Riak
       # @return [String] the escaped path segment
       def escape(bucket_or_key)
         if Riak.escaper == URI
-          Riak.escaper.escape(bucket_or_key.to_s).gsub(" ", "%20").gsub("+", "%2B").gsub('/', "%2F")
+          Riak.escaper.escape(bucket_or_key.to_s).gsub(/[ \+\/]/, { " " => "%20", "+" => "%2B", "/" => "%2F"})
         else #CGI
-          Riak.escaper.escape(bucket_or_key.to_s).gsub("+", "%20").gsub('/', "%2F")
+          Riak.escaper.escape(bucket_or_key.to_s).gsub(/[\+\/]/, { "+" => "%20", "/" => "%2F"})
         end
       end
 

data/lib/riak/util/translation.rb

@@ -10,10 +10,9 @@ module Riak
       end
 
       # Provides the translation for a given internationalized message
-      def t(message, options={})
+      def t(message, options = {})
         I18n.t("#{i18n_scope}.#{message}", options)
       end
     end
   end
 end
-

data/lib/riak/version.rb

@@ -1,3 +1,3 @@
 module Riak
-  VERSION = "2.2.0.pre1"
+  VERSION = "2.2.0"
 end

data/lib/riak/walk_spec.rb

@@ -19,13 +19,16 @@ module Riak
     extend Util::Translation
     include Util::Escape
 
-    # @return [String] The bucket followed links should be restricted to. "_" represents all buckets.
+    # @return [String] The bucket followed links should be restricted to.
+    #   "_" represents all buckets.
     attr_accessor :bucket
 
-    # @return [String] The "riaktag" or "rel" that followed links should be restricted to. "_" represents all tags.
+    # @return [String] The "riaktag" or "rel" that followed links should be
+    #   restricted to. "_" represents all tags.
     attr_accessor :tag
 
-    # @return [Boolean] Whether objects should be returned from this phase of link walking. Default is false.
+    # @return [Boolean] Whether objects should be returned from this phase
+    #   of link walking. Default is false.
     attr_accessor :keep
 
     # Normalize a list of walk specs into WalkSpec objects.
@@ -33,18 +36,13 @@ module Riak
       params.flatten!
       specs = []
       while params.length > 0
-        param = params.shift
-        case param
+        case param = params.shift
         when Hash
           specs << new(param)
         when WalkSpec
           specs << param
         else
-          if params.length >= 2
-            specs << new(param, params.shift, params.shift)
-          else
-            raise ArgumentError, t("too_few_arguments", :params => params.inspect)
-          end
+          normalize_long_params specs, params, param
         end
       end
       specs
@@ -54,30 +52,34 @@ module Riak
     # @overload initialize(hash)
     #   Creates a walk-spec from a hash.
     #   @param [Hash] hash options for the walk-spec
-    #   @option hash [String] :bucket ("_") the bucket the links should point to (default '_' is all)
-    #   @option hash [String] :tag ("_") the tag to filter links by (default '_' is all)
-    #   @option hash [Boolean] :keep (false) whether to return results from following this link specification
+    #   @option hash [String] :bucket ("_") the bucket the links should point to
+    #     (default '_' is all)
+    #   @option hash [String] :tag ("_") the tag to filter links by (default '_'
+    #     is all)
+    #   @option hash [Boolean] :keep (false) whether to return results from
+    #     following this link specification
     # @overload initialize(bucket, tag, keep)
     #   Creates a walk-spec from a bucket-tag-result triple.
-    #   @param [String] bucket the bucket the links should point to (default '_' is all)
+    #   @param [String] bucket the bucket the links should point to (default '_'
+    #     is all)
     #   @param [String] tag the tag to filter links by (default '_' is all)
-    #   @param [Boolean] keep whether to return results from following this link specification
+    #   @param [Boolean] keep whether to return results from following this link
+    #     specification
     # @see {Riak::RObject#walk}
     def initialize(*args)
       args.flatten!
       case args.size
       when 1
-        hash = args.first
-        raise ArgumentError, t("hash_type", :hash => hash.inspect) unless Hash === hash
-        assign(hash[:bucket], hash[:tag], hash[:keep])
+        assign_from_hash args.first
       when 3
         assign(*args)
       else
-        raise ArgumentError, t("wrong_argument_count_walk_spec")
+        fail ArgumentError, t('wrong_argument_count_walk_spec')
       end
     end
 
-    # Converts the walk-spec into the form required by the link-walker resource URL
+    # Converts the walk-spec into the form required by the link-walker resource
+    # URL
     def to_s
       b = @bucket && escape(@bucket) || '_'
       t = @tag && escape(@tag) || '_'
@@ -85,26 +87,59 @@ module Riak
     end
 
     def ==(other)
-      other.is_a?(WalkSpec) && other.bucket == bucket && other.tag == tag && other.keep == keep
+      return false unless other.is_a? WalkSpec
+      return false unless other.bucket == bucket
+      return false unless other.tag == tag
+      return false unless other.keep == keep
+      true
     end
 
     def ===(other)
-      self == other || case other
-                       when WalkSpec
-                         other.keep == keep &&
-                           (bucket == "_" || bucket == other.bucket) &&
-                           (tag == "_" || tag == other.tag)
-                       when Link
-                         (bucket == "_" || bucket == other.url.split("/")[2]) &&
-                           (tag == "_" || tag == other.rel)
-                       end
+      return true if self == other
+      case other
+      when WalkSpec
+        walkspec_threequality(other)
+      when Link
+        link_threequality(other)
+      end
     end
 
     private
+
+    def self.normalize_long_params(specs, params, param)
+      if params.length >= 2
+        specs << new(param, params.shift, params.shift)
+      else
+        fail ArgumentError, t('too_few_arguments',
+                              params: params.inspect)
+      end
+    end
+
+    def assign_from_hash(hash)
+      unless hash.is_a? Hash
+        fail ArgumentError, t('hash_type', hash: hash.inspect)
+      end
+
+      assign(hash[:bucket], hash[:tag], hash[:keep])
+    end
+
     def assign(bucket, tag, result)
-      @bucket = bucket || "_"
-      @tag = tag || "_"
+      @bucket = bucket || '_'
+      @tag = tag || '_'
       @keep = result || false
     end
+
+    def walkspec_threequality(other)
+      return false unless other.keep == keep
+      return false unless bucket == '_' || bucket == other.bucket
+      return false unless tag == '_' || tag == other.tag
+      true
+    end
+
+    def link_threequality(other)
+      return false unless bucket == '_' || bucket == other.url.split('/')[2]
+      return false unless tag == '_' || tag == other.rel
+      true
+    end
   end
 end