dolly 1.1.5 → 3.1.0

data/lib/dolly/connection.rb

@@ -1,42 +1,106 @@
-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'
 
 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', '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 put resource, data
+      request :put, resource.cgi_escape, data
+    end
+
+    def delete resource, rev = nil, escape: true
+      query = "?rev=#{rev}" if rev
+      resource = "#{escape ? resource.cgi_escape : resource}#{query}"
+      request :delete, resource
     end
 
-    def bulk_document
-      @bulk_document ||= BulkDocument.new(database)
+    def view resource, opts
+      request :get, resource, query: values_to_json({include_docs: true}.merge!(opts))
     end
 
-    def bulk_save
-      bulk_document.save
+    def attach resource, attachment_name, data, headers = {}
+      request :put, "#{resource.cgi_escape}/#{attachment_name}", { _body: data }.merge(headers: headers)
     end
 
-    def database_name value
-      @@database_name ||= value
+    def uuids opts = {}
+      tools("_uuids", opts)[:uuids]
     end
 
-    def default_doc
-      "#{design_doc}/_view/find"
+    def stats
+      get("/#{db_name}")
     end
 
-    def design_doc
-      "_design/#{env["design"]}"
+    def tools path, opts = nil
+      request(:get, "/#{path}", opts)
     end
 
-    def next_id
-      namespace database.uuids.first
+    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
+      Oj.load(res.body_str, symbol_keys: true)
+    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

data/lib/dolly/document.rb

@@ -1,213 +1,63 @@
-require "dolly/query"
-require "dolly/property"
-require 'dolly/timestamps'
+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'
+require 'dolly/timestamp'
+require 'dolly/query_arguments'
+require 'dolly/document_creation'
+require 'dolly/class_methods_delegation'
+require 'refinements/string_refinements'
 
 module Dolly
   class Document
-    extend Dolly::Connection
-    include Dolly::Query
-    extend Dolly::Timestamps
+    extend Mango
+    extend Query
+    extend ViewQuery
+    extend Request
+    extend DepracatedDatabase
+    extend Properties
+    extend DocumentCreation
 
-    attr_accessor :rows, :doc, :key
-    class_attribute :properties
-    cattr_accessor :timestamps do
-      {}
-    end
+    include DocumentType
+    include PropertyManager
+    include Timestamp
+    include DocumentState
+    include IdentityProperties
+    include Attachment
+    include QueryArguments
+    include ClassMethodsDelegation
 
-    def initialize options = {}
-      @doc ||= {}
-      options = options.with_indifferent_access
-      init_properties options
-    end
+    attr_writer :doc
 
-    def persisted?
-      !doc['_rev'].blank?
+    def initialize(attributes = {})
+      init_ancestor_properties
+      properties.each(&build_property(attributes))
     end
 
-    def update_properties options = {}
-      raise InvalidProperty unless valid_properties?(options)
-      options.each do |property, value|
-        send(:"#{property}=", value)
-      end
-    end
-
-    def update_properties! options = {}
-      update_properties(options)
-      save
-    end
-
-    def reload
-      self.doc = self.class.find(id).doc
-    end
-
-    def id
-      doc['_id'] ||= self.class.next_id
-    end
-
-    def id= base_value
-      doc ||= {}
-      doc['_id'] = self.class.namespace(base_value)
-    end
-
-    def rev
-      doc['_rev']
-    end
-
-    def rev= value
-      doc['_rev'] = value
-    end
+    protected
 
-    def save options = {}
-      return false unless options[:validate] == false || valid?
-      self.doc['_id'] = self.id if self.id.present?
-      self.doc['_id'] = self.class.next_id if self.doc['_id'].blank?
-      set_created_at if timestamps[self.class.name]
-      set_updated_at if timestamps[self.class.name]
-      response = database.put(id_as_resource, self.doc.to_json)
-      obj = JSON::parse response.parsed_response
-      doc['_rev'] = obj['rev'] if obj['rev']
-      obj['ok']
-    end
-
-    def save!
-      raise DocumentInvalidError unless valid?
-      save
-    end
-
-    def destroy soft = false
-      #TODO: Add soft delete support
-      q = id_as_resource + "?rev=#{rev}"
-      response = database.delete(q)
-      JSON::parse response.parsed_response
-    end
-
-    def rows= col
-      raise Dolly::ResourceNotFound if col.empty?
-      col.each{ |r| @doc = r['doc'] }
-      _properties.each do |p|
-        #TODO: Refactor properties so it is not required
-        #to be a class property. But something that doesn't
-        #persist all the inheretence chain
-        next unless self.respond_to? :"#{p.name}="
-        self.send "#{p.name}=", doc[p.name]
-      end
-      @rows = col
-    end
-
-    def from_json string
-      parsed = JSON::parse( string )
-      self.rows = parsed['rows']
-      self
-    end
-
-    def database
-      self.class.database
-    end
-
-    def id_as_resource
-      CGI::escape id
-    end
-
-    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
-      database.attach id_as_resource, CGI.escape(file_name), body, { 'Content-Type' => mime_type }
-    end
-
-    def self.create options = {}
-      obj = new options
-      obj.save
-      obj
-    end
-
-    def self.property *ary
-      self.properties ||= {}
-      options           = ary.pop if ary.last.kind_of? Hash
-      options         ||= {}
-
-      ary.each do |name|
-        self.properties[name] = Property.new options.merge(name: name)
-        self.write_methods name
-      end
-    end
-
-    private
-    #TODO: create a PropertiesSet service object, to do all this
-    def self.write_methods name
-      property = properties[name]
-      define_method(name) { read_property name }
-      define_method("#{name}=") { |value| write_property name, value }
-      define_method(:"#{name}?") { send name } if property.boolean?
-      define_method("[]") {|n| send n.to_sym }
-    end
-
-    def write_property name, value
-      instance_variable_set(:"@#{name}", value)
-      @doc[name.to_s] = value
-    end
-
-    def read_property name
-      if instance_variable_get(:"@#{name}").nil?
-        write_property name, (doc[name.to_s] || self.properties[name].value)
-      end
-      instance_variable_get(:"@#{name}")
-    end
-
-    def _properties
-      self.properties.values
-    end
-
-    def init_properties options = {}
-      raise Dolly::ResourceNotFound if options['error'] == 'not_found'
-      options.each do |k, v|
-        next unless respond_to? :"#{k}="
-        send(:"#{k}=", v)
-      end
-      initialize_default_properties options if self.properties.present?
-      init_doc options
+    def doc
+      @doc ||= {}
     end
 
-    def initialize_default_properties options
-      _properties.reject { |property| options.keys.include? property.name }.each do |property|
-        property_value = property.default.clone unless Dolly::Property::CANT_CLONE.any? { |klass| property.default.is_a? klass }
-        property_value ||= property.default
-        self.doc[property.name] ||= property_value
+    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 init_doc options
-      self.doc ||= {}
-      #TODO: define what will be the preference _id or id
-      normalized_id = options[:_id] || options[:id]
-      self.doc['_id'] = self.class.namespace( normalized_id ) if normalized_id
-    end
-
-    def valid_properties?(options)
-      options.keys.any?{ |option| properties_include?(option.to_s) }
-    end
-
-    def properties_include? property
-      _properties.map(&:name).include? property
-    end
-
-    def valid?; true; end
   end
 end

data/lib/dolly/document_creation.rb

@@ -0,0 +1,20 @@
+require 'dolly/properties'
+
+module Dolly
+  module DocumentCreation
+    include Properties
+
+    def from_doc(doc)
+      attributes = property_clean_doc(doc)
+      new(attributes).tap { |model| model.doc = doc }
+    end
+
+    def from_json(json)
+      from_doc(Oj.load(json, symbol_keys: true))
+    end
+
+    def create(attributes)
+      new(attributes).tap { |model| model.save }
+    end
+  end
+end

data/lib/dolly/document_state.rb

@@ -0,0 +1,66 @@
+require 'dolly/class_methods_delegation'
+
+module Dolly
+  module DocumentState
+    include ClassMethodsDelegation
+
+    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
+
+    def save!
+      raise DocumentInvalidError unless valid?
+      save
+    end
+
+    def update_properties(properties)
+      properties.each(&update_attribute)
+    end
+
+    def update_properties!(properties)
+      update_properties(properties)
+      save!
+    end
+
+    def destroy is_hard = true
+      return connection.delete(id, rev) if is_hard
+      doc[:_deleted] = true
+      save
+    rescue Dolly::ResourceNotFound
+      nil
+    rescue Dolly::ServerError => error
+      raise error unless error.message =~ /conflict/
+      self.rev = self.class.safe_find(id)&.rev
+      return unless self.rev
+      destroy(is_hard)
+    end
+
+    def reload
+      reloaded_doc = self.class.find(id).send(:doc)
+      attributes   = property_clean_doc(reloaded_doc)
+
+      attributes.each(&update_attribute)
+    end
+
+    def persisted?
+      return false unless doc[:_rev]
+      !doc[:_rev].empty?
+    end
+
+    def to_h
+      doc
+    end
+
+    def valid?
+      true
+    end
+
+    def after_save(response)
+      self.rev = response[:rev]
+      response[:ok]
+    end
+  end
+end