couchbase-orm 0.0.1

data/lib/couchbase-orm/base.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+
+require 'active_model'
+require 'active_support/hash_with_indifferent_access'
+require 'couchbase-orm/error'
+require 'couchbase-orm/views'
+require 'couchbase-orm/persistence'
+require 'couchbase-orm/associations'
+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'
+
+
+module CouchbaseOrm
+    class Base
+        include ::ActiveModel::Model
+        include ::ActiveModel::Dirty
+        include ::ActiveModel::Serializers::JSON
+
+        extend  ::ActiveModel::Callbacks
+        define_model_callbacks :initialize, :only => :after
+        define_model_callbacks :create, :destroy, :save, :update
+
+        include Persistence
+        include Associations
+        include Views
+
+        extend Join
+        extend Enum
+        extend EnsureUnique
+        extend HasMany
+        extend Index
+
+
+        Metadata = Struct.new(:key, :cas)
+
+
+        class << self
+            def connect(**options)
+                @bucket = ::Libcouchbase::Bucket.new(**options)
+            end
+
+            def bucket=(bucket)
+                @bucket = bucket
+            end
+
+            def bucket
+                @bucket ||= Connection.bucket
+            end
+
+            at_exit do
+                # This will disconnect the database connection
+                @bucket = nil
+            end
+
+            def uuid_generator
+                @uuid_generator ||= IdGenerator
+            end
+
+            def uuid_generator=(generator)
+                @uuid_generator = generator
+            end
+
+            def attribute(*names, **options)
+                @attributes ||= {}
+                names.each do |name|
+                    name = name.to_sym
+
+                    @attributes[name] = options
+                    next if self.instance_methods.include?(name)
+
+                    define_method(name) do
+                        read_attribute(name)
+                    end
+
+                    define_method(:"#{name}=") do |value|
+                        value = yield(value) if block_given?
+                        write_attribute(name, value)
+                    end
+                end
+            end
+
+            def attributes
+                @attributes ||= {}
+            end
+
+            def find(*ids, **options)
+                options[:extended] = true
+                options[:quiet] ||= false
+
+                ids = ids.flatten
+                records = bucket.get(*ids, **options)
+
+                records = records.is_a?(Array) ? records : [records]
+                records.map! { |record|
+                    if record
+                        self.new(record)
+                    else
+                        false
+                    end
+                }
+                records.select! { |rec| rec }
+                ids.length > 1 ? records : records[0]
+            end
+
+            def find_by_id(*ids, **options)
+                options[:quiet] = true
+                find *ids, **options
+            end
+            alias_method :[], :find_by_id
+
+            def exists?(id)
+                !bucket.get(id, quiet: true).nil?
+            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)
+                    @__attributes__[key] = default.call
+                else
+                    @__attributes__[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
+                    super(**doc)
+                when CouchbaseOrm::Base
+                    attributes = model.attributes
+                    attributes.delete(:id)
+                    super(**attributes)
+                else
+                    super(**attributes.merge(Hash(model)))
+                end
+            else
+                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
+            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
+
+
+        #
+        # Add support for comparisons
+        #
+
+        # Public: Allows for access to ActiveModel functionality.
+        #
+        # Returns self.
+        def to_model
+            self
+        end
+
+        # Public: Hashes identifying properties of the instance
+        #
+        # Ruby normally hashes an object to be used in comparisons.  In our case
+        # we may have two techincally different objects referencing the same entity id.
+        #
+        # Returns a string representing the unique key.
+        def hash
+            "#{self.class.name}-#{self.id}-#{@__metadata__.cas}-#{@__attributes__.hash}".hash
+        end
+
+        # Public: Overrides eql? to use == in the comparison.
+        #
+        # other - Another object to compare to
+        #
+        # Returns a boolean.
+        def eql?(other)
+            self == other
+        end
+
+        # Public: Overrides == to compare via class and entity id.
+        #
+        # other - Another object to compare to
+        #
+        # Returns a boolean.
+        def ==(other)
+            hash == other.hash
+        end
+    end
+end

data/lib/couchbase-orm/connection.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require 'libcouchbase'
+
+module CouchbaseOrm
+    class Connection
+        @options = {}
+        class << self
+            attr_accessor :options
+        end
+
+        def self.bucket
+            @bucket ||= ::Libcouchbase::Bucket.new(**@options)
+        end
+
+        # This will disconnect the database connection,
+        # allowing the application to exit
+        at_exit do
+            @bucket = nil
+        end
+    end
+end

data/lib/couchbase-orm/error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+module CouchbaseOrm
+    class Error < ::StandardError
+        attr_reader :record
+        
+        def initialize(message = nil, record = nil)
+            @record = record
+            super(message)
+        end
+
+        class RecordInvalid < Error; end
+        class RecordExists < Error; end
+    end
+end

data/lib/couchbase-orm/id_generator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require 'radix/base'
+
+module CouchbaseOrm
+    class IdGenerator
+        # Using base 65 as a form of compression (reduced length of ID string)
+        # No escape characters are required to display these in a URL
+        B65 = ::Radix::Base.new(::Radix::BASE::B62 + ['-', '_', '~'])
+        B10 = ::Radix::Base.new(10)
+
+        # We don't really care about dates before this library was created
+        # This reduces the length of the ID significantly
+        Skip46Years = 1451649600  # 46.years.to_i
+
+        # Generate a unique, orderable, ID using minimal bytes
+        def self.next(model)
+            # We are unlikely to see a clash here
+            now = Time.now
+            time = (now.to_i - Skip46Years) * 1_000_000 + now.usec
+
+            # This makes it very very improbable that there will ever be an ID clash
+            # Distributed system safe!
+            prefix = time.to_s
+            tail = (rand(9999) + 1).to_s.rjust(4, '0')
+
+            "#{model.class.design_document}-#{Radix.convert("#{prefix}#{tail}", B10, B65)}"
+        end
+    end
+end

data/lib/couchbase-orm/persistence.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require 'active_model'
+require 'active_support/hash_with_indifferent_access'
+
+module CouchbaseOrm
+    module Persistence
+        extend ActiveSupport::Concern
+
+
+        module ClassMethods
+            def create(attributes = nil, &block)
+                if attributes.is_a?(Array)
+                    attributes.collect { |attr| create(attr, &block) }
+                else
+                    instance = new(attributes, &block)
+                    instance.save
+                    instance
+                end
+            end
+
+            def create!(attributes = nil, &block)
+                if attributes.is_a?(Array)
+                    attributes.collect { |attr| create!(attr, &block) }
+                else
+                    instance = new(attributes, &block)
+                    instance.save!
+                    instance
+                end
+            end
+
+            # Raise an error if validation failed.
+            def fail_validate!(document)
+                raise Error::RecordInvalid.new("Failed to save the record", document)
+            end
+
+            # Allow classes to overwrite the default document name
+            # extend ActiveModel::Naming (included by ActiveModel::Model)
+            def design_document(name = nil)
+                return @design_document unless name
+                @design_document = name.to_s
+            end
+
+            # Set a default design document
+            def inherited(child)
+                super
+                child.instance_eval do
+                    @design_document = child.name.underscore
+                end
+            end
+        end
+
+
+        # Returns true if this object hasn't been saved yet -- that is, a record
+        # for the object doesn't exist in the database yet; otherwise, returns false.
+        def new_record?
+            @__metadata__.cas.nil? && @__metadata__.key.nil?
+        end
+        alias_method :new?, :new_record?
+
+        # Returns true if this object has been destroyed, otherwise returns false.
+        def destroyed?
+            !!(@__metadata__.cas && @__metadata__.key.nil?)
+        end
+
+        # Returns true if the record is persisted, i.e. it's not a new record and it was
+        # not destroyed, otherwise returns false.
+        def persisted?
+            # Changed? is provided by ActiveModel::Dirty
+            !!@__metadata__.key
+        end
+        alias_method :exists?, :persisted?
+
+        # Saves the model.
+        #
+        # If the model is new, a record gets created in the database, otherwise
+        # the existing record gets updated.
+        def save(**options)
+            raise "Cannot save a destroyed document!" if destroyed?
+            self.new_record? ? _create_record(**options) : _update_record(**options)
+        end
+
+        # Saves the model.
+        #
+        # If the model is new, a record gets created in the database, otherwise
+        # the existing record gets updated.
+        #
+        # By default, #save! always runs validations. If any of them fail
+        # CouchbaseOrm::Error::RecordInvalid gets raised, and the record won't be saved.
+        def save!
+            self.class.fail_validate!(self) unless self.save
+            self
+        end
+
+        # Deletes the record in the database and freezes this instance to
+        # reflect that no changes should be made (since they can't be
+        # persisted). Returns the frozen instance.
+        #
+        # The record is simply removed, no callbacks are executed.
+        def delete(with_cas: false, **options)
+            options[:cas] = @__metadata__.cas if with_cas
+            self.class.bucket.delete(@__metadata__.key, options)
+
+            @__metadata__.key = nil
+            @id = nil
+
+            clear_changes_information
+            self.freeze
+            self
+        end
+
+        # Deletes the record in the database and freezes this instance to reflect
+        # that no changes should be made (since they can't be persisted).
+        #
+        # There's a series of callbacks associated with #destroy.
+        def destroy(with_cas: false, **options)
+            return self if destroyed?
+            raise 'model not persisted' unless persisted?
+
+            run_callbacks :destroy do
+                destroy_associations!
+
+                options[:cas] = @__metadata__.cas if with_cas
+                self.class.bucket.delete(@__metadata__.key, options)
+
+                @__metadata__.key = nil
+                @id = nil
+
+                clear_changes_information
+                freeze
+            end
+        end
+        alias_method :destroy!, :destroy
+
+        # Updates a single attribute and saves the record.
+        # This is especially useful for boolean flags on existing records. Also note that
+        #
+        # * Validation is skipped.
+        # * \Callbacks are invoked.
+        def update_attribute(name, value)
+            public_send(:"#{name}=", value)
+            changed? ? save(validate: false) : true
+        end
+        
+        # Updates the attributes of the model from the passed-in hash and saves the
+        # record. If the object is invalid, the saving will fail and false will be returned.
+        def update(hash)
+            assign_attributes(hash)
+            save
+        end
+        alias_method :update_attributes, :update
+
+        # Updates its receiver just like #update but calls #save! instead
+        # of +save+, so an exception is raised if the record is invalid and saving will fail.
+        def update!(hash)
+            assign_attributes(hash) # Assign attributes is provided by ActiveModel::AttributeAssignment
+            save!
+        end
+        alias_method :update_attributes!, :update!
+
+        # Reloads the record from the database.
+        #
+        # This method finds record by its key and modifies the receiver in-place:
+        def reload
+            key = @__metadata__.key
+            raise "unable to reload, model not persisted" unless key
+
+            resp = self.class.bucket.get(key, quiet: false, extended: true)
+            @__attributes__ = ::ActiveSupport::HashWithIndifferentAccess.new(resp.value)
+            @__metadata__.key = resp.key
+            @__metadata__.cas = resp.cas
+
+            reset_associations
+            clear_changes_information
+            self
+        end
+
+        # Updates the TTL of the document
+        def touch(**options)
+            res = self.class.bucket.touch(@__metadata__.key, async: false, **options)
+            @__metadata__.cas = resp.cas
+            self
+        end
+
+
+        protected
+
+
+        def _update_record(with_cas: false, **options)
+            return false unless perform_validations(options)
+            return true unless changed?
+
+            run_callbacks :update do
+                run_callbacks :save do
+                    # Ensure the type is set
+                    @__attributes__[:type] = self.class.design_document
+                    @__attributes__.delete(:id)
+
+                    _id = @__metadata__.key
+                    options[:cas] = @__metadata__.cas if with_cas
+                    resp = self.class.bucket.replace(_id, @__attributes__, **options)
+
+                    # Ensure the model is up to date
+                    @__metadata__.key = resp.key
+                    @__metadata__.cas = resp.cas
+
+                    clear_changes_information
+                    true
+                end
+            end
+        end
+
+        def _create_record(**options)
+            return false unless perform_validations(options)
+
+            run_callbacks :create do
+                run_callbacks :save do
+                    # Ensure the type is set
+                    @__attributes__[:type] = self.class.design_document
+                    @__attributes__.delete(:id)
+
+                    _id = @id || self.class.uuid_generator.next(self)
+                    resp = self.class.bucket.add(_id, @__attributes__, **options)
+
+                    # Ensure the model is up to date
+                    @__metadata__.key = resp.key
+                    @__metadata__.cas = resp.cas
+
+                    clear_changes_information
+                    true
+                end
+            end
+        end
+
+        def perform_validations(options = {})
+            return valid? if options[:validate] != false
+            true
+        end
+    end
+end