cfoundry 1.3.0 → 1.4.0

data/lib/cfoundry/v2/model_magic.rb

@@ -190,11 +190,7 @@ module CFoundry::V2
     def to_one(name, opts = {})
       to_one_relations[name] = opts
 
-      obj = opts[:as] || name
-      kls = obj.to_s.capitalize.gsub(/(.)_(.)/) do
-        $1 + $2.upcase
-      end
-
+      association_name = opts[:as] || name
       default = opts[:default]
 
       if has_default = opts.key?(:default)
@@ -207,40 +203,53 @@ module CFoundry::V2
 
         @cache[name] =
           if @manifest && @manifest[:entity].key?(name)
-            @client.send(:"make_#{obj}", @manifest[:entity][name])
+            @client.send(:"make_#{association_name}", @manifest[:entity][name])
           elsif url = send("#{name}_url")
-            @client.send(:"#{obj}_from", url)
+            @client.send(:"#{association_name}_from", url)
           else
             default
           end
       end
 
+      define_method("create_#{name}") do |*args|
+        associated_instance = @client.send(:"#{association_name}")
+        args.first.each do |name, value|
+          associated_instance.send("#{name}=", value)
+        end if args.first.is_a? Hash
+
+        associated_instance.create!
+        self.send("#{name}=", associated_instance)
+      end
+
       define_method(:"#{name}_url") do
         manifest[:entity][:"#{name}_url"]
       end
 
-      define_method(:"#{name}=") do |val|
-        klass = self.class.objects[obj]
+      define_method(:"#{name}=") do |assigned_value|
+        klass = self.class.objects[association_name]
 
-        unless has_default && val == default
-          CFoundry::Validator.validate_type(val, klass)
+        unless has_default && assigned_value == default
+          CFoundry::Validator.validate_type(assigned_value, klass)
         end
 
         @manifest ||= {}
         @manifest[:entity] ||= {}
 
-        old = @manifest[:entity][:"#{name}_guid"]
-        if old != (val && val.guid)
+        old_guid = @manifest[:entity][:"#{name}_guid"]
+        association_guid = assigned_value ? assigned_value.guid : nil
+
+        if old_guid != (association_guid)
           old_obj =
-            @cache[name] || klass.new(@client, old, @manifest[:entity][name])
+            @cache[name] || klass.new(@client, old_guid, @manifest[:entity][name])
 
-          @changes[name] = [old_obj, val]
+          @changes[name] = [old_obj, assigned_value]
         end
 
-        @cache[name] = val
+        @cache[name] = assigned_value
 
-        @manifest[:entity][:"#{name}_guid"] =
-          @diff[:"#{name}_guid"] = val && val.guid
+        @manifest[:entity][:"#{name}_guid"] = association_guid
+        @diff[:"#{name}_guid"] = association_guid
+        assigned_value
       end
     end
 
@@ -253,9 +262,7 @@ module CFoundry::V2
 
       object = opts[:as] || singular
 
-      kls = object.to_s.capitalize.gsub(/(.)_(.)/) do
-        $1 + $2.upcase
-      end
+      kls = object.to_s.camelcase
 
       define_method(plural) do |*args|
         klass = CFoundry::V2.const_get(kls)

data/lib/cfoundry/version.rb

@@ -1,4 +1,4 @@
 module CFoundry # :nodoc:
   # CFoundry library version number.
-  VERSION = "1.3.0".freeze
+  VERSION = "1.4.0".freeze
 end

data/spec/cfoundry/v2/model_magic_spec.rb

@@ -1,172 +1,217 @@
 require "spec_helper"
 
-describe CFoundry::V2::ModelMagic do
-  let(:client) { fake_client }
-  let(:mymodel) { fake_model }
-  let(:guid) { random_string("my-object-guid") }
-  let(:myobject) { mymodel.new(guid, client) }
+module CFoundry::V2
+  class Associated < FakeModel
+    attribute :attribute, String
+  end
+
+  describe ModelMagic do
+    let(:client) { fake_client }
+    let(:mymodel) { fake_model }
+    let(:guid) { random_string("my-object-guid") }
+    let(:myobject) { mymodel.new(guid, client) }
 
-  describe 'attributes' do
-    describe 'reading' do
-      let(:mymodel) { fake_model { attribute :foo, :object } }
+    describe 'attributes' do
+      describe 'reading' do
+        let(:mymodel) { fake_model { attribute :foo, :object } }
 
-      context 'when it exists in the manifest' do
-        subject { myobject.fake(:foo => "bar") }
+        context 'when it exists in the manifest' do
+          subject { myobject.fake(:foo => "bar") }
+
+          it 'returns the value from the manifest' do
+            expect(subject.foo).to eq "bar"
+          end
 
-        it 'returns the value from the manifest' do
-          expect(subject.foo).to eq "bar"
+          context 'and the default is nil but the value is false' do
+            let(:mymodel) {
+              fake_model { attribute :foo, :object, :default => nil }
+            }
+
+            subject { myobject.fake(:foo => false) }
+
+            it 'returns false' do
+              expect(subject.foo).to eq false
+            end
+          end
+
+          context 'and the default is false but the value is nil' do
+            let(:mymodel) {
+              fake_model { attribute :foo, :object, :default => false }
+            }
+
+            subject { myobject.fake(:foo => nil) }
+
+            it 'returns nil' do
+              expect(subject.foo).to eq nil
+            end
+          end
         end
 
-        context 'and the default is nil but the value is false' do
-          let(:mymodel) {
-            fake_model { attribute :foo, :object, :default => nil }
-          }
+        context 'when the manifest has not been acquired' do
+          it 'retrieves the manifest the first time' do
+            mock(client.base).my_fake_model(guid) {
+              {:entity => {:foo => "fizz"}}
+            }.ordered
 
-          subject { myobject.fake(:foo => false) }
+            expect(myobject.foo).to eq "fizz"
 
-          it 'returns false' do
-            expect(subject.foo).to eq false
+            dont_allow(client.base).my_fake_model.ordered
+
+            expect(myobject.foo).to eq "fizz"
           end
         end
 
-        context 'and the default is false but the value is nil' do
+        context 'when it does not exist in the manifest' do
           let(:mymodel) {
-            fake_model { attribute :foo, :object, :default => false }
+            fake_model { attribute :foo, :object, :default => "foo" }
           }
 
-          subject { myobject.fake(:foo => nil) }
+          subject { myobject.fake }
 
-          it 'returns nil' do
-            expect(subject.foo).to eq nil
+          it 'returns the default value' do
+            expect(subject.foo).to eq "foo"
           end
         end
-      end
 
-      context 'when the manifest has not been acquired' do
-        it 'retrieves the manifest the first time' do
-          mock(client.base).my_fake_model(guid) {
-            { :entity => { :foo => "fizz" } }
-          }.ordered
+        context 'when the attribute has a custom json key' do
+          let(:mymodel) {
+            fake_model { attribute :foo, :object, :at => :not_foo }
+          }
 
-          expect(myobject.foo).to eq "fizz"
+          subject { myobject.fake }
 
-          dont_allow(client.base).my_fake_model.ordered
+          it 'retrieves the attribute using the custom key' do
+            stub(client.base).my_fake_model(guid) {
+              {:entity => {:not_foo => "fizz"}}
+            }
 
-          expect(myobject.foo).to eq "fizz"
+            expect(myobject.foo).to eq "fizz"
+          end
         end
       end
 
-      context 'when it does not exist in the manifest' do
-        let(:mymodel) {
-          fake_model { attribute :foo, :object, :default => "foo" }
-        }
+      describe 'writing' do
+        context 'when the attribute has a custom json key' do
+          let(:mymodel) {
+            fake_model { attribute :foo, :object, :at => :not_foo }
+          }
 
-        subject { myobject.fake }
+          subject { myobject }
 
-        it 'returns the default value' do
-          expect(subject.foo).to eq "foo"
-        end
-      end
+          it "uses the 'at' value in the update payload" do
+            mock(client.base).put("v2", :my_fake_models, subject.guid, hash_including(:payload => {:not_foo => 123}))
+            subject.foo = 123
+            subject.update!
+          end
 
-      context 'when the attribute has a custom json key' do
-        let(:mymodel) {
-          fake_model { attribute :foo, :object, :at => :not_foo }
-        }
+          it "uses the 'at' value in the create payload" do
+            subject.foo = 123
 
-        subject { myobject.fake }
+            mock(client.base).post(
+              "v2", :my_fake_models,
+              hash_including(:payload => {:not_foo => 123})
+            ) { {:metadata => {}} }
 
-        it 'retrieves the attribute using the custom key' do
-          stub(client.base).my_fake_model(guid) {
-            { :entity => { :not_foo => "fizz" } }
-          }
+            subject.create!
+          end
 
-          expect(myobject.foo).to eq "fizz"
+          it "is then readable via the attribute name" do
+            subject.foo = 123
+            expect(subject.foo).to eq 123
+          end
         end
       end
     end
 
-    describe 'writing' do
-      context 'when the attribute has a custom json key' do
-        let(:mymodel) {
-          fake_model { attribute :foo, :object, :at => :not_foo }
-        }
+    describe 'to_one relationships' do
+      describe 'writing' do
+        let!(:mymodel) { fake_model { to_one :foo } }
+        let!(:othermodel) { fake_model :foo }
 
-        subject { myobject }
+        let(:myobject) { mymodel.new(nil, client).fake }
+        let(:otherobject) { othermodel.new(nil, client).fake }
 
-        it "uses the 'at' value in the update payload" do
-          mock(client.base).put("v2", :my_fake_models, subject.guid, hash_including(:payload => {:not_foo => 123}))
-          subject.foo = 123
-          subject.update!
-        end
+        subject { myobject.foo = otherobject }
 
-        it "uses the 'at' value in the create payload" do
-          subject.foo = 123
+        it "sets the GUID in the manifest to the object's GUID" do
+          expect { subject }.to change {
+            myobject.manifest[:entity][:foo_guid]
+          }.to(otherobject.guid)
+        end
 
-          mock(client.base).post(
-            "v2", :my_fake_models,
-            hash_including(:payload => {:not_foo => 123})
-          ) { {:metadata => {}} }
+        it "tracks internal changes in the diff" do
+          expect { subject }.to change { myobject.diff }.to(
+            :foo_guid => otherobject.guid)
+        end
 
-          subject.create!
+        it "tracks high-level changes in .changes" do
+          before = myobject.foo
+          expect { subject }.to change { myobject.changes }.to(
+            :foo => [before, otherobject])
         end
 
-        it "is then readable via the attribute name" do
-          subject.foo = 123
-          expect(subject.foo).to eq 123
+        it "returns the assigned value" do
+          myobject.send(:foo=, otherobject).should == otherobject
         end
-      end
-    end
-  end
 
-  describe 'to_one relationships' do
-    describe 'writing' do
-      let!(:mymodel) { fake_model { to_one :foo } }
-      let!(:othermodel) { fake_model :foo }
+        context "when there is a default" do
+          let(:mymodel) { fake_model { to_one :foo, :default => nil } }
 
-      let(:myobject) { mymodel.new(nil, client).fake }
-      let(:otherobject) { othermodel.new(nil, client).fake }
+          subject { myobject.foo = nil }
 
-      subject { myobject.foo = otherobject }
+          it "allows setting to the default" do
+            myobject.foo = otherobject
 
-      it "sets the GUID in the manifest to the object's GUID" do
-        expect { subject }.to change {
-          myobject.manifest[:entity][:foo_guid]
-        }.to(otherobject.guid)
+            expect { subject }.to change {
+              myobject.manifest[:entity][:foo_guid]
+            }.from(otherobject.guid).to(nil)
+          end
+        end
       end
 
-      it "tracks internal changes in the diff" do
-        expect { subject }.to change { myobject.diff }.to(
-          :foo_guid => otherobject.guid)
-      end
+      describe 'associated create' do
+        let!(:model) { fake_model { to_one :associated } }
+        let(:instance) { model.new(nil, client).fake }
+        let!(:request) { WebMock.stub_request(:post, /v2\/associated/).to_return(:body => {:metadata => {:guid => "thing"}}.to_json) }
 
-      it "tracks high-level changes in .changes" do
-        before = myobject.foo
-        expect { subject }.to change { myobject.changes }.to(
-          :foo => [before, otherobject])
-      end
+        it 'returns a new associated object' do
+          instance.create_associated.should be_a(Associated)
+        end
+
+        it 'sets the relation' do
+          created = instance.create_associated
+          instance.associated.should == created
+        end
 
-      context "when there is a default" do
-        let(:mymodel) { fake_model { to_one :foo, :default => nil } }
+        context 'with attributes for the association' do
+          it 'sets these attributes on the association' do
+            created = instance.create_associated(:attribute => 'value')
+            created.attribute.should == 'value'
+          end
+        end
 
-        subject { myobject.foo = nil }
+        it 'calls out to cloud_controller' do
+          instance.create_associated
+          request.should have_been_requested
+        end
 
-        it "allows setting to the default" do
-          myobject.foo = otherobject
+        context 'when creation fails' do
+          let!(:request) { WebMock.stub_request(:post, /v2\/associated/).to_raise(:not_authorized) }
 
-          expect { subject }.to change {
-            myobject.manifest[:entity][:foo_guid]
-          }.from(otherobject.guid).to(nil)
+          it 'raises an exception' do
+            expect { instance.create_associated }.to raise_error(StandardError)
+          end
         end
       end
     end
-  end
 
-  describe 'summarization for an arbitrary model' do
-    let(:mymodel) { fake_model { attribute :foo, :string } }
-    let(:summary_attributes) { { :foo => "abcd" } }
+    describe 'summarization for an arbitrary model' do
+      let(:mymodel) { fake_model { attribute :foo, :string } }
+      let(:summary_attributes) { {:foo => "abcd"} }
 
-    subject { myobject }
+      subject { myobject }
 
-    it_behaves_like 'a summarizeable model'
+      it_behaves_like 'a summarizeable model'
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cfoundry
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-24 00:00:00.000000000 Z
+date: 2013-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multipart-post
@@ -376,7 +376,7 @@ files:
 - spec/support/shared_examples/cc_api_stub_request_examples.rb
 - spec/support/shared_examples/client_login_examples.rb
 - spec/support/shared_examples/model_summary_examples.rb
-homepage: http://github.com/cloudfoundry/vmc-lib
+homepage: http://github.com/cloudfoundry/cfoundry
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -390,7 +390,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -667619740033887048
+      hash: 731683098158861932
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: