dolly 1.1.4 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c296071100cabab1fada9107b27de3e3f9af84a2
-  data.tar.gz: 29f8e5081e455621370bd73efe9a3f9d6551cdaf
+SHA256:
+  metadata.gz: 52fcc7a3f0888239aaff1a6398a81112d031722db14d3070d83d574179414197
+  data.tar.gz: 20d5efb134448842c4c547d85f0f395993fdd8817898e7b174e3e5f5714a7022
 SHA512:
-  metadata.gz: 0f2d6d51779aa4596c733c1c60ccd1151a2a31c4eb120ec80614566bec61156f72ac7cbdbc5df9ae1edb95b3e4d6d3ef9e97990b178d694b0732f3d8be6527f5
-  data.tar.gz: 7ac04a9806361c649b39bf9f7749db23a9c2ee50d5901a2dff3a1b45578e145477537bad44265331ecdc90151952cc5cbc551582d6df888c94c2d08d659246c6
+  metadata.gz: f684874eaa87448a0ae67fddf5df98f3e86c5c6a53f8fb7b75e1331d16d63f07e6ef8eb2db17e461609433ccaf770a1c3a3c27b1551b5cf7c823f2d010005075
+  data.tar.gz: f44fa8ea168a1d6ca31042c4eed5b8cf0fdb1fd11dfcc5fb76e177598cce96512e6cca8a842e6c646fa4f65f8e4e0ea9759379ad73954c42fb1694c9803d42c3

data/README.md

@@ -0,0 +1,78 @@
+# 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.
+
+
+## Migrating from couch 1.x to 2.x
+
+[Official docs](https://docs.couchdb.org/en/2.3.1/install/index.html)
+
+
+You will need to uninstall the couchdb service with brew
+
+`brew services stop couchdb`
+`brew services uninstall couchdb`
+
+Download the application from the following source
+
+http://couchdb.apache.org/#download
+
+launch fauxton and check your installation
+
+Copy [this file](https://github.com/apache/couchdb/blob/master/rel/overlay/bin/couchup) into your filesystem
+
+
+make it executable
+
+`chmod +x couchup.py`
+
+and run it
+
+`./couchup.py -h`
+
+You might need to install python 3 and pip3 and the following libs
+
+`pip3 install requests progressbar2`
+
+move your .couch files into the specified `database_dir` in your [fauxton config](http://127.0.0.1:5984/_utils/#_config/couchdb@localhost)
+
+
+```
+$ ./couchup list           # Shows your unmigrated 1.x databases
+$ ./couchup replicate -a   # Replicates your 1.x DBs to 2.x
+$ ./couchup rebuild -a     # Optional; starts rebuilding your views
+$ ./couchup delete -a      # Deletes your 1.x DBs (careful!)
+$ ./couchup list           # Should show no remaining databases!
+```

data/lib/dolly.rb

@@ -1,5 +1,7 @@
 require "dolly/version"
 require "dolly/document"
-require 'dolly/railtie' if defined?(Rails)
+require 'dolly/mango_index'
+require 'railties/railtie' if defined?(Rails)
 
-module Dolly; end
+module Dolly
+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 #{item} 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,55 @@
 module Dolly
-  class Collection < DelegateClass(Set)
-    attr_accessor :rows
-    attr_writer :json, :docs_class
+  class Collection < DelegateClass(Array)
+    attr_reader :options
 
-    def initialize str, docs_class
-      @docs_class = docs_class
-      @json = str
-      initial = []
-      super(initial)
-      load
+    def initialize(rows: [], options: {})
+      @options = options
+      #TODO: We should raise an exception if one of the
+      #      requested documents is missing
+      super rows[: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_model(row))
+        klass.from_doc(row[:doc])
       end
     end
 
-    def load
-      parsed = JSON::parse json
-      self.rows = parsed['rows']
+    def doc_model(doc)
+      options[:doc_type] || constantize_key(doc[:doc_type]) || constantize_key(doc_type_for(doc[:id]))
     end
 
-    def to_json options = {}
-      load if empty?
-      map{|r| r.doc }.to_json(options)
+    def doc_type_for(key)
+      return false if key.nil?
+      key.match(%r{^([^/]+)/})[1]
     end
 
-    private
-    def docs_class
-      @docs_class
+    def constantize_key(key)
+      return false if key.nil?
+      key.split('_').collect(&:capitalize).join
     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 collectable_row?(row)
+      !deleted_doc?(row) && row[:error].nil?
     end
 
-    def json
-      @json
+    def deleted_doc?(row)
+      value = row&.fetch(:value, {})
+      return false unless value.is_a? Hash
+      value.fetch(:deleted, false)
     end
-
   end
 end

data/lib/dolly/configuration.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require 'erb'
+
+module Dolly
+  module Configuration
+    attr_writer :config_file
+
+    def env
+      @env ||= configuration[db.to_s]
+    end
+
+    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,121 @@
-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' }
+    SECURE_PROTOCOL = 'https'
 
-    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 = nil, escape: true
+      query = { query: { rev: rev } } if rev
+      resource = resource.cgi_escape if escape
+      request :delete, resource, query
     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, method)
+    end
+
+    private
+
+    def start_request(req)
+      req.basic_auth env['username'], env['password'] if env['username']&.present?
+
+      http = Net::HTTP.new(req.uri.host, req.uri.port)
+      http.use_ssl = secure?
+
+      http.request(req)
     end
 
+    def secure?
+      env['protocol'] == SECURE_PROTOCOL
+    end
+
+    def response_format(res, method)
+      raise Dolly::ResourceNotFound if res.code.to_i == 404
+      raise Dolly::ServerError.new(res.body) if (400..600).include? res.code.to_i
+      return res if method == :head
+      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