couchbase-orm 1.1.1 → 2.0.0

data/lib/couchbase-orm/associations.rb

@@ -32,6 +32,8 @@ module CouchbaseOrm
                     val = if options[:polymorphic]
                         ::CouchbaseOrm.try_load(self.send(ref))
                     else
+                        raise CouchbaseOrm::StrictLoadingViolationError, "#{self.class} is marked as strict_loading and #{assoc} cannot be lazily loaded." if strict_loading?
+
                         assoc.constantize.find(self.send(ref), quiet: true)
                     end
                     instance_variable_set(instance_var, val)
@@ -55,11 +57,126 @@ module CouchbaseOrm
                 end
             end
 
+            def has_and_belongs_to_many(name, **options)
+                @associations ||= []
+                @associations << [name.to_sym, options[:dependent]]
+
+                ref = options[:foreign_key] || :"#{name.to_s.singularize}_ids"
+                ref_ass = :"#{ref}="
+                instance_var = :"@__assoc_#{name}"
+
+                # Class reference
+                assoc = (options[:class_name] || name.to_s.singularize.camelize).to_s
+
+                # Create the local setter / getter
+                attribute(ref) { |value|
+                    remove_instance_variable(instance_var) if instance_variable_defined?(instance_var)
+                    value
+                }
+
+                # Define reader
+                define_method(name) do
+                    return instance_variable_get(instance_var) if instance_variable_defined?(instance_var)
+                    ref_value = self.send(ref)
+                    ref_value = nil if ref_value.respond_to?(:empty?) && ref_value.empty?
+
+                    val = if options[:polymorphic]
+                        ::CouchbaseOrm.try_load(ref_value) if ref_value
+                    else
+                        raise CouchbaseOrm::StrictLoadingViolationError, "#{self.class} is marked as strict_loading and #{assoc} cannot be lazily loaded." if strict_loading?
+
+                        assoc.constantize.find(ref_value) if ref_value
+                    end
+                    val = Array.wrap(val || [])
+                    instance_variable_set(instance_var, val)
+                    val
+                end
+
+                # Define writer
+                attr_writer name
+                define_method(:"#{name}=") do |value|
+                    if value
+                        if !options[:polymorphic]
+                            klass = assoc.constantize
+                            value.each do |v|
+                                raise ArgumentError, "type mismatch on association: #{klass.design_document} != #{v.class.design_document}" if klass.design_document != v.class.design_document
+                            end
+                        end
+                        self.send(ref_ass, value.map(&:id))
+                    else
+                        self.send(ref_ass, nil)
+                    end
+
+                    instance_variable_set(instance_var, value)
+                end
+
+                return unless options[:autosave]
+
+                save_method = :"autosave_associated_records_for_#{name}"
+
+                define_non_cyclic_method(save_method) do
+                    old, new = previous_changes[ref]
+                    adds = (new || []) - (old || [])
+                    subs = (old || []) - (new || [])
+                    update_has_and_belongs_to_many_reverse_association(assoc, adds, true, **options) if adds.any?
+                    update_has_and_belongs_to_many_reverse_association(assoc, subs, false, **options) if subs.any?
+                end
+
+                after_create save_method
+                after_update save_method
+            end
+
             def associations
                 @associations || []
             end
+
+            def define_non_cyclic_method(name, &block)
+                return if method_defined?(name)
+
+                define_method(name) do |*args|
+                    result = true; @_already_called ||= {}
+                    # Loop prevention for validation of associations
+                    unless @_already_called[name]
+                        begin
+                            @_already_called[name] = true
+                            result = instance_eval(&block)
+                        ensure
+                            @_already_called[name] = false
+                        end
+                    end
+                    result
+                end
+            end
         end
 
+        def update_has_and_belongs_to_many_reverse_association(assoc, keys, is_add, **options)
+            remote_method = options[:inverse_of] || self.class.to_s.pluralize.underscore.to_sym
+            return if keys.empty?
+
+            models = if options[:polymorphic]
+                      ::CouchbaseOrm.try_load(keys)
+                  else
+                      assoc.constantize.find(keys, quiet: true)
+                  end
+            models = Array.wrap(models)
+            models.each do |v|
+                next unless v.respond_to?(remote_method)
+
+                tab = v.__send__(remote_method) || []
+                index = tab.find_index(self)
+                if is_add && !index
+                    tab = tab.dup
+                    tab.push(self)
+                elsif !is_add && index
+                    tab = tab.dup
+                    tab.delete_at(index)
+                else
+                    next
+                end
+                v[remote_method] = tab
+                v.save!
+            end
+        end
 
         def destroy_associations!
             assoc = self.class.associations
@@ -72,6 +189,8 @@ module CouchbaseOrm
                     when :destroy, :delete
                         if model.respond_to?(:stream)
                             model.stream { |mod| mod.__send__(dependent) }
+                        elsif model.is_a?(Array) || model.is_a?(CouchbaseOrm::ResultsProxy)
+                            model.each { |m| m.__send__(dependent) }
                         else
                             model.__send__(dependent)
                         end

data/lib/couchbase-orm/base.rb

@@ -3,110 +3,198 @@
 
 require 'active_model'
 require 'active_support/hash_with_indifferent_access'
+require 'couchbase'
+require 'couchbase-orm/changeable'
+require 'couchbase-orm/inspectable'
 require 'couchbase-orm/error'
 require 'couchbase-orm/views'
+require 'couchbase-orm/n1ql'
 require 'couchbase-orm/persistence'
 require 'couchbase-orm/associations'
+require 'couchbase-orm/types'
+require 'couchbase-orm/relation'
+require 'couchbase-orm/proxies/bucket_proxy'
+require 'couchbase-orm/proxies/collection_proxy'
 require 'couchbase-orm/utilities/join'
 require 'couchbase-orm/utilities/enum'
 require 'couchbase-orm/utilities/index'
 require 'couchbase-orm/utilities/has_many'
 require 'couchbase-orm/utilities/ensure_unique'
-
+require 'couchbase-orm/utilities/query_helper'
+require 'couchbase-orm/utilities/ignored_properties'
+require 'couchbase-orm/json_transcoder'
+require 'couchbase-orm/timestamps'
+require 'couchbase-orm/active_record_compat'
+require 'couchbase-orm/strict_loading'
+require 'couchbase-orm/json_schema/validation'
+require 'couchbase-orm/utilities/properties_always_exists_in_document'
 
 module CouchbaseOrm
-    class Base
+    class Document
+        include Inspectable
         include ::ActiveModel::Model
         include ::ActiveModel::Dirty
+        include Changeable # override some methods from ActiveModel::Dirty (keep it included after)
+        include ::ActiveModel::Attributes
         include ::ActiveModel::Serializers::JSON
 
         include ::ActiveModel::Validations
         include ::ActiveModel::Validations::Callbacks
+
+        include ActiveRecordCompat
+        include StrictLoading
+        include Encrypt
+
+        extend Enum
+
         define_model_callbacks :initialize, :only => :after
-        define_model_callbacks :create, :destroy, :save, :update
 
+        Metadata = Struct.new(:cas)
+
+        class MismatchTypeError < RuntimeError; end
+
+        def initialize(model = nil, ignore_doc_type: false, **attributes)
+            CouchbaseOrm.logger.debug { "Initialize model #{model} with #{attributes.to_s.truncate(200)}" }
+            @__metadata__   = Metadata.new
+
+            super()
+
+            if model
+                case model
+                when Couchbase::Collection::GetResult
+                    doc = HashWithIndifferentAccess.new(model.content) || raise('empty response provided')
+                    type = doc.delete(:type)
+                    doc.delete(:id)
+
+                    if type && !ignore_doc_type && type.to_s != self.class.design_document
+                        raise CouchbaseOrm::Error::TypeMismatchError.new("document type mismatch, #{type} != #{self.class.design_document}", self)
+                    end
+
+                    self.id = attributes[:id] if attributes[:id].present?
+                    @__metadata__.cas = model.cas
+
+                    assign_attributes(decode_encrypted_attributes(doc))
+                when CouchbaseOrm::Base
+                    clear_changes_information
+                    super(model.attributes.except(:id, 'type'))
+                else
+                    clear_changes_information
+                    assign_attributes(decode_encrypted_attributes(**attributes.merge(Hash(model)).symbolize_keys))
+                end
+            else
+                clear_changes_information
+                super(attributes)
+            end
+
+            yield self if block_given?
+
+            init_strict_loading
+            run_callbacks :initialize
+        end
+
+        def [](key)
+            send(key)
+        end
+
+        def []=(key, value)
+            send(:"#{key}=", value)
+        end
+
+        protected
+
+        def serialized_attributes
+            encode_encrypted_attributes.map { |k, v|
+                [k, self.class.attribute_types[k].serialize(v)]
+            }.to_h
+        end
+    end
+
+    class NestedDocument < Document
+        def initialize(*args, **kwargs)
+            super
+            if respond_to?(:id) && id.nil?
+                assign_attributes(id: SecureRandom.hex)
+            end
+        end
+    end
+
+    class Base < Document
+        define_model_callbacks :create, :destroy, :save, :update
         include Persistence
+
         include Associations
         include Views
+        include QueryHelper
+        include N1ql
+        include Relation
+        include Timestamps
 
         extend Join
         extend Enum
         extend EnsureUnique
         extend HasMany
         extend Index
+        extend IgnoredProperties
+        extend JsonSchema::Validation
+        extend PropertiesAlwaysExistsInDocument
 
 
-        Metadata = Struct.new(:key, :cas)
+        class << self
 
+            def attribute(name, ...)
+                super
+                create_dirty_methods(name, name)
+                create_setters(name)
+            end
 
-        class << self
             def connect(**options)
-                @bucket = ::Libcouchbase::Bucket.new(**options)
+                @bucket = BucketProxy.new(::MTLibcouchbase::Bucket.new(**options))
             end
 
             def bucket=(bucket)
-                @bucket = bucket
+                @bucket = bucket.is_a?(BucketProxy) ? bucket : BucketProxy.new(bucket)
             end
 
             def bucket
-                @bucket ||= Connection.bucket
+                @bucket ||= BucketProxy.new(Connection.bucket)
             end
 
-            def uuid_generator
-                @uuid_generator ||= IdGenerator
+            def cluster
+                Connection.cluster
             end
 
-            def uuid_generator=(generator)
-                @uuid_generator = generator
+            def collection
+                CollectionProxy.new(bucket.default_collection)
             end
 
-            def attribute(*names, **options)
-                @attributes ||= {}
-                names.each do |name|
-                    name = name.to_sym
-
-                    @attributes[name] = options
-
-                    unless self.instance_methods.include?(name)
-                        define_method(name) do
-                            read_attribute(name)
-                        end
-                    end
-
-                    eq_meth = :"#{name}="
-                    unless self.instance_methods.include?(eq_meth)
-                        define_method(eq_meth) do |value|
-                            value = yield(value) if block_given?
-                            write_attribute(name, value)
-                        end
-                    end
-                end
+            def uuid_generator
+                @uuid_generator ||= IdGenerator
             end
 
-            def attributes
-                @attributes ||= {}
+            def uuid_generator=(generator)
+                @uuid_generator = generator
             end
 
-            def find(*ids, **options)
-                options[:extended] = true
-                options[:quiet] ||= false
+            def find(*ids, quiet: false, with_strict_loading: false)
+                CouchbaseOrm.logger.debug { "Base.find(l##{ids.length}) #{ids}" }
 
                 ids = ids.flatten.select { |id| id.present? }
                 if ids.empty?
-                    return nil if options[:quiet]
-                    raise Libcouchbase::Error::EmptyKey, 'no id(s) provided'
+                    raise CouchbaseOrm::Error::EmptyNotAllowed, 'no id(s) provided'
                 end
 
-                record = bucket.get(*ids, **options)
-                records = record.is_a?(Array) ? record : [record]
-                records.map! { |record|
-                    if record
-                        self.new(record)
-                    else
-                        false
-                    end
-                }
-                records.select! { |rec| rec }
+                transcoder = CouchbaseOrm::JsonTranscoder.new(ignored_properties: ignored_properties)
+                records = quiet ? collection.get_multi(ids, transcoder: transcoder) : collection.get_multi!(ids, transcoder: transcoder)
+                CouchbaseOrm.logger.debug { "Base.find found(#{records})" }
+                records = records.zip(ids).map { |record, id|
+                    next unless record
+                    next if record.error
+                    new(record, id: id).tap do |instance|
+                        if with_strict_loading
+                            instance.strict_loading!
+                        end
+                    end.tap(&:reset_object!)
+                }.compact
                 ids.length > 1 ? records : records[0]
             end
 
@@ -117,124 +205,18 @@ module CouchbaseOrm
             alias_method :[], :find_by_id
 
             def exists?(id)
-                !bucket.get(id, quiet: true).nil?
+                CouchbaseOrm.logger.debug { "Data - Exists? #{id}" }
+                collection.exists(id).exists
             end
             alias_method :has_key?, :exists?
         end
 
-
-        # Add support for libcouchbase response objects
-        def initialize(model = nil, ignore_doc_type: false, **attributes)
-            @__metadata__   = Metadata.new
-
-            # Assign default values
-            @__attributes__ = ::ActiveSupport::HashWithIndifferentAccess.new({type: self.class.design_document})
-            self.class.attributes.each do |key, options|
-                default = options[:default]
-                if default.respond_to?(:call)
-                    write_attribute key, default.call
-                else
-                    write_attribute key, default
-                end
-            end
-
-            if model
-                case model
-                when ::Libcouchbase::Response
-                    doc = model.value || raise('empty response provided')
-                    type = doc.delete(:type)
-                    doc.delete(:id)
-
-                    if type && !ignore_doc_type && type.to_s != self.class.design_document
-                        raise "document type mismatch, #{type} != #{self.class.design_document}"
-                    end
-
-                    @__metadata__.key = model.key
-                    @__metadata__.cas = model.cas
-
-                    # This ensures that defaults are applied
-                    @__attributes__.merge! doc
-                    clear_changes_information
-                when CouchbaseOrm::Base
-                    clear_changes_information
-                    attributes = model.attributes
-                    attributes.delete(:id)
-                    super(attributes)
-                else
-                    clear_changes_information
-                    super(attributes.merge(Hash(model)))
-                end
-            else
-                clear_changes_information
-                super(attributes)
-            end
-
-            yield self if block_given?
-
-            run_callbacks :initialize
-        end
-
-
-        # Document ID is a special case as it is not stored in the document
-        def id
-            @__metadata__.key || @id
-        end
-
         def id=(value)
-            raise 'ID cannot be changed' if @__metadata__.cas
+            raise RuntimeError, 'ID cannot be changed' if @__metadata__.cas && value
             attribute_will_change!(:id)
-            @id = value.to_s
-        end
-
-        def read_attribute(attr_name)
-            @__attributes__[attr_name]
-        end
-        alias_method :[], :read_attribute
-
-        def write_attribute(attr_name, value)
-            unless value.nil?
-                coerce = self.class.attributes[attr_name][:type]
-                value = Kernel.send(coerce.to_s, value) if coerce
-            end
-            attribute_will_change!(attr_name) unless @__attributes__[attr_name] == value
-            @__attributes__[attr_name] = value
-        end
-        alias_method :[]=, :write_attribute
-
-        #
-        # Add support for Serialization:
-        # http://guides.rubyonrails.org/active_model_basics.html#serialization
-        #
-
-        def attributes
-            copy = @__attributes__.merge({id: id})
-            copy.delete(:type)
-            copy
-        end
-
-        def attributes=(attributes)
-            attributes.each do |key, value|
-                setter = :"#{key}="
-                send(setter, value) if respond_to?(setter)
-            end
-        end
-
-        ID_LOOKUP = ['id', :id].freeze
-        def attribute(name)
-            return self.id if ID_LOOKUP.include?(name)
-            @__attributes__[name]
-        end
-        alias_method :read_attribute_for_serialization, :attribute
-        
-        def attribute=(name, value)
-            __send__(:"#{name}=", value)
+            _write_attribute("id", value)
         end
 
-
-        #
-        # Add support for comparisons
-        #
-
         # Public: Allows for access to ActiveModel functionality.
         #
         # Returns self.
@@ -267,12 +249,7 @@ module CouchbaseOrm
         #
         # Returns a boolean.
         def ==(other)
-            case other
-            when self.class
-                hash == other.hash
-            else
-                false
-            end
+            super || other.instance_of?(self.class) && !id.nil? && other.id == id
         end
     end
 end