couchbase-model-relationship 0.1

data/lib/couchbase/model/relationship/child.rb

@@ -0,0 +1,25 @@
+module Couchbase
+  class Model
+    module Relationship
+      module Child
+        extend ::ActiveSupport::Concern
+
+        def create_with_parent_id(options = {})
+          if id.blank? && parent.present?
+            @id = prefixed_id(parent.id)
+          end
+
+          create_without_parent_id(options)
+        end
+
+        module ClassMethods
+          def has_parent
+            attr_accessor :parent
+
+            alias_method_chain :create, :parent_id
+          end
+        end
+      end
+    end
+  end
+end

data/lib/couchbase/model/relationship/parent.rb

@@ -0,0 +1,193 @@
+# All this behavior assumes the same bucket/connection options are used for the 
+# root object and all children.
+#
+# TODO Transparent child load if object not present (cache missing objects to reduce queries)
+# TODO Support for "required" children (if missing, error) ?
+# TODO Use multi-set to batch save parent + children
+module Couchbase
+  class Model
+    module Relationship
+      module Parent
+        extend ::ActiveSupport::Concern
+        
+        included do
+          alias_method_chain :save, :autosave_children
+          alias_method_chain :delete, :autodelete_children
+        end
+
+        # TODO How to handle failures saving children?
+        def save_with_children(options = {})
+          save(options).tap do |result|
+            if result
+              children.each do |child|
+                child.save_if_changed(options)
+              end
+            end
+          end
+        end
+
+        def save_with_autosave_children(options = {})
+          # Don't save if we failed
+          save_without_autosave_children(options).tap do |result|
+            if result
+              self.class.child_associations.select(&:auto_save).each do |association|
+                association.fetch(self).try :save_if_changed, options
+              end
+            end
+          end
+        end
+
+        def delete_with_autodelete_children(options = {})
+          self.class.child_associations.select(&:auto_delete).each do |association|
+            association.fetch(self).try :delete, options
+          end
+
+          delete_without_autodelete_children(options)
+        end
+
+        # FIXME #changed? should include children if any are autosave
+
+        def delete_with_children(options = {})
+          children.each {|child| child.delete options }
+
+          delete(options)
+        end
+
+        def children
+          self.class.child_associations.map do |association|
+            association.fetch self
+          end.compact
+        end
+
+        def reload_all
+          children.each(&:reload)
+          reload
+        end
+
+        module ClassMethods
+          def child(name, options = {})
+            # TODO This may get the full module path for a relationship name,
+            # and that will make the keys very long. Is this necessary? see: AR STI
+            name = name.to_s.underscore unless name.is_a?(String)
+
+            (@_children ||= []).push Relationship::Association.new(name, options)
+
+            define_method("#{name}=") do |object|
+              # FIXME Sanity check. If parent and parent != self, error
+              object.parent = self if object.respond_to?(:parent)
+
+              instance_variable_set :"@_child_#{name}", object
+            end
+
+            define_method("#{name}_loaded?") do
+              instance_variable_get("@_child_#{name}_loaded")
+            end
+
+            define_method("#{name}_loaded!") do
+              instance_variable_set("@_child_#{name}_loaded", true)
+            end
+            protected "#{name}_loaded!".to_sym
+
+            define_method("#{name}") do
+              # DO NOT USE Association#fetch IN THIS METHOD
+              base_var_name = "@_child_#{name}"
+
+              if (existing = instance_variable_get(base_var_name)).present?
+                existing
+              else
+                if send("#{name}_loaded?")
+                  send("build_#{name}")
+                else
+                  assoc = self.class.child_association_for(name)
+                  send("#{name}_loaded!")
+
+                  if (unloaded = assoc.load(self)).present?
+                    send("#{name}=", unloaded)
+                  end
+
+                  send(name)
+                end
+              end
+            end
+
+            define_method("build_#{name}") do |attributes = {}|
+              assoc = self.class.child_association_for(name)
+              send("#{name}=", assoc.child_class.new(attributes)).tap do |child|
+                child.parent = self
+              end
+            end
+          end
+
+          def children(*names)
+            options = names.extract_options!
+
+            names.each {|name| child name, options }
+          end
+
+          def child_association_names
+            children.map(&:name)
+          end
+
+          def child_associations
+            @_children || []
+          end
+
+          def child_association_for(name)
+            @_children.detect {|association| association.name == name.to_s }
+          end
+
+          def find_with_children(id, *children)
+            find_all_with_children(id, *children).first
+          end
+
+          # FIXME This is a horrible abortion of a method
+          def find_all_with_children(ids, *children)
+            ids = Array(ids)
+
+            effective_children = if children.blank?
+              @_children.select {|child| child.auto_load }
+            else
+              children = children.map(&:to_s)
+              @_children.select {|child| children.include?(child.name) }
+            end
+            
+            search_ids = ids.dup
+            ids.each do |id|
+              search_ids.concat(effective_children.map do |child| 
+                child.child_class.prefixed_id(id)
+              end)
+            end
+
+            results = bucket.get(search_ids, quiet: true, extended: true)
+
+            parent_objects = ids.map do |id|
+              if results.key?(id)
+                raw_new(id, results.delete(id))
+              else
+                raise Couchbase::Error::NotFound.new("failed to get value (key=\"#{id}\"")
+              end
+            end
+
+            parent_objects.each do |parent|
+              results.each do |child_id, child_attributes|
+                if unprefixed_id(parent.id) == unprefixed_id(child_id) 
+                  assoc = effective_children.detect {|assoc| assoc.prefix == prefix_from_id(child_id) }
+                  parent.send "#{assoc.name}=", 
+                    assoc.child_class.raw_new(child_id, child_attributes)
+                end
+              end
+
+              effective_children.each {|assoc| parent.send("#{assoc.name}_loaded!") }
+            end
+          end
+
+          def raw_new(id, results)
+            obj, flags, cas = results
+            obj = {:raw => obj} unless obj.is_a?(Hash)
+            new({:id => id, :meta => {'flags' => flags, 'cas' => cas}}.merge(obj))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/couchbase/model/relationship/version.rb

@@ -0,0 +1,7 @@
+module Couchbase
+  class Model
+    module Relationship
+      VERSION = "0.1"
+    end
+  end
+end

data/spec/association_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe "associations" do
+  subject { ::Couchbase::Model::Relationship::Association }
+
+  it "sets the name" do
+    subject.new('abc').name.should eq('abc')
+  end
+
+  it "sets autosave properly" do
+    subject.new('abc', auto_save: true).auto_save.should be_true
+    subject.new('abc').auto_save.should be_false
+  end
+
+  it "sets autodelete properly" do
+    subject.new('abc', auto_delete: true).auto_delete.should be_true
+    subject.new('abc').auto_delete.should be_false
+  end
+
+  it "uses the provide class name" do
+    subject.new('abc', class_name: "String").child_klass.should eq('String')
+  end
+
+  it "fetches the object from the parent" do
+    parent = stub(abc: :object)
+
+    subject.new("abc").fetch(parent).should eq(:object)
+  end
+
+  it "loads the object from the database" do
+    child_class = stub_klass(Couchbase::Model)
+    child_class.expects(:prefixed_id).with('core/user:abc123').returns(:id)
+    child_class.expects(:find_by_id).with(:id).returns(:child)
+
+    parent = stub(id: "core/user:abc123")
+    instance = subject.new("string")
+    instance.stubs(child_class: child_class)
+
+    instance.load(parent).should eq(:child)
+  end
+
+  it "knows the child class name" do
+    subject.new("string").child_klass.should eq("String")
+  end
+  
+  it "knows the child class" do
+    subject.new("string").child_class.should eq(String)
+  end
+end

data/spec/attributes_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+require 'couchbase/model'
+require 'couchbase/model/attributes'
+
+describe "Attributes" do
+  let(:klass) do
+    Class.new(Couchbase::Model) do
+
+      attribute :abc
+    end
+  end
+  
+  subject { klass.new }
+
+  it "should have a setter" do
+    subject.should respond_to(:abc=)
+  end
+
+  it "should have a getter" do
+    subject.should respond_to(:abc)
+  end
+
+  it "should set the variable" do
+    subject.abc = 1
+    subject.read_attribute('abc').should eq(1)
+  end
+
+  it "should read the variable" do
+    subject.write_attribute("abc", 1)
+    subject.abc.should eq(1)
+  end
+end

data/spec/child_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+class ChildTest < Couchbase::Model
+  has_parent
+end
+
+class ChildTestParent < Couchbase::Model
+  child :child_test
+end
+
+describe "children" do
+  let(:parent) { ChildTestParent.new }
+  subject { ChildTest.new }
+
+  it "allows you to set the parent" do
+    subject.should respond_to(:parent=)
+
+    subject.parent = parent
+    subject.parent.should eq(parent)
+  end
+
+  describe "creating" do
+    it "inherits the UUID of the parent" do
+      parent.id = "child_test_parent:1234"
+      ChildTest.stubs(bucket: stub(add: true))
+
+      subject.parent = parent
+      subject.create
+
+      subject.id.should eq("child_test:1234")
+    end
+  end
+end

data/spec/complex_attributes_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+class ComplexTest < Couchbase::Model
+  class Child
+    attr_accessor :name
+
+    def self.json_create(args)
+      new(*args['parameters'])
+    end
+
+    def initialize(name)
+      self.name = name
+    end
+
+    def to_json(*args)
+      {
+        'json_class' => self.class.name,
+        'parameters' => [name]
+      }.to_json(*args)
+    end
+  end
+
+  array_attribute :array, class_name: ComplexTest::Child.name
+end
+
+describe "complex attributes" do
+  describe "array attributes" do
+    subject { ComplexTest.new }
+
+    let(:raw) do
+      {
+        'json_class' => 'ComplexTest::Child',
+        'parameters' => ['abc']
+      }.to_json
+    end
+
+    let(:object) { ComplexTest::Child.new('exist') }
+
+    it "sets values properly" do
+      subject.array = [raw, object]
+      subject.array.all? {|c| ComplexTest::Child === c }.should be_true
+
+      subject.array.map(&:name).should eq(%w(abc exist))
+    end
+  
+    it "knows what class it stores" do
+      ComplexTest.array_attribute_class(:array).should eq("ComplexTest::Child") 
+    end
+
+    it "defaults to an array" do
+      ComplexTest.new.array.should be_a(Array)
+    end
+  end
+end

data/spec/deep_copier_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Couchbase::Model::DeepCopier do
+  it "hands uncloneable objects" do
+    source = 1
+    copy = described_class.new(source).copy
+
+    source.should eq(1)
+    copy.should eq(1)
+  end
+  it "properly clones a normal object" do
+    source = "abc"
+    copy = described_class.new(source).copy
+
+    source.should eq(copy)
+    source.object_id.should_not eq(copy.object_id)
+  end
+
+  it "properly clones an array" do
+    source = []
+    copy = described_class.new(source).copy
+    source.push :a
+
+    source.should_not eq(copy)
+    copy.should eq([])
+  end
+
+  it "properly clones nested arrays" do
+    source = [[]]
+    copy = described_class.new(source).copy
+    source.last.push :a
+
+    source.should_not eq(copy)
+    copy.should eq([[]])
+  end
+
+  it "properly clones a hash" do
+    source = {}
+    copy = described_class.new(source).copy
+    source[:key] = :val
+
+    source.should_not eq(copy)
+    copy.should eq({})
+  end
+
+  it "properly clones a nested hash" do
+    source = {key: []}
+    copy = described_class.new(source).copy
+
+    source[:key1] = 'a'
+    source[:key].push 'b'
+
+    source.should_not eq(copy)
+    copy.should eq({key: []})
+  end
+end