dolly 3.0.0 → 3.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c26d50611f8efd7f5cd7b973256ddb6d885a747a
-  data.tar.gz: 4c16a1b2b21b55eeba0a9b7c0307dce20af3be90
+SHA256:
+  metadata.gz: 2242b051913632959c785357a5de12506673ae26c369bdaccb77763edcf5a15b
+  data.tar.gz: db0e1cb72dba11f0adc1184338754266dfccfe2eabd4188a23b1a313d236f2bf
 SHA512:
-  metadata.gz: a4a534952347905e024d8da5eec35a31220305edb10528e2d8e30608691ab42143a09c08a005f0121c6acda6a7f6c53320907eb9c81f4b821966d1980c6040d8
-  data.tar.gz: b4f1d1f5994aa3d963d2fe77f2c8e4b67e4d657c66a4da5548924630da64d28a70f0902b9bd503c08c4a982a47a34e188a0468ee2559eab8a0c1599ede6881c1
+  metadata.gz: '096b5264f6a0c36dc68c5c6179300fc7ca2b7fb9d8806b83929ae34180d0f900b8fb64053a6423b51d9d12b716d685cc580618290f5b80cb9041decaa217af1d'
+  data.tar.gz: 1220024efbc8a6bb491099f612b260f010d74bbf5d26bc96367ec676cb1095ecbf3f98194b1449f2563116770f23f5ba9bbac985a0b314ba18f3658ee85b5278

data/README.md

@@ -33,3 +33,46 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 ## 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/bulk_document.rb

@@ -80,7 +80,7 @@ module Dolly
     end
 
     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)
+      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/collection.rb

@@ -1,12 +1,12 @@
 module Dolly
   class Collection < DelegateClass(Array)
-    attr_reader :info
+    attr_reader :options
 
-    def initialize(rows: [], **info)
-      @info = info
+    def initialize(rows: [], options: {})
+      @options = options
       #TODO: We should raise an exception if one of the
       #      requested documents is missing
-      super rows.map(&collect_docs).compact
+      super rows[:rows].map(&collect_docs).compact
     end
 
     def first_or_all(forced_first = false)
@@ -23,13 +23,23 @@ module Dolly
     def collect_docs
       lambda do |row|
         next unless collectable_row?(row)
-        klass = Object.const_get doc_type(row[:id])
+        klass = Object.const_get(doc_model(row))
         klass.from_doc(row[:doc])
       end
     end
 
-    def doc_type(key)
-      key.match(%r{^([^/]+)/})[1].split('_').collect(&:capitalize).join
+    def doc_model(doc)
+      options[:doc_type] || constantize_key(doc[:doc_type]) || constantize_key(doc_type_for(doc[:id]))
+    end
+
+    def doc_type_for(key)
+      return false if key.nil?
+      key.match(%r{^([^/]+)/})[1]
+    end
+
+    def constantize_key(key)
+      return false if key.nil?
+      key.split('_').collect(&:capitalize).join
     end
 
     def collectable_row?(row)

data/lib/dolly/connection.rb

@@ -1,3 +1,4 @@
+require 'curb'
 require 'oj'
 require 'cgi'
 require 'net/http'
@@ -5,24 +6,28 @@ require 'dolly/request_header'
 require 'dolly/exceptions'
 require 'dolly/configuration'
 require 'refinements/string_refinements'
+require 'dolly/framework_helper'
 
 module Dolly
   class Connection
     include Dolly::Configuration
+    include Dolly::FrameworkHelper
     attr_reader :db, :app_env
 
-    DEFAULT_HEADER = { 'Content-Type' => 'application/json' }
+    DEFAULT_HEADER = { 'Content-Type' => 'application/json', 'Accept' => 'application/json' }
+    SECURE_PROTOCOL = 'https'
+    DEFAULT_DATABASE = :default
 
     using StringRefinements
 
-    def initialize db = :default, app_env = :development
+    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.cgi_escape, query
+      request :get, resource, query
     end
 
     def post resource, data
@@ -33,8 +38,10 @@ module Dolly
       request :put, resource.cgi_escape, data
     end
 
-    def delete resource, rev
-      request :delete, resource.cgi_escape, query: { rev: rev }
+    def delete resource, rev = nil, escape: true
+      query = "?rev=#{rev}" if rev
+      resource = "#{escape ? resource.cgi_escape : resource}#{query}"
+      request :delete, resource
     end
 
     def view resource, opts
@@ -58,46 +65,55 @@ module Dolly
     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)
+      db_resource = (resource =~ %r{^/}) ? resource : "/#{db_name}/#{resource}"
+      headers     = fetch_headers(data)
+      body        = fetch_body(data)
+      uri         = URI("#{base_uri}#{db_resource}")
+
+      conn = curl_method_call(method, uri, body) 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 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
+    def fetch_headers(data)
+      return unless data.is_a?(Hash)
+      Dolly::HeaderRequest.new(data&.delete(:headers))
     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 fetch_body(data)
+      return data unless data.is_a?(Hash)
 
-    def format_data(data = nil, is_json)
-      return unless data
-      body = data.delete(:_body) || data
-      is_json ? body.to_json : body
+      data&.delete(:headers)
+      data&.merge!(data&.delete(:query) || {})
     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}")
+    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 request_method(method_name)
-      Object.const_get("Net::HTTP::#{method_name.capitalize}")
+    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?
+      return data.with_indifferent_access if data.is_a?(Hash)
+      data
+    rescue Oj::ParseError
+      res.body_str
     end
 
     def values_to_json hash

data/lib/dolly/document.rb

@@ -1,9 +1,13 @@
+require 'dolly/mango'
+require 'dolly/mango_index'
 require 'dolly/query'
+require 'dolly/view_query'
 require 'dolly/connection'
 require 'dolly/request'
 require 'dolly/depracated_database'
 require 'dolly/document_state'
 require 'dolly/properties'
+require 'dolly/document_type'
 require 'dolly/identity_properties'
 require 'dolly/attachment'
 require 'dolly/property_manager'
@@ -11,15 +15,20 @@ require 'dolly/timestamp'
 require 'dolly/query_arguments'
 require 'dolly/document_creation'
 require 'dolly/class_methods_delegation'
+require 'dolly/framework_helper'
 require 'refinements/string_refinements'
 
 module Dolly
   class Document
+    extend Mango
     extend Query
+    extend ViewQuery
     extend Request
     extend DepracatedDatabase
     extend Properties
     extend DocumentCreation
+
+    include DocumentType
     include PropertyManager
     include Timestamp
     include DocumentState
@@ -27,17 +36,35 @@ module Dolly
     include Attachment
     include QueryArguments
     include ClassMethodsDelegation
+    include FrameworkHelper
 
     attr_writer :doc
 
-    def initialize attributes = {}
+    def initialize(attributes = {})
+      init_ancestor_properties
       properties.each(&build_property(attributes))
     end
 
     protected
 
     def doc
-      @doc ||= {}
+      @doc ||= doc_for_framework
+    end
+
+    def init_ancestor_properties
+      self.class.ancestors.map do |ancestor|
+        begin
+          ancestor.properties.entries.each do |property|
+            properties << property
+          end
+        rescue NoMethodError => e
+        end
+      end
+    end
+
+    def doc_for_framework
+      return {} unless rails?
+      {}.with_indifferent_access
     end
   end
 end

data/lib/dolly/document_creation.rb

@@ -1,16 +1,23 @@
 require 'dolly/properties'
+require 'dolly/framework_helper'
 
 module Dolly
   module DocumentCreation
     include Properties
+    include FrameworkHelper
 
     def from_doc(doc)
       attributes = property_clean_doc(doc)
-      new(attributes).tap { |model| model.doc = doc }
+
+      new(attributes).tap do |model|
+        model.send(:doc).merge!(doc)
+      end
     end
 
     def from_json(json)
-      from_doc(Oj.load(json, symbol_keys: true))
+      raw_data = Oj.load(json, symbol_keys: true)
+      data = rails? ? data.with_indifferent_access : raw_data
+      from_doc(data)
     end
 
     def create(attributes)

data/lib/dolly/document_state.rb

@@ -6,6 +6,7 @@ module Dolly
 
     def save(options = {})
       return false unless options[:validate] == false || valid?
+      set_type if typed? && type.nil?
       write_timestamps(persisted?)
       after_save(connection.put(id, doc))
     end

data/lib/dolly/document_type.rb

@@ -13,8 +13,8 @@ module Dolly
       "#{name_paramitized}/#{key}"
     end
 
-    def base_id(id)
-      id.sub(%r{^#{name_paramitized}/}, '')
+    def base_id
+      self.id.sub(%r{^#{name_paramitized}/}, '')
     end
 
     def name_paramitized
@@ -24,5 +24,24 @@ module Dolly
     def class_name
       is_a?(Class) ? name : self.class.name
     end
+
+    def typed?
+      respond_to?(:type)
+    end
+
+    def set_type
+      return unless typed?
+      write_attribute(:type, name_paramitized)
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def typed_model
+        property :type, class_name: String
+      end
+    end
   end
 end

data/lib/dolly/exceptions.rb

@@ -15,6 +15,29 @@ module Dolly
     end
   end
 
+  class InvalidMangoOperatorError < RuntimeError
+    def initialize msg
+      @msg = msg
+    end
+
+    def to_s
+      "Invalid Mango operator: #{@msg.inspect}"
+    end
+  end
+
+  class BulkError < RuntimeError
+    def intialize(error:, reason:, obj:)
+      @error = error
+      @reason = reason
+      @obj = obj
+    end
+
+    def to_s
+      "#{@error} on #{@obj} because #{@reason}."
+    end
+  end
+
+  class IndexNotFoundError < RuntimeError; end
   class InvalidConfigFileError < RuntimeError; end
   class InvalidProperty < RuntimeError; end
   class DocumentInvalidError < RuntimeError; end

data/lib/dolly/framework_helper.rb

@@ -0,0 +1,7 @@
+module Dolly
+  module FrameworkHelper
+    def rails?
+      defined?(ActiveSupport::HashWithIndifferentAccess)
+    end
+  end
+end

data/lib/dolly/mango.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require 'refinements/hash_refinements'
+
+module Dolly
+  module Mango
+    using HashRefinements
+
+    SELECTOR_SYMBOL = '$'
+
+    COMBINATION_OPERATORS = %I[
+      and
+      or
+      not
+      nor
+      all
+      elemMatch
+      allMath
+    ].freeze
+
+    CONDITION_OPERATORS = %I[
+      lt
+      lte
+      eq
+      ne
+      gte
+      gt
+      exists
+      in
+      nin
+      size
+      mod
+      regex
+    ].freeze
+
+    TYPE_OPERATOR = %I[
+      type
+      $type
+    ]
+
+    ALL_OPERATORS = COMBINATION_OPERATORS + CONDITION_OPERATORS
+
+    DESIGN = '_find'
+
+    def find_by(query, opts = {})
+      build_model_from_doc(find_doc_by(query, opts))
+    end
+
+    def find_doc_by(query, opts = {})
+      opts.merge!(limit: 1)
+      response = perform_query(build_query(query, opts))
+      print_index_warning(query) if response.fetch(:warning, nil)
+      response[:docs].first
+    end
+
+    def where(query, opts = {})
+      docs_where(query, opts).map do |doc|
+        build_model_from_doc(doc)
+      end
+    end
+
+    def docs_where(query, opts = {})
+      response = perform_query(build_query(query, opts))
+      print_index_warning(query) if response.fetch(:warning, nil)
+      response[:docs]
+    end
+
+    def find_bare(id, fields, options = {})
+      q = { _id: id }
+      opts = { fields: fields }.merge(options)
+      query = build_query(q, opts)
+      response = perform_query(query)
+      response[:docs]
+    end
+
+    def where_bare(selector, fields, options = {})
+      opts = { fields: fields }.merge(options)
+      query = build_query(selector, opts)
+      response = perform_query(query)
+      response[:docs]
+    end
+
+    def find_with_metadata(query, options = {})
+      opts = options.merge!(limit: 1)
+      perform_query(build_query(query, opts))
+    end
+
+    def where_with_metadata(query, options = {})
+      perform_query(build_query(query, options))
+    end
+
+    def perform_query(structured_query)
+      connection.post(DESIGN, structured_query)
+    end
+
+    private
+
+    def print_index_warning(query)
+      message = "Index not found for #{query.inspect}"
+      if (defined?(Rails.logger) && Rails&.env&.development?)
+        Rails.logger.info(message)
+      else
+        puts message
+      end
+    end
+
+    def build_model_from_doc(doc)
+      return nil if doc.nil?
+      new(doc.slice(*all_property_keys)).tap { |d| d.rev = doc[:_rev] }
+    end
+
+    def build_query(query, opts)
+      { 'selector' => build_selectors(query) }.merge(opts)
+    end
+
+    def build_selectors(query)
+      query.deep_transform_keys do |key|
+        next build_key(key) if is_operator?(key)
+        next key if is_type_operator?(key)
+        raise Dolly::InvalidMangoOperatorError.new(key) unless has_property?(key)
+        key
+      end
+    end
+
+    def build_key(key)
+      return key if key.to_s.starts_with?(SELECTOR_SYMBOL)
+      "#{SELECTOR_SYMBOL}#{key}"
+    end
+
+    def is_operator?(key)
+      ALL_OPERATORS.include?(key) || key.to_s.starts_with?(SELECTOR_SYMBOL)
+    end
+
+    def fetch_fields(query)
+      deep_keys(query).reject do |key|
+        is_operator?(key) || is_type_operator?(key)
+      end
+    end
+
+    def has_property?(key)
+      self.all_property_keys.include?(key)
+    end
+
+    def is_type_operator?(key)
+      TYPE_OPERATOR.include?(key.to_sym)
+    end
+
+    def deep_keys(obj)
+      case obj
+      when Hash then obj.keys + obj.values.flat_map { |v| deep_keys(v) }
+      when Array then obj.flat_map { |i| deep_keys(i) }
+      else []
+      end
+    end
+  end
+end

data/lib/dolly/mango_index.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'dolly/document'
+
+module Dolly
+  class MangoIndex
+    class << self
+      extend Forwardable
+
+      ALL_DOCS = '_all_docs'
+      DESIGN = '_index'
+      ROWS_KEY = :rows
+      DESIGN_PREFIX = '_design/'
+
+      def_delegators :connection, :get, :post
+
+      def all
+        get(DESIGN)[:indexes]
+      end
+
+      def create(name, fields, type = 'json')
+        post(DESIGN, build_index_structure(name, fields, type))
+      end
+
+      def create_in_database(database, name, fields, type = 'json')
+        connection_for_database(database).post(DESIGN, build_index_structure(name, fields, type))
+      end
+
+      def find_by_fields(fields)
+        rows = get(ALL_DOCS, key: key_from_fields(fields))[ROWS_KEY]
+        (rows && rows.any?)
+      end
+
+      def delete_all
+        all.each do |index_doc|
+          next if index_doc[:ddoc].nil?
+          delete(index_doc)
+        end
+      end
+
+      def delete(index_doc)
+        resource = "#{DESIGN}/#{index_doc[:ddoc]}/json/#{index_doc[:name]}"
+        connection.delete(resource, escape: false)
+      end
+
+      private
+
+      def connection_for_database(database)
+        Dolly::Connection.new(database.to_sym, Rails.env || :development)
+      end
+
+      def connection
+        @connection ||= Dolly::Document.connection
+      end
+
+      def build_index_structure(name, fields, type)
+        {
+          ddoc: key_from_fields(fields).gsub(DESIGN_PREFIX, ''),
+          index: {
+            fields: fields
+          },
+          name: name,
+          type: type
+        }
+      end
+
+      def key_from_fields(fields)
+        "#{DESIGN_PREFIX}index_#{fields.join('_')}"
+      end
+    end
+  end
+end

data/lib/dolly/properties.rb

@@ -7,6 +7,7 @@ module Dolly
 
     def property *opts, class_name: nil, default: nil
       opts.each do |opt|
+
         properties << (prop = Property.new(opt, class_name, default))
         send(:attr_reader, opt)
 
@@ -20,12 +21,16 @@ module Dolly
       @properties ||= PropertySet.new
     end
 
+    def all_property_keys
+      properties.map(&:key) + SPECIAL_KEYS
+    end
+
     def property_keys
-      properties.map(&:key) - SPECIAL_KEYS
+      all_property_keys - SPECIAL_KEYS
     end
 
     def property_clean_doc(doc)
-      doc.reject { |key, _value| !property_keys.include?(key) }
+      doc.reject { |key, _value| property_keys.exclude?(key.to_sym) }
     end
   end
 end