rufus-jig 0.1.23 → 1.0.0

data/lib/rufus/jig/couch.rb

@@ -22,6 +22,8 @@
 # Made in Japan.
 #++
 
+require 'cgi'
+
 require 'base64'
 require 'socket'
   # for #on_change
@@ -38,7 +40,7 @@ module Rufus::Jig
     attr_reader :path
     attr_reader :http
 
-    def initialize (*args)
+    def initialize(*args)
 
       @http = Rufus::Jig::Http.new(*args)
 
@@ -55,7 +57,7 @@ module Rufus::Jig
       @http.close
     end
 
-    def put (doc_or_path, opts={})
+    def put(doc_or_path, opts={})
 
       path, payload = if doc_or_path.is_a?(String)
         [ doc_or_path, '' ]
@@ -84,19 +86,71 @@ module Rufus::Jig
       nil
     end
 
-    def get (doc_or_path, opts={})
+    def get(doc_or_path, opts={})
 
       path = doc_or_path.is_a?(Hash) ? doc_or_path['_id'] : doc_or_path
       path = adjust(path)
 
-      if et = etag(path)
-        opts[:etag] = et
+      @http.get(path, opts)
+    end
+
+    # Returns all the docs in the current database.
+    #
+    #   c = Rufus::Jig::Couch.new('http://127.0.0.1:5984, 'my_db')
+    #
+    #   docs = c.all
+    #   docs = c.all(:include_docs => false)
+    #   docs = c.all(:include_design_docs => false)
+    #
+    #   docs = c.all(:skip => 10, :limit => 10)
+    #
+    # It understands (passes) all the options for CouchDB view API :
+    #
+    #   http://wiki.apache.org/couchdb/HTTP_view_API#Querying_Options
+    #
+    def all(opts={})
+
+      opts = opts.dup
+        # don't touch the original
+
+      path = adjust('_all_docs')
+
+      opts[:include_docs] = true if opts[:include_docs].nil?
+
+      adjust_params(opts)
+
+      keys = opts.delete(:keys)
+
+      return [] if keys && keys.empty?
+
+      res = if keys
+        opts[:cache] = :with_body if opts[:cache].nil?
+        @http.post(path, { 'keys' => keys }, opts)
+      else
+        @http.get(path, opts)
       end
 
-      @http.get(path, opts)
+      rows = res['rows']
+
+      docs = if opts[:params][:include_docs]
+        rows.map { |row| row['doc'] }
+      else
+        rows.map { |row| { '_id' => row['id'], '_rev' => row['value']['rev'] } }
+      end
+
+      if opts[:include_design_docs] == false
+        docs = docs.reject { |doc| DESIGN_PATH_REGEX.match(doc['_id']) }
+      end
+
+      docs
+    end
+
+    def ids(opts={})
+
+      all(opts).collect { |row| row['_id'] }
     end
 
-    def delete (doc_or_path, rev=nil)
+    def delete(doc_or_path, rev=nil)
 
       doc, path = if rev
         [ { '_id' => doc_or_path, '_rev' => rev }, doc_or_path ]
@@ -135,17 +189,9 @@ module Rufus::Jig
       end
     end
 
-    def post (path, doc)
-
-      path = adjust(path)
-
-      opts = { :content_type => :json }
-
-      if et = etag(path)
-        opts[:etag] = et
-      end
+    def post(path, doc, opts={})
 
-      @http.post(path, doc, opts)
+      @http.post(adjust(path), doc, opts.merge(:content_type => :json))
     end
 
     # Attaches a file to a couch document.
@@ -160,7 +206,7 @@ module Rufus::Jig
     #     doc, 'my_picture', data,
     #     :content_type => 'image/jpeg')
     #
-    def attach (doc_id, doc_rev, attachment_name, data, opts=nil)
+    def attach(doc_id, doc_rev, attachment_name, data, opts=nil)
 
       if opts.nil?
         opts = data
@@ -183,23 +229,27 @@ module Rufus::Jig
       path = adjust("#{doc_id}/#{attachment_name}?rev=#{doc_rev}")
 
       if @http.variant == :patron
-        #
-        # patron, as of 0.4.5 has difficulties when PUTting attachements
+
+        # patron, as of 0.4.5 (~> 0.4.10), has difficulties when PUTting
+        # attachements
         # this is a fallback to net/http
-        #
+
         require 'net/http'
+
         http = Net::HTTP.new(@http.host, @http.port)
+
         req = Net::HTTP::Put.new(path)
         req['User-Agent'] =
-          "rufus-jig #{Rufus::Jig::VERSION} (patron 0.4.5 fallback to net/http)"
+          "rufus-jig #{Rufus::Jig::VERSION} (patron 0.4.x fallback to net/http)"
         req['Content-Type'] =
           opts[:content_type]
+        req['Accept'] =
+          'application/json'
         req.body = data
-        res = http.start { |h| h.request(req) }
-        status = res.code.to_i
-        raise Rufus::Jig::HttpError.new(status, res.body) \
-          unless [ 200, 201 ].include?(status)
-        return nil
+
+        res = Rufus::Jig::HttpResponse.new(http.start { |h| h.request(req) })
+
+        return @http.send(:respond, :put, path, nil, opts, nil, res)
       end
 
       @http.put(path, data, opts)
@@ -213,7 +263,7 @@ module Rufus::Jig
     #
     #   couch.detach(doc, 'my_picture')
     #
-    def detach (doc_id, doc_rev, attachment_name=nil)
+    def detach(doc_id, doc_rev, attachment_name=nil)
 
       if attachment_name.nil?
         attachment_name = doc_rev
@@ -244,7 +294,7 @@ module Rufus::Jig
     # Note : doc inclusion (third parameter to the block) only works with
     # CouchDB >= 0.11.
     #
-    def on_change (opts={}, &block)
+    def on_change(opts={}, &block)
 
       query = {
         'feed' => 'continuous',
@@ -299,6 +349,8 @@ module Rufus::Jig
       on_change(opts, &block) if opts[:reconnect]
     end
 
+    DESIGN_PATH_REGEX = /^\_design\//
+
     # A development method. Removes all the design documents in this couch
     # database.
     #
@@ -309,14 +361,111 @@ module Rufus::Jig
 
       docs = get('_all_docs')['rows']
 
-      views = docs.select { |d| d['id'] && d['id'].match(/^\_design\//) }
+      views = docs.select { |d| d['id'] && DESIGN_PATH_REGEX.match(d['id']) }
 
       views.each { |v| delete(v['id'], v['value']['rev']) }
     end
 
+    # Queries a view.
+    #
+    #   res = couch.query('_design/my_test/_view/my_view')
+    #     #
+    #     #   [ {"id"=>"c3", "key"=>"capuccino", "value"=>nil},
+    #     #     {"id"=>"c0", "key"=>"espresso", "value"=>nil},
+    #     #     {"id"=>"c2", "key"=>"macchiato", "value"=>nil},
+    #     #     {"id"=>"c4", "key"=>"macchiato", "value"=>nil},
+    #     #     {"id"=>"c1", "key"=>"ristretto", "value"=>nil} ]
+    #
+    #   # or simply :
+    #
+    #   res = couch.query('my_test:my_view')
+    #
+    # Accepts the usual couch parameters : limit, skip, descending, keys,
+    # startkey, endkey, ...
+    #
+    def query(path, opts={})
+
+      opts = opts.dup
+        # don't touch the original
+
+      raw = opts.delete(:raw)
+
+      path = if DESIGN_PATH_REGEX.match(path)
+        path
+      else
+        doc_id, view = path.split(':')
+        path = "_design/#{doc_id}/_view/#{view}"
+      end
+
+      path = adjust(path)
+
+      adjust_params(opts)
+
+      keys = opts.delete(:keys)
+
+      res = if keys
+        opts[:cache] = :with_body if opts[:cache].nil?
+        @http.post(path, { 'keys' => keys }, opts)
+      else
+        @http.get(path, opts)
+      end
+
+      return nil if res == true
+        # POST and the view doesn't exist
+
+      return res if raw
+
+      res.nil? ? res : res['rows']
+    end
+
+    # A shortcut for
+    #
+    #   query(path, :include_docs => true).collect { |row| row['doc'] }
+    #
+    def query_for_docs(path, opts={})
+
+      res = query(path, opts.merge(:include_docs => true))
+
+      if res.nil?
+        nil
+      elsif opts[:raw]
+        res
+      else
+        res.collect { |row| row['doc'] }.uniq
+      end
+    end
+
+    # Creates or updates docs in bulk (could even delete).
+    #
+    # http://wiki.apache.org/couchdb/HTTP_Bulk_Document_API#Modify_Multiple_Documents_With_a_Single_Request
+    #
+    def bulk_put(docs, opts={})
+
+      res = @http.post(adjust('_bulk_docs'), { 'docs' => docs })
+
+      opts[:raw] ?
+        res :
+        res.collect { |row| { '_id' => row['id'], '_rev' => row['rev'] } }
+    end
+
+    # Given an array of documents (at least { '_id' => x, '_rev' => y },
+    # deletes them.
+    #
+    def bulk_delete(docs, opts={})
+
+      docs = docs.inject([]) { |a, doc|
+        a << {
+          '_id' => doc['_id'], '_rev' => doc['_rev'], '_deleted' => true
+        } if doc
+        a
+      }
+
+      bulk_put(docs, opts)
+    end
+
     protected
 
-    def adjust (path)
+    def adjust(path)
 
       case path
         when '.' then @path
@@ -325,13 +474,27 @@ module Rufus::Jig
       end
     end
 
-    # Fetches etag from http cache
-    #
-    def etag (path)
+    COUCH_PARAMS = %w[
+      key startkey endkey descending group group_level limit skip include_docs
+    ].collect { |k| k.to_sym }
+
+    COUCH_KEYS = [ :key, :startkey, :endkey ]
+
+    def adjust_params(opts)
+
+      opts[:params] = opts.keys.inject({}) { |h, k|
 
-      r = @http.cache[path]
+        if COUCH_PARAMS.include?(k)
+          v = opts.delete(k)
+          if COUCH_KEYS.include?(k)
+            h[k] = CGI.escape(Rufus::Json.encode(v))
+          elsif v != nil
+            h[k] = v
+          end
+        end
 
-      r ? r.first : nil
+        h
+      }
     end
   end
 end

data/lib/rufus/jig/http.rb

@@ -22,7 +22,6 @@
 # Made in Japan.
 #++
 
-require 'ostruct'
 
 require 'rufus/lru' # gem install rufus-lru
 
@@ -34,7 +33,7 @@ module Rufus::Jig
   # The classical helper method, does a full copy of the given object.
   # Thanks Marshal.
   #
-  def self.marshal_copy (o)
+  def self.marshal_copy(o)
 
     Marshal.load(Marshal.dump(o))
   end
@@ -45,7 +44,7 @@ module Rufus::Jig
 
     attr_reader :status
 
-    def initialize (status, message)
+    def initialize(status, message)
 
       @status = status
       super(message)
@@ -56,56 +55,129 @@ module Rufus::Jig
   #
   class TimeoutError < RuntimeError
 
-    def initialize (message=nil)
+    def initialize(message=nil)
 
       super(message || 'timed out')
     end
   end
 
+  #
+  # a Rufus::Jig wrapper for the server response.
+  #
   class HttpResponse
 
     attr_reader :status, :headers, :body
     attr_reader :original
+
+    def initialize(res)
+
+      net_http_init(res)
+    end
+
+    def etag
+
+      headers['ETag'] || headers['Etag'] || headers['etag']
+    end
+
+    protected
+
+    # (leveraged by the patron adapter as well)
+    #
+    def net_http_init(net_http_response)
+
+      @original = net_http_response
+      @status = net_http_response.code.to_i
+      @body = net_http_response.body
+      @headers = {}
+      net_http_response.each { |k, v|
+        @headers[k.split('-').collect { |s| s.capitalize }.join('-')] = v
+      }
+    end
   end
 
-  URI_REGEX = /(https?):\/\/([^@]+:[^@]+@)?([^\/]+)([^\?]*)(\?.+)?$/
+  #
+  # Rufus::Jig.parse_uri returns instances of this class.
+  #
+  class Uri
+
+    attr_accessor :scheme
+    attr_accessor :username, :password
+    attr_accessor :host, :port
+    attr_accessor :path, :query, :fragment
+
+    def initialize(sc, us, ps, ho, po, pa, qu, fr)
+
+      @scheme = sc
+      @username = us
+      @password = ps
+      @host = ho
+      @port = po
+      @path = pa
+      @query = qu
+      @fragment = fr
+    end
+
+    def to_s
+
+      tail = tail_to_s
+
+      return tail unless @host
+
+      up = ''
+      up = "#{@username}:#{password}@" if @username
+
+      "#{@scheme}://#{up}#{@host}:#{@port}#{tail}"
+    end
+
+    def tail_to_s
+
+      tail = @path
+      tail = "#{tail}?#{@query}" if @query
+      tail = "#{tail}##{@fragment}" if @fragment
+
+      tail
+    end
+  end
+
+  URI_REGEX = /(https?):\/\/([^@]+:[^@]+@)?([^\/]+)(.*)?$/
+  PATH_REGEX = /([^\?#]*)(\?[^#]+)?(#[^#]+)?$/
 
   # The current URI lib is not UTF-8 friendly, so this is a workaround.
   # Temporary hopefully.
   #
-  def self.parse_uri (s)
+  def self.parse_uri(s)
 
     m = URI_REGEX.match(s)
 
-    scheme, uname, pass, host, port, path, query = if m
+    scheme, uname, pass, host, port, tail = if m
 
       ho, po = m[3].split(':')
       po = (po || 80).to_i
 
-      query = m[5] ? m[5][1..-1] : nil
-
       un, pa = m[2] ? m[2][0..-2].split(':') : [ nil, nil ]
 
-      [ m[1], un, pa, ho, po, m[4], query ]
+      [ m[1], un, pa, ho, po, m[4] ]
 
     else
 
-      pa, qu = s.split('?')
-
-      [ nil, nil, nil, nil, nil, pa, qu ]
+      [ nil, nil, nil, nil, nil, s ]
     end
 
-    OpenStruct.new(
-      :scheme => scheme,
-      :host => host, :port => port,
-      :path => path, :query => query,
-      :username => uname, :password => pass)
+    m = PATH_REGEX.match(tail)
+
+    path, query, fragment = [ m[1], m[2], m[3] ]
+
+    port = 443 if scheme == 'https' && port == 80
+    query = query[1..-1] if query
+    fragment = fragment[1..-1] if fragment
+
+    Uri.new(scheme, uname, pass, host, port, path, query, fragment)
   end
 
   # The current URI lib is not UTF-8 friendly, so this is a workaround.
   # Temporary hopefully.
   #
-  def self.parse_host (s)
+  def self.parse_host(s)
 
     u = parse_uri(s)
 
@@ -140,9 +212,9 @@ module Rufus::Jig
     # path, it is stored in @_path (and not used).
     # Rufus::Jig::Couch uses it though.
     #
-    attr_accessor :_path, :_query
+    attr_accessor :_path, :_query, :_fragment
 
-    def initialize (*args)
+    def initialize(*args)
 
       @options = args.last.is_a?(Hash) ? args.pop.dup : {}
 
@@ -162,13 +234,19 @@ module Rufus::Jig
         @options[:basic_auth] ||= [ u.username, u.password ] if u.username
 
         if args[1]
-          @_path, @_query = args[1].split('?')
+          uu = Rufus::Jig.parse_uri(args[1])
+          @_path = uu.path
+          @_query = uu.query
+          @_fragment = uu.fragment
         else
           @_path = u.path
           @_query = u.query
+          @_fragment = u.fragment
         end
       end
 
+      @_path ||= ''
+
       @cache = LruHash.new((@options[:cache_size] || 35).to_i)
 
       if pf = @options[:prefix]
@@ -180,99 +258,79 @@ module Rufus::Jig
 
     def uri
 
-      OpenStruct.new(:scheme => @scheme, :host => @host, :port => @port)
+      Uri.new(@scheme, nil, nil, @host, @port, nil, nil, nil)
     end
 
-    def get (path, opts={})
+    def get(path, opts={})
 
       request(:get, path, nil, opts)
     end
 
-    def post (path, data, opts={})
+    def post(path, data, opts={})
 
       request(:post, path, data, opts)
     end
 
-    def put (path, data, opts={})
+    def put(path, data, opts={})
 
       request(:put, path, data, opts)
     end
 
-    def delete (path, opts={})
+    def delete(path, opts={})
 
       request(:delete, path, nil, opts)
     end
 
     protected
 
-    def from_cache (path, opts)
-
-      if et = opts[:etag]
-
-        cached = @cache[path]
-
-        if cached && cached.first != et
-          #
-          # cached version is perhaps stale
-          #
-          cached = nil
-          opts.delete(:etag)
-        end
-
-        cached
-
-      else
-
-        nil
-      end
-    end
-
-    def request (method, path, data, opts={})
+    def request(method, path, data, opts={})
 
-      raw = raw_expected?(opts)
+      data_hash = data.hash
 
       path = add_prefix(path, opts)
       path = add_params(path, opts)
 
       path = '/' if path == ''
 
-      cached = from_cache(path, opts)
-      opts.delete(:etag) if (not cached) || method != :get
+      cached = from_cache(method, path, data_hash, opts)
 
       opts = rehash_options(opts)
       data = repack_data(data, opts)
 
-      r = do_request(method, path, data, opts)
+      res = do_request(method, path, data, opts)
 
-      @last_response = r
+      respond(method, path, data_hash, opts, cached, res)
+    end
 
-      unless raw
+    def respond(method, path, data_hash, opts, cached, res)
 
-        return Rufus::Jig.marshal_copy(cached.last) if r.status == 304
-        return nil if method == :get && r.status == 404
-        return true if [ 404, 409 ].include?(r.status)
+      @last_response = res
 
-        raise @error_class.new(r.status, r.body) \
-          if r.status >= 400 && r.status < 600
-      end
+      raw = opts[:raw]
+      raw == false ? false : raw || @options[:raw]
 
-      b = decode_body(r, opts)
+      unless raw
 
-      do_cache(method, path, r, b, opts)
+        return Rufus::Jig.marshal_copy(cached.last) if res.status == 304
+        return nil if method == :get && res.status == 404
+        return true if [ 404, 409 ].include?(res.status)
 
-      raw ? r : b
-    end
+        if res.status >= 400 && res.status < 600
+          #File.open('error.html', 'wb') { |f| f.puts(res.body) }
+          raise @error_class.new(res.status, res.body)
+        end
+      end
 
-    def raw_expected? (opts)
+      b = decode_body(res, opts)
 
-      raw = opts[:raw]
+      do_cache(method, path, data_hash, opts, res, b)
 
-      raw == false ? false : raw || @options[:raw]
+      raw ? res : b
     end
 
     # Should work with GET and POST/PUT options
     #
-    def rehash_options (opts)
+    def rehash_options(opts)
 
       opts['Accept'] ||= (opts.delete(:accept) || 'application/json')
       opts['Accept'] = 'application/json' if opts['Accept'] == :json
@@ -291,7 +349,7 @@ module Rufus::Jig
       opts
     end
 
-    def add_prefix (path, opts)
+    def add_prefix(path, opts)
 
       host = Rufus::Jig.parse_host(path)
 
@@ -306,7 +364,7 @@ module Rufus::Jig
       Path.join(*elts)
     end
 
-    def add_params (path, opts)
+    def add_params(path, opts)
 
       if params = opts[:params]
 
@@ -322,42 +380,77 @@ module Rufus::Jig
       path
     end
 
-    def repack_data (data, opts)
+    APP_JSON_REGEX = /^application\/json/
 
-      return nil unless data
+    def repack_data(data, opts)
 
+      return nil if data == nil
+      return data if data.is_a?(String)
 
-      data = if data.is_a?(String)
-        data
-      elsif (opts['Content-Type'] || '').match(/^application\/json/)
-        Rufus::Json.encode(data)
+      ct = opts['Content-Type'] || ''
+
+      if APP_JSON_REGEX.match(ct)
+        return Rufus::Json.encode(data)
+      end
+      if ct == '' && (data.is_a?(Array) || data.is_a?(Hash))
+        opts['Content-Type'] = 'application/json'
+        return Rufus::Json.encode(data)
+      end
+
+      data.to_s
+    end
+
+    def from_cache(method, path, data_hash, opts)
+
+      path = if method == :post && opts[:cache] == :with_body
+        "#{path}//#{data_hash}"
       else
-        data.to_s
+        path
       end
 
-      #opts['Content-Length'] =
-      #  (data.respond_to?(:bytesize) ? data.bytesize : data.size).to_s
-        #
-        # Patron doesn't play well with custom lengths : "56, 56" issue
+      etag = opts[:etag]
+      cached = @cache[path]
+
+      if etag && cached && cached.first != etag
+        # cached version is probably stale
+        cached = nil
+        opts.delete(:etag)
+      end
+      if ( ! etag) && cached
+        opts[:etag] = cached.first
+      end
 
-      data
+      cached
     end
 
-    def do_cache (method, path, response, body, opts)
+    def do_cache(method, path, data_hash, opts, response, body)
+
+      path = if method == :post && opts[:cache] == :with_body
+        "#{path}//#{data_hash}"
+      else
+        path
+      end
 
-      if (method != :get) || (opts[:cache] == false)
+      etag = response.etag
+
+      if etag.nil? || opts[:cache] == false || method == :delete
+        @cache.delete(path)
+        return
+      end
+      if method != :get && ( ! opts[:cache])
         @cache.delete(path)
-      elsif et = response.headers['Etag']
-        @cache[path] = [ et, Rufus::Jig.marshal_copy(body) ]
+        return
       end
+
+      @cache[path] = [ etag, Rufus::Jig.marshal_copy(body) ]
     end
 
-    def decode_body (response, opts)
+    def decode_body(response, opts)
 
       b = response.body
       ct = response.headers['Content-Type']
 
-      if opts[:force_json] || (ct && ct.match(/^application\/json/))
+      if opts[:force_json] || (ct && APP_JSON_REGEX.match(ct))
         Rufus::Json.decode(b)
       else
         b