dolly 1.1.7 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 45fa7180b3da598f09d522101ae72b4d35bff7d1
-  data.tar.gz: 3eceb48ee307b83c6b379e2bdacd7530cafbe0f5
+SHA256:
+  metadata.gz: b4a7f73673dc9600d2451b6ae0dd1ed5ca8c792f671f1a115405b751610b9077
+  data.tar.gz: 7765f1a58d5515aebce77a79fdde6e0aad8e8928867e39c45a26ac5321ef7cb9
 SHA512:
-  metadata.gz: 2e3e721bce03f02a766d159950956ac4dff0394cf437f1fc06117ad5755ee9a0e8da0baa004c2c247710c9909fe36a5be2815ea78eb5c4371700e9376ea1b9e1
-  data.tar.gz: 3215f948add4eb9b8f7048bafcd0a98e01c91ce09c4c4601a0c58d4a9863f1d2aa96a88de65f62d70e32945493bc82c7b9d43a25726457308321a1022e3c65f5
+  metadata.gz: 9430a6c2bc2b951442751b3192778a7d73985d6cb3fa0864f5a9529695d20fec13cd4b451d8232f06dfc0a27cc6897acae734eb979c52b63a60d81aa7c5061c6
+  data.tar.gz: a46dd510d441efffe1b7998e64b5806fba6fee10470dc3c38d78a4be49bd18d48b50ad9d84b630ef0c04895934214821162a46e3bc3888a71c02171623bffdb6

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/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

@@ -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,113 @@
-require "dolly/request"
-require "dolly/name_space"
-require "dolly/db_config"
-require "dolly/bulk_document"
+require 'curb'
+require 'oj'
+require 'cgi'
+require 'net/http'
+require 'dolly/request_header'
+require 'dolly/exceptions'
+require 'dolly/configuration'
+require 'refinements/string_refinements'
+require 'dolly/framework_helper'
 
 module Dolly
-  module Connection
-    include Dolly::NameSpace
-    include Dolly::DbConfig
+  class Connection
+    include Dolly::Configuration
+    include Dolly::FrameworkHelper
+    attr_reader :db, :app_env
 
-    @@design_doc = nil
+    DEFAULT_HEADER = { 'Content-Type' => 'application/json', 'Accept' => 'application/json' }
+    SECURE_PROTOCOL = 'https'
+    DEFAULT_DATABASE = :default
 
-    def database
-      @database ||= Request.new(env)
+    using StringRefinements
+
+    def initialize db = DEFAULT_DATABASE, 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, query
+    end
+
+    def post resource, data
+      request :post, resource.cgi_escape, data
     end
 
-    def bulk_document
-      @bulk_document ||= BulkDocument.new(database)
+    def put resource, data
+      request :put, resource.cgi_escape, data
     end
 
-    def bulk_save
-      bulk_document.save
+    def delete resource, rev = nil, escape: true
+      query = "?rev=#{rev}" if rev
+      resource = "#{escape ? resource.cgi_escape : resource}#{query}"
+      request :delete, resource
     end
 
-    def database_name value
-      @@database_name ||= value
+    def view resource, opts
+      request :get, resource, query: values_to_json({include_docs: true}.merge!(opts))
     end
 
-    def default_doc
-      "#{design_doc}/_view/find"
+    def attach resource, attachment_name, data, headers = {}
+      request :put, "#{resource.cgi_escape}/#{attachment_name}", { _body: data }.merge(headers: headers)
     end
 
-    def design_doc
-      "_design/#{env["design"]}"
+    def uuids opts = {}
+      tools("_uuids", opts)[:uuids]
     end
 
-    def next_id
-      namespace database.uuids.first
+    def stats
+      get("/#{db_name}")
+    end
+
+    def tools path, opts = nil
+      request(:get, "/#{path}", opts)
+    end
+
+    def request(method, resource, data = {})
+      headers  = Dolly::HeaderRequest.new(data&.delete(:headers))
+      data&.merge!(data&.delete(:query) || {})
+      db_resource = (resource =~ %r{^/}) ? resource : "/#{db_name}/#{resource}"
+      uri = URI("#{base_uri}#{db_resource}")
+      conn = curl_method_call(method, uri, data) do |curl|
+        if env['username'].present?
+          curl.http_auth_types = :basic
+          curl.username = env['username']
+          curl.password = env['password'].to_s
+        end
+
+        headers.each { |k, v| curl.headers[k] = v } if headers.present?
+      end
+      response_format(conn, method)
     end
 
+    private
+
+    def curl_method_call(method, uri, data, &block)
+      return Curl::Easy.http_head(uri.to_s, &block) if method.to_sym == :head
+      return Curl.delete(uri.to_s, &block) if method.to_sym == :delete
+      return Curl.send(method, uri, data, &block) if method.to_sym == :get
+      Curl.send(method, uri.to_s, data.to_json, &block)
+    end
+
+    def response_format(res, method)
+      raise Dolly::ResourceNotFound if res.status.to_i == 404
+      raise Dolly::ServerError.new(res.status.to_i) if (400..600).include? res.status.to_i
+      return res.header_str if method == :head
+
+      data = Oj.load(res.body_str, symbol_keys: true)
+      return data unless rails?
+      data.with_indifferent_access
+    rescue Oj::ParseError
+      res.body_str
+    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

data/lib/dolly/depracated_database.rb

@@ -0,0 +1,24 @@
+module Dolly
+  module DepracatedDatabase
+    Database = Struct.new(:connection) do
+      def request *args
+        connection.request *args
+      end
+
+      def post *args
+        connection.post *args
+      end
+    end
+
+    def view *args
+      opts = args.pop if args.last.is_a? Hash
+      opts ||= {}
+      connection.view *args, opts.merge(include_docs: true)
+    end
+
+    def database
+      warn "[DEPRECATION] `database` is deprecated.  Please use `connection` instead."
+      Database.new(connection)
+    end
+  end
+end