jmoses-couchbase 1.3.6

data/lib/couchbase/cluster.rb

@@ -0,0 +1,119 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2011, 2012 Couchbase, Inc.
+# License:: Apache License, Version 2.0
+#
+# 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.
+#
+
+module Couchbase
+
+  class Cluster
+
+    # Establish connection to the cluster for administration
+    #
+    # @param [Hash] options The connection parameter
+    # @option options [String] :username The username
+    # @option options [String] :password The password
+    # @option options [String] :pool ("default") The pool name
+    # @option options [String] :hostname ("localhost") The hostname
+    # @option options [String] :port (8091) The port
+    def initialize(options = {})
+      if options[:username].nil? || options[:password].nil?
+        raise ArgumentError, "username and password mandatory to connect to the cluster"
+      end
+      @connection = Bucket.new(options.merge(:type => :cluster))
+    end
+
+    # Create data bucket
+    #
+    # @param [String] name The name of the bucket
+    # @param [Hash] options The bucket parameters
+    # @option options [String] :bucket_type ("couchbase") The type of the
+    #   bucket. Possible values are "memcached" and "couchbase".
+    # @option options [Fixnum] :ram_quota (100) The RAM quota in megabytes.
+    # @option options [Fixnum] :replica_number (1) The number of replicas of
+    #   each document. Minimum 0, maximum 3.
+    # @option options [String] :auth_type ("sasl") The authentication type.
+    #   Possible values are "sasl" and "none". Note you should specify free
+    #   port for "none"
+    # @option options [Fixnum] :proxy_port The port for moxi
+    # @option options [true, false] :replica_index (true) Disable or
+    #   enable indexes for bucket replicas
+    # @option options [true, false] :flush_enabled (false) Enables the
+    #   'flush all' functionality on the specified bucket.
+    # @option options [true, false] :parallel_db_and_view_compaction (false)
+    #   Indicates whether database and view files on disk can be
+    #   compacted simultaneously
+    #
+    def create_bucket(name, options = {})
+      defaults = {
+        :type => "couchbase",
+        :ram_quota => 100,
+        :replica_number => 1,
+        :auth_type => "sasl",
+        :sasl_password => "",
+        :proxy_port => nil,
+        :flush_enabled => false,
+        :replica_index => true,
+        :parallel_db_and_view_compaction => false
+      }
+      options = defaults.merge(options)
+      params = {"name" => name}
+      params["bucketType"] = options[:type]
+      params["ramQuotaMB"] = options[:ram_quota]
+      params["replicaNumber"] = options[:replica_number]
+      params["authType"] = options[:auth_type]
+      params["saslPassword"] = options[:sasl_password]
+      params["proxyPort"] = options[:proxy_port]
+      params["flushEnabled"] = !!options[:flush_enabled]
+      params["replicaIndex"] = !!options[:replica_index]
+      params["parallelDBAndViewCompaction"] = !!options[:parallel_db_and_view_compaction]
+      payload = Utils.encode_params(params.reject!{|k, v| v.nil?})
+      request = @connection.make_http_request("/pools/default/buckets",
+                                              :content_type => "application/x-www-form-urlencoded",
+                                              :type => :management,
+                                              :method => :post,
+                                              :extended => true,
+                                              :body => payload)
+      response = nil
+      request.on_body do |r|
+        response = r
+        response.instance_variable_set("@operation", :create_bucket)
+        yield(response) if block_given?
+      end
+      request.continue
+      response
+    end
+
+    # Delete the data bucket
+    #
+    # @param [String] name The name of the bucket
+    # @param [Hash] options
+    def delete_bucket(name, options = {})
+      request = @connection.make_http_request("/pools/default/buckets/#{name}",
+                                              :type => :management,
+                                              :method => :delete,
+                                              :extended => true)
+      response = nil
+      request.on_body do |r|
+        response = r
+        response.instance_variable_set("@operation", :delete_bucket)
+        yield(response) if block_given?
+      end
+      request.continue
+      response
+    end
+
+  end
+
+end

data/lib/couchbase/connection_pool.rb

@@ -0,0 +1,58 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2013 Couchbase, Inc.
+# License:: Apache License, Version 2.0
+#
+# 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.
+#
+
+if RUBY_VERSION.to_f < 1.9
+  raise LoadError, "connection_pool gem doesn't support ruby < 1.9"
+end
+require 'connection_pool'
+
+module Couchbase
+  class ConnectionPool
+
+    def initialize(pool_size = 5, *args)
+      @pool = ::ConnectionPool.new(:size => pool_size) { ::Couchbase::Bucket.new(*args) }
+    end
+
+    def with
+      yield @pool.checkout
+    ensure
+      @pool.checkin
+    end
+
+    def respond_to?(id, *args)
+      super || @pool.with { |c| c.respond_to?(id, *args) }
+    end
+
+    def method_missing(name, *args, &block)
+      define_proxy_method(name)
+      send(name, *args, &block)
+    end
+
+    protected
+
+    def define_proxy_method(name)
+      self.class.class_eval <<-RUBY
+        def #{name}(*args, &block)
+          @pool.with do |connection|
+            connection.send(#{name.inspect}, *args, &block)
+          end
+        end
+      RUBY
+    end
+
+  end
+end

data/lib/couchbase/constants.rb

@@ -0,0 +1,12 @@
+module Couchbase
+  module Constants # :nodoc:
+    S_ID = 'id'.freeze
+    S_DOC = 'doc'.freeze
+    S_VALUE = 'value'.freeze
+    S_META = 'meta'.freeze
+    S_FLAGS = 'flags'.freeze
+    S_CAS = 'cas'.freeze
+    S_KEY = 'key'.freeze
+    S_IS_LAST = Object.new.freeze
+  end
+end

data/lib/couchbase/result.rb

@@ -0,0 +1,26 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2011, 2012 Couchbase, Inc.
+# License:: Apache License, Version 2.0
+#
+# 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.
+#
+
+module Couchbase
+  class Result
+    def initialize(attrs = {})
+      attrs.each do |k, v|
+        instance_variable_set("@#{k}", v) if respond_to?(k)
+      end
+    end
+  end
+end

data/lib/couchbase/transcoder.rb

@@ -0,0 +1,120 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2013 Couchbase, Inc.
+# License:: Apache License, Version 2.0
+#
+# 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 'multi_json'
+require 'ext/multi_json_fix'
+
+module Couchbase
+
+  module Transcoder
+
+    module Compat
+      def self.enable!
+        @disabled = false
+      end
+
+      def self.disable!
+        @disabled = true
+      end
+
+      def self.enabled?
+        !@disabled
+      end
+
+      def self.guess_and_load(blob, flags, options = {})
+        case flags & Bucket::FMT_MASK
+        when Bucket::FMT_DOCUMENT
+          MultiJson.load(blob)
+        when Bucket::FMT_MARSHAL
+          ::Marshal.load(blob)
+        when Bucket::FMT_PLAIN
+          blob
+        else
+          raise ArgumentError, "unexpected flags (0x%02x)" % flags
+        end
+      end
+    end
+
+    module Document
+      def self.dump(obj, flags, options = {})
+        [
+          MultiJson.dump(obj),
+          (flags & ~Bucket::FMT_MASK) | Bucket::FMT_DOCUMENT
+        ]
+      end
+
+      def self.load(blob, flags, options = {})
+        if (flags & Bucket::FMT_MASK) == Bucket::FMT_DOCUMENT || options[:forced]
+          MultiJson.load(blob)
+        else
+          if Compat.enabled?
+            return Compat.guess_and_load(blob, flags, options)
+          else
+            raise ArgumentError,
+              "unexpected flags (0x%02x instead of 0x%02x)" % [flags, Bucket::FMT_DOCUMENT]
+          end
+        end
+      end
+    end
+
+    module Marshal
+      def self.dump(obj, flags, options = {})
+        [
+          ::Marshal.dump(obj),
+          (flags & ~Bucket::FMT_MASK) | Bucket::FMT_MARSHAL
+        ]
+      end
+
+      def self.load(blob, flags, options = {})
+        if (flags & Bucket::FMT_MASK) == Bucket::FMT_MARSHAL || options[:forced]
+          ::Marshal.load(blob)
+        else
+          if Compat.enabled?
+            return Compat.guess_and_load(blob, flags, options)
+          else
+            raise ArgumentError,
+              "unexpected flags (0x%02x instead of 0x%02x)" % [flags, Bucket::FMT_MARSHAL]
+          end
+        end
+      end
+    end
+
+    module Plain
+      def self.dump(obj, flags, options = {})
+        [
+          obj,
+          (flags & ~Bucket::FMT_MASK) | Bucket::FMT_PLAIN
+        ]
+      end
+
+      def self.load(blob, flags, options = {})
+        if (flags & Bucket::FMT_MASK) == Bucket::FMT_PLAIN || options[:forced]
+          blob
+        else
+          if Compat.enabled?
+            return Compat.guess_and_load(blob, flags, options)
+          else
+            raise ArgumentError,
+              "unexpected flags (0x%02x instead of 0x%02x)" % [flags, Bucket::FMT_PLAIN]
+          end
+        end
+      end
+    end
+
+  end
+
+end

data/lib/couchbase/utils.rb

@@ -0,0 +1,62 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2011-2012 Couchbase, Inc.
+# License:: Apache License, Version 2.0
+#
+# 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.
+#
+
+module Couchbase
+
+  class Utils
+
+    def self.encode_params(params)
+      params.map do |k, v|
+        next if !v && k.to_s == "group"
+        if %w{key keys startkey endkey start_key end_key}.include?(k.to_s)
+          v = MultiJson.dump(v)
+        end
+        if v.class == Array
+          build_query(v.map { |x| [k, x] })
+        else
+          "#{escape(k)}=#{escape(v)}"
+        end
+      end.compact.join("&")
+    end
+
+    def self.build_query(uri, params = nil)
+      uri = uri.dup
+      return uri if params.nil? || params.empty?
+      uri << "?" << encode_params(params)
+    end
+
+    def self.escape(s)
+      s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/nu) {
+        '%'+$1.unpack('H2'*bytesize($1)).join('%').upcase
+      }.tr(' ', '+')
+    end
+
+    # Return the bytesize of String; uses String#size under Ruby 1.8 and
+    # String#bytesize under 1.9.
+    if ''.respond_to?(:bytesize)
+      def self.bytesize(string)
+        string.bytesize
+      end
+    else
+      def self.bytesize(string)
+        string.size
+      end
+    end
+
+  end
+
+end

data/lib/couchbase/version.rb

@@ -0,0 +1,21 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2011, 2012 Couchbase, Inc.
+# License:: Apache License, Version 2.0
+#
+# 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.
+#
+
+# Couchbase ruby client
+module Couchbase
+  VERSION = "1.3.6"
+end

data/lib/couchbase/view.rb

@@ -0,0 +1,506 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2011 Couchbase, Inc.
+# License:: Apache License, Version 2.0
+#
+# 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 'base64'
+
+module Couchbase
+
+  module Error
+    class View < Base
+      attr_reader :from, :reason
+
+      def initialize(from, reason, prefix = "SERVER: ")
+        @from = from
+        @reason = reason
+        super("#{prefix}#{from}: #{reason}")
+      end
+    end
+
+    class HTTP < Base
+      attr_reader :type, :reason
+
+      def parse_body!
+        if @body
+          hash = MultiJson.load(@body)
+          if hash["errors"]
+            @type = :invalid_arguments
+            @reason = hash["errors"].values.join(" ")
+          else
+            @type = hash["error"]
+            @reason = hash["reason"]
+          end
+        end
+      rescue MultiJson::DecodeError
+        @type = @reason = nil
+      end
+
+      def to_s
+        str = super
+        if @type || @reason
+          str.sub(/ \(/, ": #{[@type, @reason].compact.join(": ")} (")
+        else
+          str
+        end
+      end
+    end
+  end
+
+  # This class implements Couchbase View execution
+  #
+  # @see http://www.couchbase.com/docs/couchbase-manual-2.0/couchbase-views.html
+  class View
+    include Enumerable
+    include Constants
+
+    class ArrayWithTotalRows < Array # :nodoc:
+      attr_accessor :total_rows
+      alias total_entries total_rows
+    end
+
+    class AsyncHelper # :nodoc:
+      include Constants
+      EMPTY = []
+
+      def initialize(wrapper_class, bucket, include_docs, quiet, block)
+        @wrapper_class = wrapper_class
+        @bucket = bucket
+        @block = block
+        @quiet = quiet
+        @include_docs = include_docs
+        @queue = []
+        @first = @shift = 0
+        @completed = false
+      end
+
+      # Register object in the emitter.
+      def push(obj)
+        if @include_docs
+          @queue << obj
+          @bucket.get(obj[S_ID], :extended => true, :quiet => @quiet) do |res|
+            obj[S_DOC] = {
+              S_VALUE => res.value,
+              S_META => {
+                S_ID => obj[S_ID],
+                S_FLAGS => res.flags,
+                S_CAS => res.cas
+              }
+            }
+            check_for_ready_documents
+          end
+        else
+          old_obj = @queue.shift
+          @queue << obj
+          block_call(old_obj) if old_obj
+        end
+      end
+
+      def complete!
+        if @include_docs
+          @completed = true
+          check_for_ready_documents
+        elsif !@queue.empty?
+          obj = @queue.shift
+          obj[S_IS_LAST] = true
+          block_call obj
+        end
+      end
+
+      private
+
+      def block_call(obj)
+        @block.call @wrapper_class.wrap(@bucket, obj)
+      end
+
+      def check_for_ready_documents
+        shift = @shift
+        queue = @queue
+        save_last = @completed ? 0 : 1
+        while @first < queue.size + shift - save_last
+          obj = queue[@first - shift]
+          break unless obj[S_DOC]
+          queue[@first - shift] = nil
+          @first += 1
+          if @completed && @first == queue.size + shift
+            obj[S_IS_LAST] = true
+          end
+          block_call obj
+        end
+        if @first - shift > queue.size / 2
+          queue[0, @first - shift] = EMPTY
+          @shift = @first
+        end
+      end
+
+    end
+
+    attr_reader :params
+
+    # Set up view endpoint and optional params
+    #
+    # @param [Couchbase::Bucket] bucket Connection object which
+    #   stores all info about how to make requests to Couchbase views.
+    #
+    # @param [String] endpoint Full Couchbase View URI.
+    #
+    # @param [Hash] params Optional parameter which will be passed to
+    #   {View#fetch}
+    #
+    def initialize(bucket, endpoint, params = {})
+      @bucket = bucket
+      @endpoint = endpoint
+      @params = {:connection_timeout => 75_000}.merge(params)
+      @wrapper_class = params.delete(:wrapper_class) || ViewRow
+      unless @wrapper_class.respond_to?(:wrap)
+        raise ArgumentError, "wrapper class should reposond to :wrap, check the options"
+      end
+    end
+
+    # Yields each document that was fetched by view. It doesn't instantiate
+    # all the results because of streaming JSON parser. Returns Enumerator
+    # unless block given.
+    #
+    # @param [Hash] params Params for Couchdb query. Some useful are:
+    #   :start_key, :start_key_doc_id, :descending. See {View#fetch}.
+    #
+    # @example Use each method with block
+    #
+    #   view.each do |doc|
+    #     # do something with doc
+    #   end
+    #
+    # @example Use Enumerator version
+    #
+    #   enum = view.each  # request hasn't issued yet
+    #   enum.map{|doc| doc.title.upcase}
+    #
+    # @example Pass options during view initialization
+    #
+    #   endpoint = "http://localhost:5984/default/_design/blog/_view/recent"
+    #   view = View.new(conn, endpoint, :descending => true)
+    #   view.each do |document|
+    #     # do something with document
+    #   end
+    #
+    def each(params = {})
+      return enum_for(:each, params) unless block_given?
+      fetch(params) {|doc| yield(doc)}
+    end
+
+    def first(params = {})
+      params = params.merge(:limit => 1)
+      fetch(params).first
+    end
+
+    def take(n, params = {})
+      params = params.merge(:limit => n)
+      fetch(params)
+    end
+
+    # Registers callback function for handling error objects in view
+    # results stream.
+    #
+    # @yieldparam [String] from Location of the node where error occured
+    # @yieldparam [String] reason The reason message describing what
+    #   happened.
+    #
+    # @example Using +#on_error+ to log all errors in view result
+    #
+    #     # JSON-encoded view result
+    #     #
+    #     # {
+    #     #   "total_rows": 0,
+    #     #   "rows": [ ],
+    #     #   "errors": [
+    #     #     {
+    #     #       "from": "127.0.0.1:5984",
+    #     #       "reason": "Design document `_design/testfoobar` missing in database `test_db_b`."
+    #     #     },
+    #     #     {
+    #     #       "from": "http:// localhost:5984/_view_merge/",
+    #     #       "reason": "Design document `_design/testfoobar` missing in database `test_db_c`."
+    #     #     }
+    #     #   ]
+    #     # }
+    #
+    #     view.on_error do |from, reason|
+    #       logger.warn("#{view.inspect} received the error '#{reason}' from #{from}")
+    #     end
+    #     docs = view.fetch
+    #
+    # @example More concise example to just count errors
+    #
+    #     errcount = 0
+    #     view.on_error{|f,r| errcount += 1}.fetch
+    #
+    def on_error(&callback)
+      @on_error = callback
+      self  # enable call chains
+    end
+
+    # Performs query to Couchbase view. This method will stream results if block
+    # given or return complete result set otherwise. In latter case it defines
+    # method +total_rows+ returning corresponding entry from
+    # Couchbase result object.
+    #
+    # @note Avoid using +$+ symbol as prefix for properties in your
+    #   documents, because server marks with it meta fields like flags and
+    #   expiration, therefore dollar prefix is some kind of reserved. It
+    #   won't hurt your application. Currently the {ViewRow}
+    #   class extracts +$flags+, +$cas+ and +$expiration+ properties from
+    #   the document and store them in {ViewRow#meta} hash.
+    #
+    # @param [Hash] params parameters for Couchbase query.
+    # @option params [true, false] :include_docs (false) Include the
+    #   full content of the documents in the return. Note that the document
+    #   is fetched from the in memory cache where it may have been changed
+    #   or even deleted. See also +:quiet+ parameter below to control error
+    #   reporting during fetch.
+    # @option params [true, false] :quiet (true) Do not raise error if
+    #   associated document not found in the memory. If the parameter +true+
+    #   will use +nil+ value instead.
+    # @option params [true, false] :descending (false) Return the documents
+    #   in descending by key order
+    # @option params [String, Fixnum, Hash, Array] :key Return only
+    #   documents that match the specified key. Will be JSON encoded.
+    # @option params [Array] :keys The same as +:key+, but will work for
+    #   set of keys. Will be JSON encoded.
+    # @option params [String, Fixnum, Hash, Array] :startkey Return
+    #   records starting with the specified key. +:start_key+ option should
+    #   also work here. Will be JSON encoded.
+    # @option params [String] :startkey_docid Document id to start with
+    #   (to allow pagination for duplicate startkeys). +:start_key_doc_id+
+    #   also should work.
+    # @option params [String, Fixnum, Hash, Array] :endkey Stop returning
+    #   records when the specified key is reached. +:end_key+ option should
+    #   also work here. Will be JSON encoded.
+    # @option params [String] :endkey_docid Last document id to include
+    #   in the output (to allow pagination for duplicate startkeys).
+    #   +:end_key_doc_id+ also should work.
+    # @option params [true, false] :inclusive_end (true) Specifies whether
+    #   the specified end key should be included in the result
+    # @option params [Fixnum] :limit Limit the number of documents in the
+    #   output.
+    # @option params [Fixnum] :skip Skip this number of records before
+    #   starting to return the results.
+    # @option params [String, Symbol] :on_error (:continue) Sets the
+    #   response in the event of an error. Supported values:
+    #   :continue:: Continue to generate view information in the event of an
+    #               error, including the error information in the view
+    #               response stream.
+    #   :stop::     Stop immediately when an error condition occurs. No
+    #               further view information will be returned.
+    # @option params [Fixnum] :connection_timeout (75000) Timeout before the
+    #   view request is dropped (milliseconds)
+    # @option params [true, false] :reduce (true) Use the reduction function
+    # @option params [true, false] :group (false) Group the results using
+    #   the reduce function to a group or single row.
+    # @option params [Fixnum] :group_level Specify the group level to be
+    #   used.
+    # @option params [String, Symbol, false] :stale (:update_after) Allow
+    #   the results from a stale view to be used. Supported values:
+    #   false::         Force a view update before returning data
+    #   :ok::           Allow stale views
+    #   :update_after:: Allow stale view, update view after it has been
+    #                   accessed
+    # @option params [Hash] :body Accepts the same parameters, except
+    #   +:body+ of course, but sends them in POST body instead of query
+    #   string. It could be useful for really large and complex parameters.
+    #
+    # @yieldparam [Couchbase::ViewRow] document
+    #
+    # @return [Array] with documents. There will be +total_entries+
+    #   method defined on this array if it's possible.
+    #
+    # @raise [Couchbase::Error::View] when +on_error+ callback is nil and
+    #   error object found in the result stream.
+    #
+    # @example Query +recent_posts+ view with key filter
+    #   doc.recent_posts(:body => {:keys => ["key1", "key2"]})
+    #
+    # @example Fetch second page of result set (splitted in 10 items per page)
+    #   page = 2
+    #   per_page = 10
+    #   doc.recent_posts(:skip => (page - 1) * per_page, :limit => per_page)
+    #
+    # @example Simple join using Map/Reduce
+    #   # Given the bucket with Posts(:id, :type, :title, :body) and
+    #   # Comments(:id, :type, :post_id, :author, :body). The map function
+    #   # below (in javascript) will build the View index called
+    #   # "recent_posts_with_comments" which will behave like left inner join.
+    #   #
+    #   #   function(doc) {
+    #   #     switch (doc.type) {
+    #   #       case "Post":
+    #   #         emit([doc.id, 0], null);
+    #   #         break;
+    #   #       case "Comment":
+    #   #         emit([doc.post_id, 1], null);
+    #   #         break;
+    #   #     }
+    #   #   }
+    #   #
+    #   post_id = 42
+    #   doc.recent_posts_with_comments(:start_key => [post_id, 0],
+    #                                  :end_key => [post_id, 1],
+    #                                  :include_docs => true)
+    def fetch(params = {}, &block)
+      params = @params.merge(params)
+      include_docs = params.delete(:include_docs)
+      quiet = params.delete(:quiet){ true }
+
+      options = {:chunked => true, :extended => true, :type => :view}
+      if body = params.delete(:body)
+        body = MultiJson.dump(body) unless body.is_a?(String)
+        options.update(:body => body, :method => params.delete(:method) || :post)
+      end
+      path = Utils.build_query(@endpoint, params)
+      request = @bucket.make_http_request(path, options)
+
+      if @bucket.async?
+        if block
+          fetch_async(request, include_docs, quiet, block)
+        end
+      else
+        fetch_sync(request, include_docs, quiet, block)
+      end
+    end
+
+    # Method for fetching asynchronously all rows and passing array to callback
+    #
+    # Parameters are same as for {View#fetch} method, but callback is called for whole set for
+    # rows instead of one by each.
+    #
+    # @example
+    #   con.run do
+    #     doc.recent_posts.fetch_all do |posts|
+    #       do_something_with_all_posts(posts)
+    #     end
+    #   end
+    def fetch_all(params = {}, &block)
+      return fetch(params) unless @bucket.async?
+      raise ArgumentError, "Block needed for fetch_all in async mode" unless block
+
+      all = []
+      fetch(params) do |row|
+        all << row
+        if row.last?
+          @bucket.create_timer(0) { block.call(all) }
+        end
+      end
+    end
+
+
+    # Returns a string containing a human-readable representation of the {View}
+    #
+    # @return [String]
+    def inspect
+      %(#<#{self.class.name}:#{self.object_id} @endpoint=#{@endpoint.inspect} @params=#{@params.inspect}>)
+    end
+
+    private
+
+    def send_error(*args)
+      if @on_error
+        @on_error.call(*args.take(2))
+      else
+        raise Error::View.new(*args)
+      end
+    end
+
+    def fetch_async(request, include_docs, quiet, block)
+      filter = ["/rows/", "/errors/"]
+      parser = YAJI::Parser.new(:filter => filter, :with_path => true)
+      helper = AsyncHelper.new(@wrapper_class, @bucket, include_docs, quiet, block)
+
+      request.on_body do |chunk|
+        if chunk.success?
+          parser << chunk.value if chunk.value
+          helper.complete! if chunk.completed?
+        else
+          send_error("http_error", chunk.error)
+        end
+      end
+
+      parser.on_object do |path, obj|
+        case path
+        when "/errors/"
+          from, reason = obj["from"], obj["reason"]
+          send_error(from, reason)
+        else
+          helper.push(obj)
+        end
+      end
+
+      request.perform
+      nil
+    end
+
+    def fetch_sync(request, include_docs, quiet, block)
+      res = []
+      filter = ["/rows/", "/errors/"]
+      unless block
+        filter << "/total_rows"
+        docs = ArrayWithTotalRows.new
+      end
+      parser = YAJI::Parser.new(:filter => filter, :with_path => true)
+      last_chunk = nil
+
+      request.on_body do |chunk|
+        last_chunk = chunk
+        res << chunk.value  if chunk.success?
+      end
+
+      parser.on_object do |path, obj|
+        case path
+        when "/total_rows"
+          # if total_rows key present, save it and take next object
+          docs.total_rows = obj
+        when "/errors/"
+          from, reason = obj["from"], obj["reason"]
+          send_error(from, reason)
+        else
+          if include_docs
+            val, flags, cas = @bucket.get(obj[S_ID], :extended => true, :quiet => quiet)
+            obj[S_DOC] = {
+              S_VALUE => val,
+              S_META => {
+                S_ID => obj[S_ID],
+                S_FLAGS => flags,
+                S_CAS => cas
+              }
+            }
+          end
+          doc = @wrapper_class.wrap(@bucket, obj)
+          block ? block.call(doc) : docs << doc
+        end
+      end
+
+      request.continue
+
+      if last_chunk.success?
+        while value = res.shift
+          parser << value
+        end
+      else
+        send_error("http_error", last_chunk.error, nil)
+      end
+
+      # return nil for call with block
+      docs
+    end
+  end
+end