dolly 1.1.5 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 03de975a49c2982823fa97d06b6fab8cd2c318bd
-  data.tar.gz: 0bb7049a7a92b697b192e5b77a8c7c4e1f987f34
+SHA256:
+  metadata.gz: 2bd1cf887f25cacb3b25be56354cf74c1771cd021514cb8bf733e31aa7198feb
+  data.tar.gz: cd464f54583a1f417fb58e27f504ccce8ddd33f39f1f48eea0f3b66487313445
 SHA512:
-  metadata.gz: f6c3ed9e33e8e708cd683f0e6444e42b74daf5ed32df22dafef257c78f486a62f1e01b475d071900f911152cf49e7b27e435ac837852db10080714c0566e042e
-  data.tar.gz: 9e2c3a349107aaabd667b011c8d41bcec00c743317a17111af4a7d4c47f307a4bb22e1817549ca3ffd77a13b146e14ce84d6e880b162d0bf16d18a149ebbc2c5
+  metadata.gz: 5c2bddaf348f5028c10ea464ea3265a9653d741508a103d3bd4d3e83757261ead6de60d630db9a8fa512ba22e13cd36043debc8e8d7be457aa63079018a3d580
+  data.tar.gz: f1c2ede8149132f5d6941fbbe0b4eb1ada18ed060eb76ccd8b4eeffec556590b2b8c8044331d6726de10a0758120a6595b07f6da5afdd86da95be655344ceb8b

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,28 +1,7 @@
 require "dolly/version"
 require "dolly/document"
-require "dolly/configuration"
-require 'dolly/railtie' if defined?(Rails)
+require 'dolly/mango_index'
+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 #{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