better-ripple 1.0.0

data/lib/ripple/associations/embedded.rb

@@ -0,0 +1,35 @@
+require 'ripple/associations/proxy'
+require 'ripple/validations/associated_validator'
+
+module Ripple
+  module Associations
+    module Embedded
+
+      def initialize(*args)
+        super
+        lazy_load_validates_associated
+      end
+
+      protected
+
+      def lazy_load_validates_associated
+        return if @owner.class.validators_on(@reflection.name).any? {|v| Ripple::Validations::AssociatedValidator === v}
+        @owner.class.validates @reflection.name, :associated => true
+      end
+
+      def assign_references(docs)
+        Array.wrap(docs).each do |doc|
+          next unless doc.respond_to?(:_parent_document=)
+          doc._parent_document = owner
+        end
+      end
+
+      def instantiate_target(*args)
+        doc = super
+        assign_references(doc)
+        doc
+      end
+
+    end
+  end
+end

data/lib/ripple/associations/instantiators.rb

@@ -0,0 +1,26 @@
+require 'ripple/associations'
+
+module Ripple
+  module Associations
+    module Instantiators
+
+      def build(attrs={})
+        instantiate_target(:new, attrs)
+      end
+
+      def create(attrs={})
+        instantiate_target(:create, attrs)
+      end
+
+      def create!(attrs={})
+        instantiate_target(:create!, attrs)
+      end
+
+      protected
+      def instantiate_target
+        raise NotImplementedError
+      end
+
+    end
+  end
+end

data/lib/ripple/associations/linked.rb

@@ -0,0 +1,65 @@
+require 'ripple/associations'
+require 'set'
+
+module Ripple
+  module Associations
+    module Linked
+      def replace(value)
+        @reflection.verify_type!(value, @owner)
+        @owner.robject.links -= links
+        Array.wrap(value).compact.each do |doc|
+          @owner.robject.links << doc.to_link(@reflection.link_tag)
+        end
+        loaded
+        @keys = nil
+        @target = value
+      end
+
+      def replace_links(value)
+        @owner.robject.links -= links
+        Array(value).each do |link|
+          @owner.robject.links << link
+        end
+        reset
+      end
+
+      def keys
+        @keys ||= Set.new(links.map { |l| l.key })
+      end
+
+      def reset
+        super
+        @keys = nil
+      end
+
+      def include?(document)
+        return false unless document.respond_to?(:robject)
+
+        # TODO: when we allow polymorphic assocations, this will have to change
+        #       since @reflection.bucket_name will be '_' in that case.
+        return false unless document.robject.bucket.name == @reflection.bucket_name
+        keys.include?(document.key)
+      end
+
+      protected
+      def links
+        @owner.robject.links.select(&@reflection.link_filter)
+      end
+
+      def robjects
+        walk_result = begin
+          @owner.robject.walk(*Array(@reflection.link_spec)).first || []
+        rescue
+          []
+        end
+
+        # We can get more robject results that we have links when there is conflict,
+        # since link-walking returns the robjects for the union of all sibling links.
+        # Here, we filter out robjects that should not be included.
+        walk_result.select do |robject|
+          links.include?(robject.to_link(@reflection.link_tag))
+        end
+      end
+    end
+  end
+end

data/lib/ripple/associations/many.rb

@@ -0,0 +1,38 @@
+require 'ripple/associations'
+
+module Ripple
+  module Associations
+    module Many
+      include Instantiators
+
+      def to_ary
+        load_target
+        Array === target ? target.to_ary : Array.wrap(target)
+      end
+
+      def count
+        load_target
+        target.size
+      end
+
+      def reset
+        super
+        @target = []
+      end
+
+      def <<(value)
+        raise NotImplementedError
+      end
+
+      alias_method :push, :<<
+      alias_method :concat, :<<
+
+      protected
+      def instantiate_target(instantiator, attrs={})
+        doc = klass.send(instantiator, attrs)
+        self << doc
+        doc
+      end
+    end
+  end
+end

data/lib/ripple/associations/many_embedded_proxy.rb

@@ -0,0 +1,39 @@
+require 'ripple/associations/proxy'
+require 'ripple/associations/many'
+require 'ripple/associations/embedded'
+
+module Ripple
+  module Associations
+    class ManyEmbeddedProxy < Proxy
+      include Many
+      include Embedded
+
+      def <<(docs)
+        load_target
+        docs = Array.wrap(docs)
+        @reflection.verify_type!(docs, @owner)
+        assign_references(docs)
+        @target += docs
+        self
+      end
+
+      def replace(docs)
+        @reflection.verify_type!(docs, @owner)
+        @_docs = docs.map { |doc| attrs = doc.respond_to?(:attributes_for_persistence) ? doc.attributes_for_persistence : doc }
+        assign_references(docs)
+        reset
+        @_docs
+      end
+
+      protected
+      def find_target
+        (@_docs || []).map do |attrs|
+          klass.instantiate(attrs).tap do |doc|
+            assign_references(doc)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/ripple/associations/many_linked_proxy.rb

@@ -0,0 +1,66 @@
+require 'ripple/associations/proxy'
+require 'ripple/associations/many'
+require 'ripple/associations/linked'
+
+module Ripple
+  module Associations
+    class ManyLinkedProxy < Proxy
+      include Many
+      include Linked
+
+      def count
+        # avoid having to load all documents by using our keys set instead
+        keys.size
+      end
+
+      def <<(value)
+        if loaded?
+          new_target = @target.concat(Array.wrap(value))
+          replace new_target
+        else
+          @reflection.verify_type!([value], @owner)
+          @owner.robject.links << value.to_link(@reflection.link_tag)
+          appended_documents << value
+          @keys = nil
+        end
+
+        self
+      end
+
+      def delete(value)
+        load_target
+        @target.delete(value)
+        replace @target
+        self
+      end
+
+      def reset
+        @appended_documents = nil
+        super
+      end
+
+      def loaded_documents
+        (super + appended_documents).uniq
+      end
+
+      protected
+
+      def find_target
+        robjs = robjects
+
+        robjs.delete_if do |robj|
+          appended_documents.any? do |doc|
+            doc.key == robj.key &&
+            doc.class.bucket_name == robj.bucket.name
+          end
+        end
+
+        appended_documents + robjs.map {|robj| klass.send(:instantiate, robj) }
+      end
+
+      def appended_documents
+        @appended_documents ||= []
+      end
+    end
+  end
+end

data/lib/ripple/associations/many_reference_proxy.rb

@@ -0,0 +1,95 @@
+require 'ripple/associations/proxy'
+require 'ripple/associations/many'
+
+require 'set'
+
+module Ripple
+  module Associations
+    class ManyReferenceProxy < Proxy
+      include Many
+
+      def <<(value)
+        values = Array.wrap(value)
+        @reflection.verify_type!(values, @owner)
+
+        values.each {|v| assign_key(v) }
+        load_target
+        @target.merge values
+
+        self
+      end
+
+      def replace(value)
+        @reflection.verify_type!(value, @owner)
+        delete_all
+        Array.wrap(value).compact.each do |doc|
+          assign_key(doc)
+        end
+        loaded
+        @keys = nil
+        @target = Set.new(value)
+      end
+
+      def delete_all
+        load_target
+        @target.each do |e|
+          delete(e)
+        end
+      end
+
+      def delete(value)
+        load_target
+        assign_key(value, nil)
+        @target.delete(value)
+      end
+
+      def target
+        load_target
+        @target.to_a
+      end
+
+      def keys
+        @keys ||= Ripple.client.search(klass.bucket_name, "#{key_name}: #{@owner.key}")["response"]["docs"].inject(Set.new) do |set, search_document|
+          set << search_document["id"]
+        end
+      end
+
+      def reset
+        @keys = nil
+        super
+      end
+
+      def include?(document)
+        return false unless document.class.respond_to?(:bucket_name)
+
+        return false unless document.class.bucket_name == @reflection.bucket_name
+        keys.include?(document.key)
+      end
+
+      def count
+        if loaded?
+          @target.count
+        else
+          keys.count
+        end
+      end
+
+      protected
+      def find_target
+        Set.new(klass.find(keys.to_a))
+      end
+
+      def key_name
+        "#{@owner.class.name.underscore}_key"
+      end
+
+      def assign_key(target, key=@owner.key)
+        if target.new_record?
+          target.send("#{key_name}=", key)
+        else
+          target.update_attribute(key_name, key)
+        end
+      end
+    end
+  end
+end

data/lib/ripple/associations/many_stored_key_proxy.rb

@@ -0,0 +1,76 @@
+require 'ripple/associations/proxy'
+require 'ripple/associations/many'
+
+module Ripple
+  module Associations
+    class ManyStoredKeyProxy < Proxy
+      include Many
+
+      def count
+        keys.size
+      end
+
+      def <<(value)
+        @reflection.verify_type!([value], @owner)
+
+        raise "Unable to append if the document isn't first saved." if value.new_record?
+        load_target
+        @target << value
+        keys << value.key
+
+        self
+      end
+
+      def replace(value)
+        @reflection.verify_type!(value, @owner)
+
+        reset_owner_keys
+        value.each { |doc| self << doc }
+        @target = value
+        loaded
+      end
+
+      def delete(value)
+        keys.delete(value.key)
+        self
+      end
+
+      def keys
+        if @owner.send(keys_name).nil?
+          reset_owner_keys
+        end
+
+        @owner.send(keys_name)
+      end
+
+      def reset
+        super
+        self.owner_keys = @owner.robject.data ? @owner.robject.data[keys_name] : []
+      end
+
+      def include?(document)
+        return false unless document.respond_to?(:robject)
+        return false unless document.robject.bucket.name == @reflection.bucket_name
+        keys.include?(document.key)
+      end
+
+      def reset_owner_keys
+        self.owner_keys = []
+      end
+
+
+      protected
+      def find_target
+        klass.find(keys.to_a)
+      end
+
+      def keys_name
+        "#{@reflection.name.to_s.singularize}_keys"
+      end
+
+      def owner_keys=(new_keys)
+        @owner.send("#{keys_name}=", @owner.class.properties[keys_name].type.new(new_keys))
+      end
+    end
+  end
+end