dolly 1.1.7 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 45fa7180b3da598f09d522101ae72b4d35bff7d1
-  data.tar.gz: 3eceb48ee307b83c6b379e2bdacd7530cafbe0f5
+  metadata.gz: c26d50611f8efd7f5cd7b973256ddb6d885a747a
+  data.tar.gz: 4c16a1b2b21b55eeba0a9b7c0307dce20af3be90
 SHA512:
-  metadata.gz: 2e3e721bce03f02a766d159950956ac4dff0394cf437f1fc06117ad5755ee9a0e8da0baa004c2c247710c9909fe36a5be2815ea78eb5c4371700e9376ea1b9e1
-  data.tar.gz: 3215f948add4eb9b8f7048bafcd0a98e01c91ce09c4c4601a0c58d4a9863f1d2aa96a88de65f62d70e32945493bc82c7b9d43a25726457308321a1022e3c65f5
+  metadata.gz: a4a534952347905e024d8da5eec35a31220305edb10528e2d8e30608691ab42143a09c08a005f0121c6acda6a7f6c53320907eb9c81f4b821966d1980c6040d8
+  data.tar.gz: b4f1d1f5994aa3d963d2fe77f2c8e4b67e4d657c66a4da5548924630da64d28a70f0902b9bd503c08c4a982a47a34e188a0468ee2559eab8a0c1599ede6881c1

data/README.md

@@ -0,0 +1,35 @@
+# Dolly3
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/dolly3`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dolly3'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dolly3
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/dolly3.

data/lib/dolly.rb

@@ -1,28 +1,6 @@
 require "dolly/version"
 require "dolly/document"
-require "dolly/configuration"
-require 'dolly/railtie' if defined?(Rails)
+require 'railties/railtie' if defined?(Rails)
 
 module Dolly
-  class << self
-    def configure
-      yield config
-    end
-
-    def config
-      @config ||= Configuration.new
-    end
-
-    def reset!
-      @config = Configuration.new
-    end
-
-    def log_requests?
-      !!config.log_requests
-    end
-
-    def logger
-      @logger ||= config.logger
-    end
-  end
 end

data/lib/dolly/attachment.rb

@@ -0,0 +1,29 @@
+require 'base64'
+
+module Dolly
+  module Attachment
+    def attach_file! file_name, mime_type, body, opts={}
+      attach_file file_name, mime_type, body, opts
+      save
+    end
+
+    def attach_file file_name, mime_type, body, opts={}
+      if opts[:inline]
+        attach_inline_file file_name, mime_type, body
+      else
+        attach_standalone_file file_name, mime_type, body
+      end
+    end
+
+    def attach_inline_file file_name, mime_type, body
+      attachment_data = { file_name.to_s => { 'content_type' => mime_type,
+                                              'data'         => Base64.encode64(body)} }
+      doc['_attachments'] ||= {}
+      doc['_attachments'].merge! attachment_data
+    end
+
+    def attach_standalone_file file_name, mime_type, body
+      self.class.connection.attach id_as_resource, CGI.escape(file_name), body, { 'Content-Type' => mime_type }
+    end
+  end
+end

data/lib/dolly/bulk_document.rb

@@ -1,37 +1,34 @@
-require 'dolly/bulk_error'
-
 module Dolly
   class BulkDocument
-    include Enumerable
     extend Forwardable
 
-    DOC_NAME  = "_bulk_docs".freeze
+    DOC_NAME = '_bulk_docs'
 
-    attr_reader :payload, :database
+    attr_reader :payload, :connection
     attr_accessor :errors, :response
 
     def_delegators :docs, :[], :<<
 
-    def initialize database, ary = []
-      @database = database
+    def initialize(connection, ary = [])
+      @connection = connection
       @payload = Hash.new
-      self.payload[:docs] = ary
+      payload[:docs] = ary
     end
 
     def docs
-      self.payload[:docs]
+      payload[:docs]
     end
 
     def save
       return if docs.empty?
-      self.response = JSON::parse self.database.post(DOC_NAME, json_payload)
+      self.response = connection.post(DOC_NAME, docs_payload)
       build_errors
       update_revs
     end
 
     def delete
       return if docs.empty?
-      JSON::parse database.post DOC_NAME, json_payload("_deleted" => true)
+      connection.post DOC_NAME, json_payload(_deleted: true)
     end
 
     def clear
@@ -45,41 +42,45 @@ module Dolly
     end
 
     private
+
     def update_revs
-      self.response.each do |doc|
-        next if doc['error']
-        item = self.payload[:docs].detect{|d| d.id == doc['id']}
+      response.each do |doc|
+        next if doc[:error]
+        item = payload[:docs].detect { |d| d.id == doc[:id] }
+
         if item.nil?
-          self.errors << BulkError.new({"error" => "Document saved but not local rev updated.", "reason" => "Document with id #{doc['id']} on bulk doc was not found in payload.", "obj" => nil})
+          errors << response_error(item)
           next
         end
-        item.doc['_rev'] = doc['rev']
-        self.payload[:docs].delete item
+
+        item.rev = doc[:rev]
+        payload[:docs].delete(item)
       end
+
       clean_response
     end
 
     def clean_response
-      self.response.delete_if {|doc| !doc['error'] }
+      response.delete_if { |d| !d[:error] }
     end
 
     def build_errors
       self.errors = response_errors.map do |err|
-        obj = self.payload[:docs].detect{|d| d.id == err['id']} if err['id']
-        BulkError.new err.merge!("obj" => obj)
+        obj = payload[:docs].detect { |d| d.id == err[:id]} if err[:id]
+        BulkError.new err.merge!(obj: obj)
       end
     end
 
-    def bare_docs
-      self.payload[:docs].map(&:doc)
+    def docs_payload opts = {}
+      { docs: docs.map {|d| d.to_h.merge(opts) } }
     end
 
-    def json_payload opts = {}
-      {docs: bare_docs.map{|d| d.merge(opts)} }.to_json
+    def response_errors
+      self.response.select{ |d| d[:error] }
     end
 
-    def response_errors
-      self.response.select{|d| d['error']}
+    def response_error(item)
+      BulkError.new(error: 'Document saved but not local rev updated.', reason: "Document with id #{doc['id']} on bulk doc was not found in payload.", obj: nil)
     end
   end
 end

data/lib/dolly/class_methods_delegation.rb

@@ -0,0 +1,15 @@
+module Dolly
+  module ClassMethodsDelegation
+    def connection
+      self.class.connection
+    end
+
+    def property_clean_doc(doc)
+      self.class.property_clean_doc(doc)
+    end
+
+    def database
+      self.class.database
+    end
+  end
+end

data/lib/dolly/collection.rb

@@ -1,88 +1,45 @@
 module Dolly
-  class Collection < DelegateClass(Set)
-    attr_accessor :rows
-    attr_writer :json, :docs_class
+  class Collection < DelegateClass(Array)
+    attr_reader :info
 
-    def initialize str, docs_class
-      @docs_class = docs_class
-      @json = str
-      initial = []
-      super(initial)
-      load
+    def initialize(rows: [], **info)
+      @info = info
+      #TODO: We should raise an exception if one of the
+      #      requested documents is missing
+      super rows.map(&collect_docs).compact
     end
 
-    def last
-      to_a.last
+    def first_or_all(forced_first = false)
+      return self if forced_first
+      single? ? first : self
     end
 
-    def update_properties! properties ={}
-      properties.each do |key, value|
-
-        regex = %r{
-          \"#{key}\":  # find key definition in json string
-          (            # start value group
-            \"[^\"]*\" # find anything (even empty) between \" and \"
-            |          # logical OR
-            null       #literal null value
-          )            # end value group
-        }x
-
-        raise Dolly::MissingPropertyError unless json.match regex
-        json.gsub! regex, "\"#{key}\":\"#{value}\""
-      end
-
-      BulkDocument.new(Dolly::Document.database, to_a).save
-      clear
-      load
-      self
+    def single?
+      size <= 1
     end
 
-    def each &block
-      load if empty?
-      super &block
-      #TODO: returning nil to avoid extra time serializing set.
-      nil
-    end
+    private
 
-    def rows= ary
-      ary.each do |r|
-        next unless r['doc']
-        properties = r['doc']
-        id = properties.delete '_id'
-        rev = properties.delete '_rev' if properties['_rev']
-        document = (docs_class || doc_class(id)).new properties
-        document.doc = properties.merge({'_id' => id, '_rev' => rev})
-        self << document
+    def collect_docs
+      lambda do |row|
+        next unless collectable_row?(row)
+        klass = Object.const_get doc_type(row[:id])
+        klass.from_doc(row[:doc])
       end
     end
 
-    def load
-      parsed = JSON::parse json
-      self.rows = parsed['rows']
+    def doc_type(key)
+      key.match(%r{^([^/]+)/})[1].split('_').collect(&:capitalize).join
     end
 
-    def to_json options = {}
-      load if empty?
-      map{|r| r.doc }.to_json(options)
+    def collectable_row?(row)
+      !deleted_doc?(row) && row[:error].nil?
     end
 
-    private
-    def docs_class
-      @docs_class
-    end
-
-    def doc_class id
-      # TODO: We need to improve and document the way we return
-      # multiple types when querying from a class, as it might
-      # be confusing. We *could* also get dolly to parse the result
-      # before sending it back to the client.
-      doc_class = id[/^[a-z_]+/].camelize.constantize
-      docs_class == doc_class ? docs_class : doc_class
+    def deleted_doc?(row)
+      value = row&.fetch(:value, {})
+      return false unless value.is_a? Hash
+      value.fetch(:deleted, false)
     end
-
-    def json
-      @json
-    end
-
   end
 end

data/lib/dolly/configuration.rb

@@ -1,18 +1,43 @@
-require 'dolly/logger'
+# frozen_string_literal: true
+require 'erb'
 
 module Dolly
-  class Configuration
-    attr_accessor :log_requests, :log_path, :log
+  module Configuration
+    attr_writer :config_file
 
-    def initialize
-      @log_requests = false
-      @log_path = $stdout
-      @log = :dolly
+    def env
+      @env ||= configuration[db.to_s]
     end
 
-    def logger
-      return Rails.logger if log.to_sym == :rails
-      Dolly::Logger.new self
+    def base_uri
+      "#{protocol}#{host}#{port}"
+    end
+
+    def protocol
+      "#{env['protocol']}://"
+    end
+
+    def host
+      env['host']
+    end
+
+    def port
+      return unless env['port']
+      ":#{env['port']}"
+    end
+
+    def db_name
+      env['name']
+    end
+
+    def configuration
+      @config_data ||= File.read(config_file)
+      raise Dolly::InvalidConfigFileError if @config_data&.empty?
+      YAML::load(ERB.new(@config_data).result)[app_env.to_s]
+    end
+
+    def config_file
+      @config_file ||= File.join('config', 'couchdb.yml')
     end
   end
 end

data/lib/dolly/connection.rb

@@ -1,42 +1,111 @@
-require "dolly/request"
-require "dolly/name_space"
-require "dolly/db_config"
-require "dolly/bulk_document"
+require 'oj'
+require 'cgi'
+require 'net/http'
+require 'dolly/request_header'
+require 'dolly/exceptions'
+require 'dolly/configuration'
+require 'refinements/string_refinements'
 
 module Dolly
-  module Connection
-    include Dolly::NameSpace
-    include Dolly::DbConfig
+  class Connection
+    include Dolly::Configuration
+    attr_reader :db, :app_env
 
-    @@design_doc = nil
+    DEFAULT_HEADER = { 'Content-Type' => 'application/json' }
 
-    def database
-      @database ||= Request.new(env)
+    using StringRefinements
+
+    def initialize db = :default, app_env = :development
+      @db      = db
+      @app_env = app_env
+    end
+
+    def get(resource, data = {})
+      query = { query: values_to_json(data) } if data
+      request :get, resource.cgi_escape, query
+    end
+
+    def post resource, data
+      request :post, resource.cgi_escape, data
+    end
+
+    def put resource, data
+      request :put, resource.cgi_escape, data
     end
 
-    def bulk_document
-      @bulk_document ||= BulkDocument.new(database)
+    def delete resource, rev
+      request :delete, resource.cgi_escape, query: { rev: rev }
     end
 
-    def bulk_save
-      bulk_document.save
+    def view resource, opts
+      request :get, resource, query: values_to_json({include_docs: true}.merge!(opts))
     end
 
-    def database_name value
-      @@database_name ||= value
+    def attach resource, attachment_name, data, headers = {}
+      request :put, "#{resource.cgi_escape}/#{attachment_name}", { _body: data }.merge(headers: headers)
     end
 
-    def default_doc
-      "#{design_doc}/_view/find"
+    def uuids opts = {}
+      tools("_uuids", opts)[:uuids]
     end
 
-    def design_doc
-      "_design/#{env["design"]}"
+    def stats
+      get("/#{db_name}")
     end
 
-    def next_id
-      namespace database.uuids.first
+    def tools path, opts = nil
+      request(:get, "/#{path}", opts)
+    end
+
+    def request(method, resource, data = {})
+      headers  = Dolly::HeaderRequest.new data.delete(:headers)
+      uri      = build_uri(resource, data.delete(:query))
+      klass    = request_method(method)
+      req      = klass.new(uri, headers)
+      req.body = format_data(data, headers.json?)
+      response = start_request(req)
+
+      response_format(response)
+    end
+
+    private
+
+    def start_request(req)
+      Net::HTTP.start(req.uri.hostname, req.uri.port) do |http|
+        req.basic_auth env['username'], env['password'] if env['username'].present?
+        http.request(req)
+      end
     end
 
+    def response_format(res)
+      raise Dolly::ResourceNotFound if res.code.to_i == 404
+      raise Dolly::ServerError.new(res.body) if (400..600).include? res.code.to_i
+      Oj.load(res.body, symbol_keys: true)
+    end
+
+    def format_data(data = nil, is_json)
+      return unless data
+      body = data.delete(:_body) || data
+      is_json ? body.to_json : body
+    end
+
+    def build_uri(resource, query = nil)
+      query_str = "?#{to_query(query)}" if query
+      uri       = (resource =~ %r{^/}) ? resource : "/#{db_name}/#{resource}"
+
+      URI("#{base_uri}#{uri}#{query_str}")
+    end
+
+    def request_method(method_name)
+      Object.const_get("Net::HTTP::#{method_name.capitalize}")
+    end
+
+    def values_to_json hash
+      hash.each_with_object({}) { |(k,v), h| h[k] = v.is_a?(Numeric) ? v : v.to_json }
+    end
+
+    def to_query(string)
+      string.map { |k, v| "#{k}=#{v}" }.sort * '&'
+    end
   end
 end