gliffy 0.0.6 → 0.0.7

data/spec/lib/gliffy/{document_png_spec.rb → document/presentation/png_spec.rb}

@@ -1,13 +1,12 @@
 require 'spec_helper'
 
-describe Gliffy::Document::PNG do
+describe Gliffy::Document::Presentation::PNG do
     let(:content) { "SAMPLE CONTENT" }
     let(:document) { double(Gliffy::Document) }
-    let(:png) { Gliffy::Document::PNG.new(document) }
+    let(:png) { Gliffy::Document::Presentation::PNG.new(document) }
 
-    it "has a reference to the original document" do
-        expect(png).to respond_to :document
-        expect(png.document).to be document
+    it_should_behave_like "a document presentation" do
+      let(:presentation) { png }
     end
 
     it "has content" do
@@ -30,14 +29,14 @@ describe Gliffy::Document::PNG do
             )
         ).and_return(content)
 
-        expect(png.content(Gliffy::Document::PNG::SIZE_THUMBNAIL)).to eq content
+        expect(png.content(Gliffy::Document::Presentation::PNG::SIZE_THUMBNAIL)).to eq content
     end
 
     it "has a thumbnail" do
         png.stub(:content).and_return(content)
         expect(png.thumbnail).to eq content
         expect(png).to have_received(:content).with(
-            Gliffy::Document::PNG::SIZE_THUMBNAIL
+            Gliffy::Document::Presentation::PNG::SIZE_THUMBNAIL
         )
     end
 
@@ -45,7 +44,7 @@ describe Gliffy::Document::PNG do
         png.stub(:content).and_return(content)
         expect(png.small).to eq content
         expect(png).to have_received(:content).with(
-            Gliffy::Document::PNG::SIZE_SMALL
+            Gliffy::Document::Presentation::PNG::SIZE_SMALL
         )
     end
 
@@ -53,7 +52,7 @@ describe Gliffy::Document::PNG do
         png.stub(:content).and_return(content)
         expect(png.medium).to eq content
         expect(png).to have_received(:content).with(
-            Gliffy::Document::PNG::SIZE_MEDIUM
+            Gliffy::Document::Presentation::PNG::SIZE_MEDIUM
         )
     end
 
@@ -61,7 +60,7 @@ describe Gliffy::Document::PNG do
         png.stub(:content).and_return(content)
         expect(png.full).to eq content
         expect(png).to have_received(:content).with(
-            Gliffy::Document::PNG::SIZE_FULL
+            Gliffy::Document::Presentation::PNG::SIZE_FULL
         )
     end
-end
+end

data/spec/lib/gliffy/document/presentation/svg_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Gliffy::Document::Presentation::SVG do
+    let(:content) { "SAMPLE CONTENT" }
+    let(:document) { double(Gliffy::Document) }
+    let(:svg) { Gliffy::Document::Presentation::SVG.new(document) }
+
+    it_should_behave_like "a document presentation" do
+      let(:presentation) { svg }
+    end
+
+    it "has a reference to the original document" do
+        expect(svg).to respond_to :document
+        expect(svg.document).to be document
+    end
+
+    it "has content" do
+        expect(svg).to respond_to :content
+    end
+
+    it "delegates task of fetching SVG content content to the API facade" do
+        account = double(Gliffy::Account, :id => 11)
+        api = double(Gliffy::API)
+        document.stub(:api).and_return(api)
+        document.stub(:owner).and_return(account)
+        document.stub(:id).and_return(22)
+        api.should_receive(
+            :raw
+        ).with(
+            "/accounts/11/documents/22.svg",
+            hash_including(
+                :action => "get"
+            )
+        ).and_return(content)
+
+        expect(svg.content).to eq content
+    end
+end

data/spec/lib/gliffy/document/presentation/xml_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Gliffy::Document::Presentation::XML do
+    let(:content) { "SAMPLE CONTENT" }
+    let(:document) { double(Gliffy::Document) }
+    let(:xml) { Gliffy::Document::Presentation::XML.new(document) }
+
+    it_should_behave_like "a document presentation" do
+      let(:presentation) { xml }
+    end
+
+    it "has a reference to the original document" do
+        expect(xml).to respond_to :document
+        expect(xml.document).to be document
+    end
+
+    it "has content" do
+        expect(xml).to respond_to :content
+    end
+
+    it "delegates task of fetching XML content content to the API facade" do
+        account = double(Gliffy::Account, :id => 11)
+        api = double(Gliffy::API)
+        document.stub(:api).and_return(api)
+        document.stub(:owner).and_return(account)
+        document.stub(:id).and_return(22)
+        api.should_receive(
+            :raw
+        ).with(
+            "/accounts/11/documents/22.xml",
+            hash_including(
+                :action => "get"
+            )
+        ).and_return(content)
+
+        expect(xml.content).to eq content
+    end
+end

data/spec/lib/gliffy/document/presentation_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Gliffy::Document::Presentation do
+  let(:document) { double(Gliffy::Document) }
+  let(:presentation) { Gliffy::Document::Presentation.new(document) }
+
+  it_should_behave_like "a document presentation" 
+end

data/spec/lib/gliffy/document_spec.rb

@@ -1,108 +1,179 @@
-require 'spec_helper'
-
-describe Gliffy::Document do
-  before :each do
-    Gliffy::Document.clear_cache
-  end
-
-  let(:api)  { double(Gliffy::API) }
-  let(:owner) do
-    owner = double(Gliffy::Account) 
-    owner.stub(:api).and_return(api)
-    owner
-  end
-
-  let(:document_id) { 1000002 }
-  let(:document_name) { 'SNPP Domain Model' }
-
-  let(:response) do
-    Gliffy::API::Response.new(fixture(
-      "document",
-      :document_id => document_id,
-      :document_name => document_name
-      )
-    )
-  end
-
-  let(:document) do
-    Gliffy::Document.load(owner, response.node("//g:document"))
-  end
-
-  it "has an id" do
-    expect(document).to respond_to :id
-    expect(document.id).to eq document_id
-  end
-
-  it "has a name" do
-    expect(document).to respond_to :name
-    expect(document.name).to eq document_name
-  end
-
-  it "has 'public access' flag" do
-    expect(document).to respond_to :public?
-    expect(document.public?).to eq(true)
-  end
-
-  it "has a version number" do
-    expect(document).to respond_to :versions
-    expect(document.versions).to eq(5)
-  end
-
-  it "has a modification date" do
-    expect(document).to respond_to :modified
-    expect(document.modified).to eq(DateTime.new(2008, 7, 8, 17, 31, 23))
-  end
-
-  it "has a creation date" do
-    expect(document).to respond_to :created
-    expect(document.created).to eq(DateTime.new(2008, 7, 8, 17, 31, 24))
-  end
-
-  it "has a publication date" do
-    expect(document).to respond_to :published
-    expect(document.published).to eq(DateTime.new(2008, 7, 8, 17, 31, 25))
-  end
-
-  it "has an owner" do
-    expect(document).to respond_to :owner
-    expect(document.owner).to be(owner)
-  end
-
-  it "has a link to gliffy editor" do
-    return_url = "sample/url"
-    return_text = "RETURN TEXT"
-
-    api.should_receive(
-      :web
-    ).with(
-      "/gliffy/",
-      hash_including(
-        :launchDiagramId => document_id,
-        :returnURL => return_url,
-        :returnButtonText => return_text
-      )
-    ).and_return(
-      "http://www.gliffy.com/gliffy/?launchDiagramId=#{document.id}&returnURL=#{return_url}&returnButtonText=#{return_text}"
-    )
-
-    link = document.editor(return_url, return_text)
-
-    expect(link).to match '/gliffy/'
-    expect(link).to match 'launchDiagramId='
-    expect(link).to match document.id.to_s
-    expect(link).to match 'returnURL='
-    expect(link).to match return_url
-    expect(link).to match 'returnButtonText='
-    expect(link).to match return_text
-  end
-
-  it "has an PNG image" do
-    expect(document).to respond_to :png
-    expect(document.png).to be_instance_of Gliffy::Document::PNG
-  end
-
-  it "has singleton-life behavior" do
-    doc1 = Gliffy::Document.load(owner, response.node("//g:document"))
-    expect(doc1).to be document
-  end
-end
+require 'spec_helper'
+
+describe Gliffy::Document do
+  before :each do
+    Gliffy::Document.clear_cache
+  end
+
+  let(:api)  { double(Gliffy::API::Facade) }
+  let(:owner) do
+    owner = double(Gliffy::Account)
+    owner.stub(:api).and_return(api)
+    owner
+  end
+
+  let(:document_id) { 1000002 }
+  let(:document_name) { 'SNPP Domain Model' }
+
+  let(:response) do
+    Gliffy::API::Response.new(fixture(
+      "document",
+      :document_id => document_id,
+      :document_name => document_name
+      )
+    )
+  end
+
+  let(:document) do
+    Gliffy::Document.load(owner, response.node("//g:document"))
+  end
+
+  it "has an id" do
+    expect(document).to respond_to :id
+    expect(document.id).to eq document_id
+  end
+
+  it "has a name" do
+    expect(document).to respond_to :name
+    expect(document.name).to eq document_name
+  end
+
+  it "has 'public access' flag" do
+    expect(document).to respond_to :public?
+    expect(document.public?).to eq(true)
+  end
+
+  it "has a version number" do
+    expect(document).to respond_to :versions
+    expect(document.versions).to eq(5)
+  end
+
+  it "has a modification date" do
+    expect(document).to respond_to :modified
+    expect(document.modified).to eq(DateTime.new(2008, 7, 8, 17, 31, 23))
+  end
+
+  it "has a creation date" do
+    expect(document).to respond_to :created
+    expect(document.created).to eq(DateTime.new(2008, 7, 8, 17, 31, 24))
+  end
+
+  it "has a publication date" do
+    expect(document).to respond_to :published
+    expect(document.published).to eq(DateTime.new(2008, 7, 8, 17, 31, 25))
+  end
+
+  it "has an owner" do
+    expect(document).to respond_to :owner
+    expect(document.owner).to be(owner)
+  end
+
+  it "has a link to gliffy editor" do
+    return_url = "sample/url"
+    return_text = "RETURN TEXT"
+
+    api.should_receive(
+      :web
+    ).with(
+      "/gliffy/",
+      hash_including(
+        :launchDiagramId => document_id,
+        :returnURL => return_url,
+        :returnButtonText => return_text
+      )
+    ).and_return(
+      "http://www.gliffy.com/gliffy/?launchDiagramId=#{document.id}&returnURL=#{return_url}&returnButtonText=#{return_text}"
+    )
+
+    link = document.editor(return_url, return_text)
+
+    expect(link).to match '/gliffy/'
+    expect(link).to match 'launchDiagramId='
+    expect(link).to match document.id.to_s
+    expect(link).to match 'returnURL='
+    expect(link).to match return_url
+    expect(link).to match 'returnButtonText='
+    expect(link).to match return_text
+  end
+
+  it "has an PNG image" do
+    expect(document).to respond_to :png
+    expect(document.png).to be_instance_of Gliffy::Document::Presentation::PNG
+  end
+
+  it "has SVG representation" do
+    expect(document).to respond_to :svg
+    expect(document.svg).to be_instance_of Gliffy::Document::Presentation::SVG
+  end
+
+  it "has XML representation" do
+    expect(document).to respond_to :xml
+    expect(document.xml).to be_instance_of Gliffy::Document::Presentation::XML
+  end
+
+  it "has singleton-life behavior" do
+    doc1 = Gliffy::Document.load(owner, response.node("//g:document"))
+    expect(doc1).to be document
+  end
+
+  it "can be renamed" do
+    expect(document).to respond_to :rename
+  end
+
+  context "when renamed" do
+    let (:new_name) { "NEW DOCUMENT NAME" }
+    before :each do
+      api.stub(:update_document_metadata)
+      document.rename new_name
+    end
+
+    it "changes the name to the new value" do
+      expect(document.name).to eq new_name
+    end
+
+    it "calls rename method of the REST API" do
+      expect(api).to have_received(:update_document_metadata)
+        .with(document_id, new_name, nil)
+    end
+  end
+
+  it "can be deleted" do
+    expect(document).to respond_to :delete
+  end
+
+  it "has flag indicating whether this object has been deleted" do
+    expect(document).to respond_to :deleted?
+  end
+
+  context "when not deleted" do
+    it "knows it" do
+      expect(document.deleted?).to be_false
+    end
+  end
+
+  context "when deleted" do
+    let(:observer) { double(Object) }
+
+    before :each do
+      api.stub(:delete_document)
+
+      observer.stub(:update)
+      document.add_observer(observer)
+
+      document.delete
+    end
+
+    it "calls REST API" do
+      expect(api).to have_received(:delete_document)
+        .with(document_id)
+    end
+
+    it "knows it" do
+      expect(document.deleted?).to be_true
+    end
+
+    it "notifies observers" do
+      expect(observer).to have_received(:update).with(:delete, document)
+    end
+  end
+end

data/spec/lib/gliffy/folder_spec.rb

@@ -1,175 +1,224 @@
-# -*- coding: utf-8 -*-
-require 'spec_helper'
-
-describe Gliffy::Folder do
-  let(:account_id) { 100 }
-  let(:api) { double(Gliffy::API) }
-  let(:account) { double(Gliffy::Account, :api => api, :id => account_id) }
-
-  subject(:folder) do
-    Gliffy::Folder.load(
-      account,
-      Gliffy::API::Response.new(
-        fixture('folder')
-      ).node("//g:folders/g:folder[1]")
-    )
-  end
-
-  it "has a name" do
-    expect(folder).to respond_to :name
-    expect(folder.name).to eq "ROOT"
-  end
-
-  it "has a path" do
-    expect(folder).to respond_to :path
-    expect(folder.path).to eq "ROOT"
-  end
-
-  it "has a list of documents" do
-    expect(folder).to respond_to :documents
-  end
-
-  describe "root folder" do
-    it "knows it is root" do
-      expect(folder.root?).to be_true
-    end
-
-    it "has no parent" do
-      expect(folder.parent).to be_nil
-    end
-  end
-
-  describe "document list" do
-    it "is loaded from API" do
-      api.should_receive(
-        :get
-      ).and_return(
-        Gliffy::API::Response.new(fixture("documents"))
-      )
-
-      folder.documents
-    end
-
-    it "has correct length" do
-      api.stub(
-        :get
-      ).and_return(
-        Gliffy::API::Response.new(fixture("documents"))
-      )
-
-      expect(folder.documents.length).to eq 3
-    end
-
-    it "is empty when API returns appropriate response" do
-      api.stub(
-        :get
-      ).and_return(
-        Gliffy::API::Response.new(fixture("documents-empty"))
-      )
-
-      expect(folder.documents.length).to eq 0
-    end
-  end
-
-  it "has nested folders" do
-    expect(folder).to respond_to :folders
-  end
-
-  describe "folder list" do
-    subject(:children) { folder.folders }
-
-    it { should respond_to :length }
-    it { should respond_to :[] }
-    it "has corrent length" do 
-      expect(children.length).to eq 4
-    end
-  end
-
-  describe "first-level folder 'Burns Top Secret'" do
-    subject(:first_child) { folder.folders[0] }
-
-    it "has correct parent" do
-      expect(first_child.parent).to be folder
-    end
-
-    it "has correct name" do
-      expect(first_child.name).to eq "Burns Top Secret"
-    end
-
-    it "has correct path" do
-      expect(first_child.path).to eq "ROOT/Burns Top Secret"
-    end
-
-    it "has correct number of children" do
-      expect(first_child.folders).to eq []
-    end
-
-    it "knows it is not root" do
-      expect(first_child.root?).to be_false
-    end
-  end
-
-  describe "first-level folder 'Simsons Family'" do
-    subject(:second_child) { folder.folders[3] }
-
-    it "has correct parent" do
-      expect(second_child.parent).to be folder
-    end
-
-    it "has correct name" do
-      expect(second_child.name).to eq "Simpsons Family"
-    end
-
-    it "has correct path" do
-      expect(second_child.path).to eq "ROOT/Simpsons Family"
-    end
-
-    it "has corrent number of children" do
-      expect(second_child.folders.length).to eq 2
-    end
-
-    it "knows it is not root" do
-      expect(second_child.root?).to be_false
-    end
-
-    describe "second-level folder 'Maggie and Lisas Stuff'" do
-      subject(:nested_child) { second_child.folders[1] }
-
-      it "has corrent parent" do
-        expect(nested_child.parent).to be second_child
-      end
-
-      it "has correct name" do
-        expect(nested_child.name).to eq "Maggie and Lisas Stuff"
-      end
-
-      it "has correct path" do
-        expect(nested_child.path).to eq "ROOT/Simpsons Family/Maggie and Lisas Stuff"
-      end
-
-      it "knows it is not root" do
-        expect(nested_child.root?).to be_false
-      end
-    end
-  end
-
-  context "when assigning a parent" do
-    context "with valid path" do
-      it "updates parent" do
-        f1 = Gliffy::Folder.new(account, "F1", "/ROOT/F1", [])
-        f2 = Gliffy::Folder.new(account, "F2", "/ROOT/F1/F2", [])
-
-        f2.parent = f1
-        expect(f2.parent).to be f1
-      end
-    end
-
-    context "with invalid path" do
-      it "raises an error" do
-        f1 = Gliffy::Folder.new(@account, "F1", "/ROOT/F1", [])
-        f2 = Gliffy::Folder.new(@account, "F2", "/ROOT/F2", [])
-        expect { f1.parent = f2 }.to raise_error
-      end
-    end
-  end
-end
+# -*- coding: utf-8-unix -*-
+require 'spec_helper'
+
+describe Gliffy::Folder do
+  let(:account_id) { 100 }
+  let(:api) { double(Gliffy::API::Facade) }
+  let(:account) { double(Gliffy::Account, :api => api, :id => account_id) }
+
+  subject(:folder) do
+    Gliffy::Folder.load(
+      account,
+      Gliffy::API::Response.new(
+        fixture('folder')
+      ).node("//g:folders/g:folder[1]")
+    )
+  end
+
+  it "has a name" do
+    expect(folder).to respond_to :name
+    expect(folder.name).to eq "ROOT"
+  end
+
+  it "has a path" do
+    expect(folder).to respond_to :path
+    expect(folder.path).to eq "ROOT"
+  end
+
+  it "has a list of documents" do
+    expect(folder).to respond_to :documents
+  end
+
+  describe "root folder" do
+    it "knows it is root" do
+      expect(folder.root?).to be_true
+    end
+
+    it "has no parent" do
+      expect(folder.parent).to be_nil
+    end
+  end
+
+  describe "document list" do
+    it "is loaded from API" do
+      api.should_receive(
+        :get
+      ).and_return(
+        Gliffy::API::Response.new(fixture("documents"))
+      )
+
+      folder.documents
+    end
+
+    it "has correct length" do
+      api.stub(
+        :get
+      ).and_return(
+        Gliffy::API::Response.new(fixture("documents"))
+      )
+
+      expect(folder.documents.length).to eq 3
+    end
+
+    it "is empty when API returns appropriate response" do
+      api.stub(
+        :get
+      ).and_return(
+        Gliffy::API::Response.new(fixture("documents-empty"))
+      )
+
+      expect(folder.documents.length).to eq 0
+    end
+  end
+
+  it "has nested folders" do
+    expect(folder).to respond_to :folders
+  end
+
+  describe "folder list" do
+    subject(:children) { folder.folders }
+
+    it { should respond_to :length }
+    it { should respond_to :[] }
+    it "has corrent length" do 
+      expect(children.length).to eq 4
+    end
+  end
+
+  describe "first-level folder 'Burns Top Secret'" do
+    subject(:first_child) { folder.folders[0] }
+
+    it "has correct parent" do
+      expect(first_child.parent).to be folder
+    end
+
+    it "has correct name" do
+      expect(first_child.name).to eq "Burns Top Secret"
+    end
+
+    it "has correct path" do
+      expect(first_child.path).to eq "ROOT/Burns Top Secret"
+    end
+
+    it "has correct number of children" do
+      expect(first_child.folders).to eq []
+    end
+
+    it "knows it is not root" do
+      expect(first_child.root?).to be_false
+    end
+  end
+
+  describe "first-level folder 'Simsons Family'" do
+    subject(:second_child) { folder.folders[3] }
+
+    it "has correct parent" do
+      expect(second_child.parent).to be folder
+    end
+
+    it "has correct name" do
+      expect(second_child.name).to eq "Simpsons Family"
+    end
+
+    it "has correct path" do
+      expect(second_child.path).to eq "ROOT/Simpsons Family"
+    end
+
+    it "has corrent number of children" do
+      expect(second_child.folders.length).to eq 2
+    end
+
+    it "knows it is not root" do
+      expect(second_child.root?).to be_false
+    end
+
+    describe "second-level folder 'Maggie and Lisas Stuff'" do
+      subject(:nested_child) { second_child.folders[1] }
+
+      it "has corrent parent" do
+        expect(nested_child.parent).to be second_child
+      end
+
+      it "has correct name" do
+        expect(nested_child.name).to eq "Maggie and Lisas Stuff"
+      end
+
+      it "has correct path" do
+        expect(nested_child.path).to eq "ROOT/Simpsons Family/Maggie and Lisas Stuff"
+      end
+
+      it "knows it is not root" do
+        expect(nested_child.root?).to be_false
+      end
+    end
+  end
+
+  context "when assigning a parent" do
+    context "with valid path" do
+      it "updates parent" do
+        f1 = Gliffy::Folder.new(account, "F1", "/ROOT/F1", [])
+        f2 = Gliffy::Folder.new(account, "F2", "/ROOT/F1/F2", [])
+
+        f2.parent = f1
+        expect(f2.parent).to be f1
+      end
+    end
+
+    context "with invalid path" do
+      it "raises an error" do
+        f1 = Gliffy::Folder.new(@account, "F1", "/ROOT/F1", [])
+        f2 = Gliffy::Folder.new(@account, "F2", "/ROOT/F2", [])
+        expect { f1.parent = f2 }.to raise_error
+      end
+    end
+  end
+
+  it "allows us to create a document" do
+    expect(folder).to respond_to :create_document
+  end
+
+  context "when creating a document" do
+    let(:document_name) { "NEW DOCUMENT NAME" }
+
+    before :each do
+      api.stub(:create_document)
+      folder.create_document(document_name)
+    end
+
+    it "calls REST API" do
+      expect(api).to have_received(:create_document)
+        .with(document_name,
+              Gliffy::Document::TYPE_DIAGRAM,
+              nil,
+              folder.path)
+    end
+  end
+
+  context "when receives a document delete notification" do
+    before :each do
+      api.should_receive(
+        :get
+      ).and_return(
+        Gliffy::API::Response.new(fixture("documents"))
+      )
+    end
+
+    it "removes document from the document list" do
+      original_length = folder.documents.length
+      document = folder.documents[1]
+
+      folder.update(:delete, document)
+
+      expect(folder.documents.length).to eq original_length - 1
+      expect(folder.documents).to_not include document
+    end
+  end
+
+  context "when receives an unknown event" do
+    let(:document) { double(Gliffy::Document) }
+
+    it "throws an exception" do
+      expect { folder.update(:unknown, document) }.to raise_error ArgumentError
+    end
+  end
+end