riak-client 0.8.3 → 0.9.0.beta

data/lib/riak/link.rb

@@ -22,7 +22,7 @@ module Riak
     # @return [String] the relationship tag (or "rel") of the other resource to this one
     attr_accessor :tag
     alias_method :rel, :tag
-    alias_method :rel=, :tag=
+    alias_method :'rel=', :'tag='
 
     # @return [String] the bucket of the related resource
     attr_accessor :bucket
@@ -30,6 +30,10 @@ module Riak
     # @return [String] the key of the related resource
     attr_accessor :key
 
+    %w{bucket key}.each do |m|
+      class_eval %{ def #{m}=(value); @url = nil; @#{m} = value; end }
+    end
+
     # @param [String] header_string the string value of the Link: HTTP header from a Riak response
     # @return [Array<Link>] an array of Riak::Link structs parsed from the header
     def self.parse(header_string)
@@ -56,12 +60,13 @@ module Riak
 
     # @return [String] the URL (relative or absolute) of the related resource
     def url
-      "/riak/#{escape(bucket)}" + (key.blank? ? "" : "/#{escape(key)}")
+      @url ||= "/riak/#{escape(bucket)}" + (key.blank? ? "" : "/#{escape(key)}")
     end
 
     def url=(value)
-      @bucket = CGI.unescape($1) if value =~ %r{^/[^/]+/([^/]+)/?}
-      @key = CGI.unescape($1) if value =~ %r{^/[^/]+/[^/]+/([^/]+)/?}
+      @url = value
+      @bucket = unescape($1) if value =~ %r{^/[^/]+/([^/]+)/?}
+      @key = unescape($1) if value =~ %r{^/[^/]+/[^/]+/([^/]+)/?}
     end
 
     def inspect; to_s; end

data/lib/riak/locale/en.yml

@@ -18,6 +18,8 @@ en:
     content_type_undefined: "content_type is not defined!"
     empty_map_reduce_query: "Specify one or more query phases to your MapReduce."
     failed_request: "Expected %{expected} from Riak but received %{code}. %{body}"
+    filter_needs_block: "Filter %{filter} expects a block."
+    filter_arity_mismatch: "Filter %{filter} expects %{expected} arguments but %{received} were given."
     hash_type: "invalid argument %{hash} is not a Hash"
     http_configuration: "The %{backend} HTTP backend cannot be used. Please check its requirements."
     hostname_invalid: "host must be a valid hostname"

data/lib/riak/map_reduce.rb

@@ -19,7 +19,12 @@ module Riak
     include Util::Translation
     include Util::Escape
 
-    # @return [Array<[bucket,key]>,String] The bucket/keys for input to the job, or the bucket (all keys).
+    autoload :Phase,         "riak/map_reduce/phase"
+    autoload :FilterBuilder, "riak/map_reduce/filter_builder"
+
+    # @return [Array<[bucket,key]>,String,Hash<:bucket,:filters>] The
+    #       bucket/keys for input to the job, or the bucket (all
+    #       keys), or a hash containing the bucket and key-filters.
     # @see #add
     attr_accessor :inputs
 
@@ -52,9 +57,17 @@ module Riak
     #   @param [String,Bucket] bucket the bucket of the object
     #   @param [String] key the key of the object
     #   @param [String] keydata extra data to pass along with the object to the job
+    # @overload add(bucket, filters)
+    #   Run the job across all keys in the bucket, with the given
+    #   key-filters. This will replace any other inputs previously
+    #   added. (Requires Riak 0.14)
+    #   @param [String,Bucket] bucket the bucket to filter keys from
+    #   @param [Array<Array>] filters a list of key-filters to apply
+    #                                 to the key list
     # @return [MapReduce] self
     def add(*params)
-      params = params.dup.flatten
+      params = params.dup
+      params = params.first if Array === params.first
       case params.size
       when 1
         p = params.first
@@ -69,14 +82,28 @@ module Riak
       when 2..3
         bucket = params.shift
         bucket = bucket.name if Bucket === bucket
-        key = params.shift
-        @inputs << params.unshift(escape(key)).unshift(escape(bucket))
+        if Array === params.first
+          @inputs = {:bucket => escape(bucket), :filters => params.first }
+        else
+          key = params.shift
+          @inputs << params.unshift(escape(key)).unshift(escape(bucket))
+        end
       end
       self
     end
     alias :<< :add
     alias :include :add
 
+    # Adds a bucket and key-filters built by the given
+    # block. Equivalent to #add with a list of filters.
+    # @param [String] bucket the bucket to apply key-filters to
+    # @yield [] builder block - instance_eval'ed into a FilterBuilder
+    # @return [MapReduce] self
+    # @see MapReduce#add
+    def filter(bucket, &block)
+      add(bucket, FilterBuilder.new(&block).to_a)
+    end
+
     # Add a map phase to the job.
     # @overload map(function)
     #   @param [String, Array] function a Javascript function that represents the phase, or an Erlang [module,function] pair
@@ -144,16 +171,13 @@ module Riak
     end
 
     # Executes this map-reduce job.
-    # @return [Array<Array>] similar to link-walking, each element is an array of results from a phase where "keep" is true. If there is only one "keep" phase, only the results from that phase will be returned.
-    def run
+    # @return [Array<Array>] similar to link-walking, each element is
+    #   an array of results from a phase where "keep" is true. If there
+    #   is only one "keep" phase, only the results from that phase will
+    #   be returned.
+    def run(&block)
       raise MapReduceError.new(t("empty_map_reduce_query")) if @query.empty?
-      response = @client.http.post(200, @client.mapred, to_json, {"Content-Type" => "application/json", "Accept" => "application/json"})
-      begin
-        raise unless response[:headers]['content-type'].include?('application/json')
-        JSON.parse(response[:body])
-      rescue
-        response
-      end
+      @client.backend.mapred(self, &block)
     rescue FailedRequest => fr
       if fr.code == 500 && fr.headers['content-type'].include?("application/json")
         raise MapReduceError.new(fr.body)
@@ -161,95 +185,5 @@ module Riak
         raise fr
       end
     end
-
-    # Represents an individual phase in a map-reduce pipeline. Generally you'll want to call
-    # methods of MapReduce instead of using this directly.
-    class Phase
-      include Util::Translation
-      # @return [Symbol] the type of phase - :map, :reduce, or :link
-      attr_accessor :type
-
-      # @return [String, Array<String, String>, Hash, WalkSpec] For :map and :reduce types, the Javascript function to run (as a string or hash with bucket/key), or the module + function in Erlang to run. For a :link type, a {Riak::WalkSpec} or an equivalent hash.
-      attr_accessor :function
-
-      # @return [String] the language of the phase's function - "javascript" or "erlang". Meaningless for :link type phases.
-      attr_accessor :language
-
-      # @return [Boolean] whether results of this phase will be returned
-      attr_accessor :keep
-
-      # @return [Array] any extra static arguments to pass to the phase
-      attr_accessor :arg
-
-      # Creates a phase in the map-reduce pipeline
-      # @param [Hash] options options for the phase
-      # @option options [Symbol] :type one of :map, :reduce, :link
-      # @option options [String] :language ("javascript") "erlang" or "javascript"
-      # @option options [String, Array, Hash] :function In the case of Javascript, a literal function in a string, or a hash with :bucket and :key. In the case of Erlang, an Array of [module, function].  For a :link phase, a hash including any of :bucket, :tag or a WalkSpec.
-      # @option options [Boolean] :keep (false) whether to return the results of this phase
-      # @option options [Array] :arg (nil) any extra static arguments to pass to the phase
-      def initialize(options={})
-        self.type = options[:type]
-        self.language = options[:language] || "javascript"
-        self.function = options[:function]
-        self.keep = options[:keep] || false
-        self.arg = options[:arg]
-      end
-
-      def type=(value)
-        raise ArgumentError, t("invalid_phase_type") unless value.to_s =~ /^(map|reduce|link)$/i
-        @type = value.to_s.downcase.to_sym
-      end
-
-      def function=(value)
-        case value
-        when Array
-          raise ArgumentError, t("module_function_pair_required") unless value.size == 2
-          @language = "erlang"
-        when Hash
-          raise ArgumentError, t("stored_function_invalid") unless type == :link || value.has_key?(:bucket) && value.has_key?(:key)
-          @language = "javascript"
-        when String
-          @language = "javascript"
-        when WalkSpec
-          raise ArgumentError, t("walk_spec_invalid_unless_link") unless type == :link
-        else
-          raise ArgumentError, t("invalid_function_value", :value => value.inspect)
-        end
-        @function = value
-      end
-
-      # Converts the phase to JSON for use while invoking a job.
-      # @return [String] a JSON representation of the phase
-      def to_json(*a)
-        as_json.to_json(*a)
-      end
-
-      # Converts the phase to its JSON-compatible representation for job invocation.
-      # @return [Hash] a Hash-equivalent of the phase
-      def as_json(options=nil)
-        obj = case type
-              when :map, :reduce
-                defaults = {"language" => language, "keep" => keep}
-                case function
-                when Hash
-                  defaults.merge(function)
-                when String
-                  if function =~ /\s*function/
-                    defaults.merge("source" => function)
-                  else
-                    defaults.merge("name" => function)
-                  end
-                when Array
-                  defaults.merge("module" => function[0], "function" => function[1])
-                end
-              when :link
-                spec = WalkSpec.normalize(function).first
-                {"bucket" => spec.bucket, "tag" => spec.tag, "keep" => spec.keep || keep}
-              end
-        obj["arg"] = arg if arg
-        { type => obj }
-      end
-    end
   end
 end

data/lib/riak/map_reduce/filter_builder.rb

@@ -0,0 +1,106 @@
+# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+require 'riak'
+
+module Riak
+  class MapReduce
+    # Builds key-filter lists for MapReduce inputs in a DSL-like fashion.
+    class FilterBuilder
+      include Util::Translation
+
+      # Known filters available in riak_kv_mapred_filters, mapped to
+      # their arities. These are turned into instance methods.
+      # Example:
+      #
+      #    FilterBuilder.new do
+      #      string_to_int
+      #      less_than 50
+      #    end
+      FILTERS = {
+        :int_to_string => 0,
+        :string_to_int => 0,
+        :float_to_string => 0,
+        :string_to_float => 0,
+        :to_upper => 0,
+        :to_lower => 0,
+        :tokenize => 2,
+        :urldecode => 0,
+        :greater_than => 1,
+        :less_than => 1,
+        :greater_than_eq => 1,
+        :less_than_eq => 1,
+        :between => [2,3],
+        :matches => 1,
+        :neq => 1,
+        :eq => 1,
+        :set_member => 1,
+        :similar_to => 2,
+        :starts_with => 1,
+        :ends_with => 1
+      }
+
+      # Available logical operations for joining filter chains. These
+      # are turned into instance methods with leading underscores,
+      # with aliases to uppercase versions.
+      # Example:
+      #
+      #    FilterBuilder.new do
+      #      string_to_int
+      #      AND do
+      #        greater_than_eq 50
+      #        neq 100
+      #      end
+      #    end
+      LOGICAL_OPERATIONS = %w{and or not}
+
+      FILTERS.each do |f,arity|
+        class_eval <<-CODE
+          def #{f}(*args)
+            raise ArgumentError.new(t("filter_arity_mismatch", :filter => :#{f}, :expected => #{arity.inspect}, :received => args.size)) unless Array(#{arity.inspect}).include?(args.size)
+            @filters << ([:#{f}] + args)
+          end
+        CODE
+      end
+
+      LOGICAL_OPERATIONS.each do |op|
+        class_eval <<-CODE
+          def _#{op}(&block)
+            raise ArgumentError.new(t('filter_needs_block', :filter => '#{op}')) unless block_given?
+            @filters << [:#{op}, self.class.new(&block).to_a]
+          end
+          alias :#{op.to_s.upcase} :_#{op}
+        CODE
+      end
+
+      # Creates a new FilterBuilder. Pass a block that will be
+      # instance_eval'ed to construct the sequence of filters.
+      def initialize(&block)
+        @filters = []
+        instance_eval(&block) if block_given?
+      end
+
+      # Wraps multi-step filters for use inside logical
+      # operations. Does not correspond to an actual filter.
+      def sequence(&block)
+        @filters << self.class.new(&block).to_a
+      end
+      alias :seq :sequence
+
+      # @return A list of filters for handing to the MapReduce inputs.
+      def to_a
+        @filters
+      end
+    end
+  end
+end

data/lib/riak/map_reduce/phase.rb

@@ -0,0 +1,108 @@
+# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+require 'riak'
+
+module Riak
+  class MapReduce
+    # Represents an individual phase in a map-reduce pipeline. Generally you'll want to call
+    # methods of MapReduce instead of using this directly.
+    class Phase
+      include Util::Translation
+      # @return [Symbol] the type of phase - :map, :reduce, or :link
+      attr_accessor :type
+
+      # @return [String, Array<String, String>, Hash, WalkSpec] For :map and :reduce types, the Javascript function to run (as a string or hash with bucket/key), or the module + function in Erlang to run. For a :link type, a {Riak::WalkSpec} or an equivalent hash.
+      attr_accessor :function
+
+      # @return [String] the language of the phase's function - "javascript" or "erlang". Meaningless for :link type phases.
+      attr_accessor :language
+
+      # @return [Boolean] whether results of this phase will be returned
+      attr_accessor :keep
+
+      # @return [Array] any extra static arguments to pass to the phase
+      attr_accessor :arg
+
+      # Creates a phase in the map-reduce pipeline
+      # @param [Hash] options options for the phase
+      # @option options [Symbol] :type one of :map, :reduce, :link
+      # @option options [String] :language ("javascript") "erlang" or "javascript"
+      # @option options [String, Array, Hash] :function In the case of Javascript, a literal function in a string, or a hash with :bucket and :key. In the case of Erlang, an Array of [module, function].  For a :link phase, a hash including any of :bucket, :tag or a WalkSpec.
+      # @option options [Boolean] :keep (false) whether to return the results of this phase
+      # @option options [Array] :arg (nil) any extra static arguments to pass to the phase
+      def initialize(options={})
+        self.type = options[:type]
+        self.language = options[:language] || "javascript"
+        self.function = options[:function]
+        self.keep = options[:keep] || false
+        self.arg = options[:arg]
+      end
+
+      def type=(value)
+        raise ArgumentError, t("invalid_phase_type") unless value.to_s =~ /^(map|reduce|link)$/i
+        @type = value.to_s.downcase.to_sym
+      end
+
+      def function=(value)
+        case value
+        when Array
+          raise ArgumentError, t("module_function_pair_required") unless value.size == 2
+          @language = "erlang"
+        when Hash
+          raise ArgumentError, t("stored_function_invalid") unless type == :link || value.has_key?(:bucket) && value.has_key?(:key)
+          @language = "javascript"
+        when String
+          @language = "javascript"
+        when WalkSpec
+          raise ArgumentError, t("walk_spec_invalid_unless_link") unless type == :link
+        else
+          raise ArgumentError, t("invalid_function_value", :value => value.inspect)
+        end
+        @function = value
+      end
+
+      # Converts the phase to JSON for use while invoking a job.
+      # @return [String] a JSON representation of the phase
+      def to_json(*a)
+        as_json.to_json(*a)
+      end
+
+      # Converts the phase to its JSON-compatible representation for job invocation.
+      # @return [Hash] a Hash-equivalent of the phase
+      def as_json(options=nil)
+        obj = case type
+              when :map, :reduce
+                defaults = {"language" => language, "keep" => keep}
+                case function
+                when Hash
+                  defaults.merge(function)
+                when String
+                  if function =~ /\s*function/
+                    defaults.merge("source" => function)
+                  else
+                    defaults.merge("name" => function)
+                  end
+                when Array
+                  defaults.merge("module" => function[0], "function" => function[1])
+                end
+              when :link
+                spec = WalkSpec.normalize(function).first
+                {"bucket" => spec.bucket, "tag" => spec.tag, "keep" => spec.keep || keep}
+              end
+        obj["arg"] = arg if arg
+        { type => obj }
+      end
+    end
+  end
+end

data/lib/riak/robject.rb

@@ -13,14 +13,15 @@
 #    limitations under the License.
 require 'riak'
 require 'set'
+require 'time'
 
 module Riak
   # Represents the data and metadata stored in a bucket/key pair in
-  # the Riak database, the base unit of data manipulation.  
+  # the Riak database, the base unit of data manipulation.
   class RObject
-    include Util
     include Util::Translation
     include Util::Escape
+    extend Util::Escape
 
     # @return [Bucket] the bucket in which this object is contained
     attr_accessor :bucket
@@ -57,7 +58,7 @@ module Riak
     # @return [Array<RObject>] An array of RObject instances
     def self.load_from_mapreduce(client, response)
       response.map do |item|
-        RObject.new(client[CGI.unescape(item['bucket'])], CGI.unescape(item['key'])).load_from_mapreduce(item)
+        RObject.new(client[unescape(item['bucket'])], unescape(item['key'])).load_from_mapreduce(item)
       end
     end
 
@@ -72,27 +73,6 @@ module Riak
       yield self if block_given?
     end
 
-    # Load object data from an HTTP response
-    # @param [Hash] response a response from {Riak::Client::HTTPBackend}
-    def load(response)
-      extract_header(response, "location", :key) {|v| URI.unescape(v.split("/").last) }
-      extract_header(response, "content-type", :content_type)
-      extract_header(response, "x-riak-vclock", :vclock)
-      extract_header(response, "link", :links) {|v| Set.new(Link.parse(v)) }
-      extract_header(response, "etag", :etag)
-      extract_header(response, "last-modified", :last_modified) {|v| Time.httpdate(v) }
-      @meta = response[:headers].inject({}) do |h,(k,v)|
-        if k =~ /x-riak-meta-(.*)/
-          h[$1] = v
-        end
-        h
-      end
-      @conflict = (response[:code].to_i == 300 && content_type =~ /multipart\/mixed/) rescue false
-      @siblings = nil
-      self.raw_data = response[:body] if response[:body].present?
-      self
-    end
-
     # Load object data from a map/reduce response item.
     # This method is used by RObject::load_from_mapreduce to instantiate the necessary
     # objects.
@@ -115,7 +95,7 @@ module Riak
       self
     end
 
-    # @return [Object] the unmarshaled form of {#raw_data} stored in riak at this object's key 
+    # @return [Object] the unmarshaled form of {#raw_data} stored in riak at this object's key
     def data
       if @raw_data && !@data
         @data = deserialize(@raw_data)
@@ -147,37 +127,6 @@ module Riak
       @raw_data = new_raw_data
     end
 
-    # HTTP header hash that will be sent along when storing the object
-    # @return [Hash] hash of HTTP Headers
-    def store_headers
-      {}.tap do |hash|
-        hash["Content-Type"] = @content_type
-        hash["X-Riak-Vclock"] = @vclock if @vclock
-        if @prevent_stale_writes && @etag.present?
-          hash["If-Match"] = @etag
-        elsif @prevent_stale_writes
-          hash["If-None-Match"] = "*"
-        end
-        unless @links.blank?
-          hash["Link"] = @links.reject {|l| l.rel == "up" }.map(&:to_s).join(", ")
-        end
-        unless @meta.blank?
-          @meta.each do |k,v|
-            hash["X-Riak-Meta-#{k}"] = v.to_s
-          end
-        end
-      end
-    end
-
-    # HTTP header hash that will be sent along when reloading the object
-    # @return [Hash] hash of HTTP headers
-    def reload_headers
-      {}.tap do |h|
-        h['If-None-Match'] = @etag if @etag.present?
-        h['If-Modified-Since'] = @last_modified.httpdate if @last_modified.present?
-      end
-    end
-
     # Store the object in Riak
     # @param [Hash] options query parameters
     # @option options [Fixnum] :r the "r" parameter (Read quorum for the implicit read performed when validating the store operation)
@@ -189,23 +138,22 @@ module Riak
     def store(options={})
       raise ArgumentError, t("content_type_undefined") unless @content_type.present?
       params = {:returnbody => true}.merge(options)
-      method, codes, path = @key.present? ? [:put, [200,204,300], "#{escape(@bucket.name)}/#{escape(@key)}"] : [:post, 201, escape(@bucket.name)]
-      response = @bucket.client.http.send(method, codes, @bucket.client.prefix, path, params, raw_data, store_headers)
-      load(response)
+      @bucket.client.backend.store_object(self, params[:returnbody], params[:w], params[:dw])
+      self
     end
 
     # Reload the object from Riak.  Will use conditional GETs when possible.
     # @param [Hash] options query parameters
     # @option options [Fixnum] :r the "r" parameter (Read quorum)
-    # @option options [Boolean] :force will force a reload request if the vclock is not present, useful for reloading the object after a store (not passed in the query params)
+    # @option options [Boolean] :force will force a reload request if
+    #     the vclock is not present, useful for reloading the object after
+    #     a store (not passed in the query params)
     # @return [Riak::RObject] self
     def reload(options={})
       force = options.delete(:force)
       return self unless @key && (@vclock || force)
-      codes = @bucket.allow_mult ? [200,300,304] : [200,304]
-      response = @bucket.client.http.get(codes, @bucket.client.prefix, escape(@bucket.name), escape(@key), options, reload_headers)
-      load(response) unless response[:code] == 304
-      self
+      self.etag = self.last_modified = nil if force
+      bucket.client.backend.reload_object(self, options[:r])
     end
 
     alias :fetch :reload
@@ -218,17 +166,14 @@ module Riak
       freeze
     end
 
+    attr_writer :siblings, :conflict
+
     # Returns sibling objects when in conflict.
     # @return [Array<RObject>] an array of conflicting sibling objects for this key
     # @return [self] this object when not in conflict
     def siblings
       return self unless conflict?
-      @siblings ||= Multipart.parse(data, Multipart.extract_boundary(content_type)).map do |part|
-        RObject.new(self.bucket, self.key) do |sibling|
-          sibling.load(part)
-          sibling.vclock = vclock
-        end
-      end
+      @siblings
     end
 
     # @return [true,false] Whether this object has conflicting sibling objects (divergent vclocks)
@@ -286,21 +231,14 @@ module Riak
              else
                @raw_data && "(#{@raw_data.size} bytes)"
              end
-      "#<#{self.class.name} #{url} [#{@content_type}]:#{body}>"
+      "#<#{self.class.name} {#{bucket.name}#{"," + @key if @key}} [#{@content_type}]:#{body}>"
     end
 
     # Walks links from this object to other objects in Riak.
     # @param [Array<Hash,WalkSpec>] link specifications for the query
     def walk(*params)
       specs = WalkSpec.normalize(*params)
-      response = @bucket.client.http.get(200, @bucket.client.prefix, escape(@bucket.name), escape(@key), specs.join("/"))
-      if boundary = Multipart.extract_boundary(response[:headers]['content-type'].first)
-        Multipart.parse(response[:body], boundary).map do |group|
-          map_walk_group(group)
-        end
-      else
-        []
-      end
+      @bucket.client.http.link_walk(self, specs)
     end
 
     # Converts the object to a link suitable for linking other objects
@@ -322,14 +260,14 @@ module Riak
     alias :vector_clock :vclock
     alias :vector_clock= :vclock=
 
-    protected
+      protected
     def load_map_reduce_value(hash)
       metadata = hash['metadata']
       extract_if_present(metadata, 'X-Riak-VTag', :etag)
       extract_if_present(metadata, 'content-type', :content_type)
       extract_if_present(metadata, 'X-Riak-Last-Modified', :last_modified) { |v| Time.httpdate( v ) }
       extract_if_present(metadata, 'Links', :links) do |links|
-        Set.new( links.map { |l| Link.new("#{@bucket.client.prefix}#{l[0]}/#{l[1]}", l[2]) } )
+        Set.new( links.map { |l| Link.new(*l) } )
       end
       extract_if_present(metadata, 'X-Riak-Meta', :meta) do |meta|
         Hash[
@@ -349,20 +287,5 @@ module Riak
         send("#{attribute}=", value)
       end
     end
-
-    def extract_header(response, name, attribute=nil, &block)
-      extract_if_present(response[:headers], name, attribute) do |value|
-        block ? block.call(value[0]) : value[0]
-      end
-    end
-
-    def map_walk_group(group)
-      group.map do |obj|
-        if obj[:headers] && obj[:body] && obj[:headers]['location']
-          bucket, key = $1, $2 if obj[:headers]['location'].first =~ %r{/.*/(.*)/(.*)$}
-          RObject.new(@bucket.client.bucket(bucket, :keys => false), key).load(obj)
-        end
-      end
-    end
   end
 end