dolly 1.1.4 → 3.0.1

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

data/lib/dolly/document_type.rb

@@ -0,0 +1,47 @@
+require 'refinements/string_refinements'
+
+module Dolly
+  module DocumentType
+    using StringRefinements
+
+    def namespace_keys(keys)
+      keys.map { |key| namespace_key key }
+    end
+
+    def namespace_key(key)
+      return key if key =~ %r{^#{name_paramitized}/}
+      "#{name_paramitized}/#{key}"
+    end
+
+    def base_id
+      self.id.sub(%r{^#{name_paramitized}/}, '')
+    end
+
+    def name_paramitized
+      class_name.split("::").last.underscore
+    end
+
+    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

@@ -0,0 +1,32 @@
+module Dolly
+  class ResourceNotFound < RuntimeError
+    def to_s
+      'The document was not found.'
+    end
+  end
+
+  class ServerError < RuntimeError
+    def initialize msg
+      @msg = msg
+    end
+
+    def to_s
+      "There has been an error on the couchdb server: #{@msg.inspect}"
+    end
+  end
+
+  class InvalidMangoOperatorError < RuntimeError
+    def initialize msg
+      @msg = msg
+    end
+
+    def to_s
+      "Invalid Mango operator: #{@msg.inspect}"
+    end
+  end
+
+  class IndexNotFoundError < RuntimeError; end
+  class InvalidConfigFileError < RuntimeError; end
+  class InvalidProperty < RuntimeError; end
+  class DocumentInvalidError < RuntimeError; end
+end