dolly 1.1.7 → 3.1.1

data/lib/dolly/document.rb

@@ -1,217 +1,70 @@
-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 'dolly/framework_helper'
+require 'refinements/string_refinements'
 
 module Dolly
   class Document
-    extend Dolly::Connection
-    include Dolly::Query
-    extend Dolly::Timestamps
-
-    attr_accessor :rows, :doc, :key
-    class_attribute :properties
-    cattr_accessor :timestamps do
-      {}
-    end
-
-    def initialize options = {}
-      @doc ||= {}
-      options = options.with_indifferent_access
-      init_properties options
-    end
-
-    def persisted?
-      !doc['_rev'].blank?
-    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
-
-    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 hard = true
-      if hard
-        q = id_as_resource + "?rev=#{rev}"
-        response = database.delete(q)
-        JSON::parse response.parsed_response
-      else
-        self.doc['_deleted'] = true
-        self.save
-      end
-    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
+    extend Mango
+    extend Query
+    extend ViewQuery
+    extend Request
+    extend DepracatedDatabase
+    extend Properties
+    extend DocumentCreation
+
+    include DocumentType
+    include PropertyManager
+    include Timestamp
+    include DocumentState
+    include IdentityProperties
+    include Attachment
+    include QueryArguments
+    include ClassMethodsDelegation
+    include FrameworkHelper
+
+    attr_writer :doc
+
+    def initialize(attributes = {})
+      init_ancestor_properties
+      properties.each(&build_property(attributes))
+    end
+
+    protected
+
+    def 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
 
-    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
+    def doc_for_framework
+      return {} unless rails?
+      {}.with_indifferent_access
     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
-    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
-      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,27 @@
+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 do |model|
+        model.send(:doc).merge!(doc)
+      end
+    end
+
+    def from_json(json)
+      raw_data = Oj.load(json, symbol_keys: true)
+      data = rails? ? data.with_indifferent_access : raw_data
+      from_doc(data)
+    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

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/identity_properties.rb

@@ -0,0 +1,29 @@
+require 'dolly/document_type'
+require 'dolly/class_methods_delegation'
+
+module Dolly
+  module IdentityProperties
+    include DocumentType
+    include ClassMethodsDelegation
+
+    def id
+      doc[:_id] ||= namespace_key(connection.uuids.last)
+    end
+
+    def id= value
+      doc[:_id] = namespace_key(value)
+    end
+
+    def rev
+      doc[:_rev]
+    end
+
+    def rev= value
+      doc[:_rev] = value
+    end
+
+    def id_as_resource
+      CGI.escape(id)
+    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