ro-bundle 0.1.0

data/lib/ro-bundle/ro/provenance.rb

@@ -0,0 +1,153 @@
+#------------------------------------------------------------------------------
+# Copyright (c) 2014 The University of Manchester, UK.
+#
+# BSD Licenced. See LICENCE.rdoc for details.
+#
+# Author: Robert Haines
+#------------------------------------------------------------------------------
+
+#
+module ROBundle
+
+  # This module is a mixin for Research Object
+  # {provenance}[http://wf4ever.github.io/ro/bundle/draft/#provenance]
+  # information.
+  #
+  # To use this module simply provide an (optionally private) method named
+  # 'structure' which returns the internal fields of the object as a Hash.
+  #
+  # Fields added by this mixin are:
+  # * <tt>:authoredBy</tt>
+  # * <tt>:authoredOn</tt>
+  # * <tt>:createdBy</tt>
+  # * <tt>:createdOn</tt>
+  module Provenance
+
+    # :call-seq:
+    #   add_author(author) -> Agent
+    #
+    # Add an author to the list of authors for this Research Object. The
+    # supplied parameter can either be an Agent or the name of an author as a
+    # String.
+    #
+    # The Agent object added to the Research Object is returned.
+    def add_author(author)
+      unless author.is_a?(Agent)
+        author = Agent.new(author.to_s)
+      end
+
+      @edited = true
+      (structure[:authoredBy] ||= []) << author
+      author
+    end
+
+    # :call-seq:
+    #   authored_by -> Agents
+    #
+    # Return the list of Agents that authored this Research Object.
+    def authored_by
+      structure.fetch(:authoredBy, []).dup
+    end
+
+    # :call-seq:
+    #   authored_on -> Time
+    #
+    # Return the time that this RO Bundle was edited as a Time object, or
+    # +nil+ if not present in the manifest.
+    def authored_on
+      Util.parse_time(structure[:authoredOn])
+    end
+
+    # :call-seq:
+    #   authored_on = new_time
+    #
+    # Set a new authoredOn time for this Manifest. Anything that Ruby can
+    # interpret as a time is accepted and converted to ISO8601 format on
+    # serialization.
+    def authored_on=(new_time)
+      @edited = true
+      set_time(:authoredOn, new_time)
+    end
+
+    # :call-seq:
+    #   created_by -> Agent
+    #
+    # Return the Agent that created this Research Object.
+    def created_by
+      structure[:createdBy]
+    end
+
+    # :call-seq:
+    #   created_by = new_creator
+    #
+    # Set the Agent that has created this RO Bundle. Anything passed to this
+    # method that is not an Agent will be converted to an Agent before setting
+    # the value.
+    def created_by=(new_creator)
+      unless new_creator.instance_of?(Agent)
+        new_creator = Agent.new(new_creator.to_s)
+      end
+
+      @edited = true
+      structure[:createdBy] = new_creator
+    end
+
+    # :call-seq:
+    #   created_on -> Time
+    #
+    # Return the time that this RO Bundle was created as a Time object, or
+    # +nil+ if not present in the manifest.
+    def created_on
+      Util.parse_time(structure[:createdOn])
+    end
+
+    # :call-seq:
+    #   created_on = new_time
+    #
+    # Set a new createdOn time for this Manifest. Anything that Ruby can
+    # interpret as a time is accepted and converted to ISO8601 format on
+    # serialization.
+    def created_on=(new_time)
+      @edited = true
+      set_time(:createdOn, new_time)
+    end
+
+    # :call-seq:
+    #   remove_author(name)
+    #   remove_author(Agent)
+    #
+    # Remove the specified author or all authors with the specified name from
+    # the +authoredBy+ field.
+    def remove_author(object)
+      if object.is_a?(Agent)
+        structure[:authoredBy].delete(object)
+        @edited = true
+      else
+        changed = structure[:authoredBy].reject! { |a| a.name == object }
+        @edited = true unless changed.nil?
+      end
+    end
+
+    private
+
+    def init_provenance_defaults(struct)
+      creator = struct[:createdBy]
+      struct[:createdBy] = Agent.new(creator) unless creator.nil?
+      struct[:authoredBy] = [*struct.fetch(:authoredBy, [])].map do |agent|
+        Agent.new(agent)
+      end
+
+      struct
+    end
+
+    def set_time(key, time)
+      if time.instance_of?(String)
+        time = Time.parse(time)
+      end
+
+      structure[key] = time.iso8601
+    end
+
+  end
+
+end

data/lib/ro-bundle/util.rb

@@ -0,0 +1,57 @@
+#------------------------------------------------------------------------------
+# Copyright (c) 2014 The University of Manchester, UK.
+#
+# BSD Licenced. See LICENCE.rdoc for details.
+#
+# Author: Robert Haines
+#------------------------------------------------------------------------------
+
+#
+module ROBundle
+
+  # A module with lots of utility functions.
+  module Util
+
+    # :call-seq:
+    #   clean_json(json_hash) -> Hash
+    #
+    # Remove empty strings and nils from a json hash structure.
+    def self.clean_json(structure)
+      structure.delete_if do |_, v|
+        v.nil? || (v.respond_to?(:empty?) && v.empty?)
+      end
+    end
+
+    # :call-seq:
+    #   parse_time(time) -> Time
+    #
+    # Parse a time string into a Time object. Does not try to parse +nil+.
+    def self.parse_time(time)
+      return if time.nil?
+      Time.parse(time)
+    end
+
+    # :call-seq:
+    #   is_absolute_uri?(uri) -> true or false
+    #
+    # Is the supplied URI absolute? An absolute URI is a valid URI that starts
+    # with a scheme, such as http, https or urn.
+    def self.is_absolute_uri?(uri)
+      uri = URI.parse(uri) unless uri.is_a?(URI)
+      !uri.scheme.nil?
+    rescue URI::InvalidURIError
+      false
+    end
+
+    # :call-seq:
+    #   strip_leading_slash(string)
+    #
+    # Return the supplied string with a leading slash removed.
+    def self.strip_leading_slash(string)
+      return if string.nil?
+      string.sub(/^\//, "")
+    end
+
+  end
+
+end

data/lib/ro-bundle/version.rb

@@ -0,0 +1,13 @@
+#------------------------------------------------------------------------------
+# Copyright (c) 2014 The University of Manchester, UK.
+#
+# BSD Licenced. See LICENCE.rdoc for details.
+#
+# Author: Robert Haines
+#------------------------------------------------------------------------------
+
+#
+module ROBundle
+  # The version number of this library as a String.
+  VERSION = "0.1.0"
+end

data/ro-bundle.gemspec

@@ -0,0 +1,43 @@
+#------------------------------------------------------------------------------
+# Copyright (c) 2014 The University of Manchester, UK.
+#
+# BSD Licenced. See LICENCE.rdoc for details.
+#
+# Author: Robert Haines
+#------------------------------------------------------------------------------
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ro-bundle/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ro-bundle"
+  spec.version       = ROBundle::VERSION
+  spec.authors       = ["Robert Haines"]
+  spec.email         = ["support@mygrid.org.uk"]
+  spec.summary       = "This library provides an API for manipulating "\
+    "Research Object (RO) bundles."
+  spec.description   = "This library provides an API for manipulating "\
+    "Research Object (RO) bundles. The RO bundle specification can be found "\
+    "at http://purl.org/wf4ever/ro-bundle."
+  spec.homepage      = "http://www.taverna.org.uk"
+  spec.license       = "BSD"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.has_rdoc         = true
+  spec.extra_rdoc_files = [ "Changes.rdoc", "Licence.rdoc", "ReadMe.rdoc" ]
+  spec.rdoc_options     = [ "-N", "--tab-width=2", "--main=ReadMe.rdoc" ]
+
+  spec.required_ruby_version = ">= 1.9.3"
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake", "~> 10.1"
+  spec.add_development_dependency("rdoc", "~> 4.1")
+  spec.add_development_dependency "coveralls"
+  spec.add_runtime_dependency "ucf", "~> 1.0"
+  spec.add_runtime_dependency "json", "~> 1.8"
+  spec.add_runtime_dependency "uuid", "~> 2.3"
+end

data/test/data/empty-manifest.json

@@ -0,0 +1 @@
+{}

data/test/data/example3-manifest.json

@@ -0,0 +1,40 @@
+{
+    "@context":  [
+        "https://w3id.org/bundle/context"
+    ],
+    "id": "/",
+    "manifest":  "manifest.json",
+    "createdOn": "2013-03-05T17:29:03Z",
+    "createdBy": {
+        "uri":     "http://example.com/foaf#alice",
+        "orcid":   "http://orcid.org/0000-0002-1825-0097",
+        "name":    "Alice W. Land" },
+    "history":   "evolution.ttl",
+    "aggregates": [
+       { "file":  "/folder/soup.jpeg" },
+       { "uri": "http://example.com/blog/" },
+       { "file":      "/README.txt",
+         "mediatype": "text/plain",
+         "createdBy": {
+             "uri":     "http://example.com/foaf#bob",
+             "name":    "Bob Builder" },
+         "createdOn": "2013-02-12T19:37:32.939Z" },
+       { "uri":    "http://example.com/comments.txt",
+         "bundledAs": {
+            "uri":    "urn:uuid:a0cf8616-bee4-4a71-b21e-c60e6499a644",
+            "folder":   "/folder/",
+            "filename": "external.txt" }
+       }
+    ],
+    "annotations": [
+      { "annotation": "urn:uuid:d67466b4-3aeb-4855-8203-90febe71abdf",
+        "about":      "/folder/soup.jpeg",
+        "content":    "annotations/soup-properties.ttl" },
+
+      { "about":   "urn:uuid:a0cf8616-bee4-4a71-b21e-c60e6499a644",
+        "content": "http://example.com/blog/they-aggregated-our-file" },
+
+      { "about":   "urn:uuid:d67466b4-3aeb-4855-8203-90febe71abdf",
+        "content": "annotations/a-meta-annotation-in-this-ro.txt" }
+    ]
+}

data/test/data/invalid-manifest.json

@@ -0,0 +1,5 @@
+{
+    "@context":  [
+        "https://w3id.org/bundle/context"
+    ],
+    "id": "/",

data/test/helpers/fake_manifest.rb

@@ -0,0 +1,23 @@
+#------------------------------------------------------------------------------
+# Copyright (c) 2014 The University of Manchester, UK.
+#
+# BSD Licenced. See LICENCE.rdoc for details.
+#
+# Author: Robert Haines
+#------------------------------------------------------------------------------
+
+# Fake up a manifest for easy testing.
+class FakeManifest < ROBundle::Manifest
+
+  def initialize(file)
+    @file = file
+    super()
+  end
+
+  private
+
+  def contents
+    File.read(@file)
+  end
+
+end

data/test/helpers/fake_provenance.rb

@@ -0,0 +1,32 @@
+#------------------------------------------------------------------------------
+# Copyright (c) 2014 The University of Manchester, UK.
+#
+# BSD Licenced. See LICENCE.rdoc for details.
+#
+# Author: Robert Haines
+#------------------------------------------------------------------------------
+
+# Fake up a mixed in provenance module for easy testing.
+class FakeProvenance
+  include ROBundle::Provenance
+
+  def initialize
+    @edited = false
+  end
+
+  def edited?
+    @edited
+  end
+
+  private
+
+  # This structure purposefully has no :authoredBy or :authoredOn fields.
+  def structure
+    @structure ||= init_provenance_defaults(
+      {
+        :createdBy => { :name => "Robert Haines" },
+        :createdOn => "2014-08-20T11:30:00+01:00"
+      }
+    )
+  end
+end

data/test/helpers/list_tests.rb

@@ -0,0 +1,22 @@
+#------------------------------------------------------------------------------
+# Copyright (c) 2014 The University of Manchester, UK.
+#
+# BSD Licenced. See LICENCE.rdoc for details.
+#
+# Author: Robert Haines
+#------------------------------------------------------------------------------
+
+# Is the given file name in the list of history objects
+def entry_in_history_list(entry, list)
+  name = entry.start_with?(".ro/") ? entry.sub(".ro/", "") : "/#{entry}"
+  list.include?(name)
+end
+
+# Is the given name in the list of agent objects
+def name_in_agent_list(name, list)
+  list.each do |e|
+    return true if e.name == name
+  end
+
+  false
+end

data/test/tc_add_annotation.rb

@@ -0,0 +1,571 @@
+#------------------------------------------------------------------------------
+# Copyright (c) 2014 The University of Manchester, UK.
+#
+# BSD Licenced. See LICENCE.rdoc for details.
+#
+# Author: Robert Haines
+#------------------------------------------------------------------------------
+
+require 'test/unit'
+require "ro-bundle"
+
+class TestAddAnnotation < Test::Unit::TestCase
+
+  def test_add_annotation_object
+    Dir.mktmpdir do |dir|
+      filename = File.join(dir, "test.bundle")
+
+      ro = "/"
+      uri = "http://www.example.com"
+      entry = "test_1.json"
+      annotation1 = ROBundle::Annotation.new(ro)
+      annotation2 = ROBundle::Annotation.new(entry, uri)
+      annotation3 = ROBundle::Annotation.new(annotation1)
+
+      ROBundle::File.create(filename) do |b|
+        b.add_aggregate(entry, $man_ex3)
+
+        ann = b.add_annotation(annotation1)
+        b.add_annotation(annotation2)
+        b.add_annotation(annotation3)
+
+        assert_equal annotation1, ann
+
+        ann1, ann2, ann3 = b.annotations
+
+        assert b.annotation?(ann1.annotation_id)
+        assert_same annotation1, ann1
+
+        assert b.annotation?(ann2.annotation_id)
+        assert_same annotation2, ann2
+        assert_equal uri, ann2.content
+
+        assert b.annotation?(ann3.annotation_id)
+        assert_same annotation3, ann3
+      end
+
+      ROBundle::File.open(filename) do |b|
+        refute b.aggregates.empty?
+        refute b.annotations.empty?
+        refute b.commit_required?
+
+        ann1, ann2, ann3 = b.annotations
+
+        assert b.annotation?(ann1.annotation_id)
+        assert_not_same annotation1, ann1
+
+        assert b.annotation?(ann2.annotation_id)
+        assert_not_same annotation2, ann2
+        assert_equal uri, ann2.content
+
+        assert b.annotation?(ann3.annotation_id)
+        assert_not_same annotation3, ann3
+      end
+    end
+  end
+
+  def test_add_annotation_object_no_target
+    Dir.mktmpdir do |dir|
+      filename = File.join(dir, "test.bundle")
+
+      entry = "test.html"
+      annotation = ROBundle::Annotation.new(entry)
+
+      ROBundle::File.create(filename) do |b|
+        assert_raises(Errno::ENOENT) do
+          b.add_annotation(annotation)
+        end
+      end
+
+      ROBundle::File.open(filename) do |b|
+        assert b.aggregates.empty?
+        assert b.annotations.empty?
+        refute b.commit_required?
+      end
+    end
+  end
+
+  def test_add_annotation_no_target
+    Dir.mktmpdir do |dir|
+      filename = File.join(dir, "test.bundle")
+
+      entry = "test.html"
+
+      ROBundle::File.create(filename) do |b|
+        assert_raises(Errno::ENOENT) do
+          b.add_annotation(entry)
+        end
+      end
+
+      ROBundle::File.open(filename) do |b|
+        assert b.aggregates.empty?
+        assert b.annotations.empty?
+        refute b.commit_required?
+      end
+    end
+  end
+
+  def test_add_file_annotations_to_aggregate
+    Dir.mktmpdir do |dir|
+      filename = File.join(dir, "test.bundle")
+
+      entry = "test_1.json"
+      entry2 = "test_2.json"
+
+      ROBundle::File.create(filename) do |b|
+        b.add_aggregate(entry, $man_ex3)
+        b.add_aggregate(entry2, $man_ex3)
+
+        ann = b.add_annotation(entry, $man_ex3)
+        b.add_annotation(entry, $man_ex3, :aggregate => true)
+        b.add_annotation(entry, entry2)
+
+        assert ann.instance_of?(ROBundle::Annotation)
+
+        ann1, ann2, ann3 = b.annotations
+
+        assert b.annotation?(ann1.annotation_id)
+        refute b.aggregate?(ann1.content)
+
+        assert b.annotation?(ann2.annotation_id)
+        assert b.aggregate?(ann2.content)
+
+        assert b.annotation?(ann3)
+        assert b.aggregate?(ann3.content)
+      end
+
+      ROBundle::File.open(filename) do |b|
+        refute b.aggregates.empty?
+        refute b.annotations.empty?
+        refute b.commit_required?
+
+        ann1, ann2, ann3 = b.annotations
+
+        assert b.annotation?(ann1.annotation_id)
+        refute b.aggregate?(ann1.content)
+
+        assert b.annotation?(ann2.annotation_id)
+        assert b.aggregate?(ann2.content)
+
+        assert b.annotation?(ann3)
+        assert b.aggregate?(ann3.content)
+      end
+    end
+  end
+
+  def test_add_uri_annotations_to_aggregate
+    Dir.mktmpdir do |dir|
+      filename = File.join(dir, "test.bundle")
+
+      entry = "test_1.json"
+      uri1 = "http://www.example.com/example1"
+      uri2 = URI.parse("http://www.example.com/example2")
+      uri3 = "http://www.example.com/example3"
+
+      ROBundle::File.create(filename) do |b|
+        b.add_aggregate(entry, $man_ex3)
+        b.add_aggregate(uri3)
+
+        ann = b.add_annotation(entry, uri1)
+        b.add_annotation(entry, uri2, :aggregate => true)
+        b.add_annotation(entry, uri3)
+
+        assert ann.instance_of?(ROBundle::Annotation)
+
+        ann1, ann2, ann3 = b.annotations
+
+        assert b.annotation?(ann1.annotation_id)
+        refute b.aggregate?(ann1.content)
+
+        assert b.annotation?(ann2.annotation_id)
+        assert b.aggregate?(ann2.content)
+
+        assert b.annotation?(ann3)
+        assert b.aggregate?(ann3.content)
+      end
+
+      ROBundle::File.open(filename) do |b|
+        refute b.aggregates.empty?
+        refute b.annotations.empty?
+        refute b.commit_required?
+
+        ann1, ann2, ann3 = b.annotations
+
+        assert b.annotation?(ann1.annotation_id)
+        refute b.aggregate?(ann1.content)
+
+        assert b.annotation?(ann2.annotation_id)
+        assert b.aggregate?(ann2.content)
+
+        assert b.annotation?(ann3)
+        assert b.aggregate?(ann3.content)
+      end
+    end
+  end
+
+  def test_add_content_annotations_to_aggregate
+    Dir.mktmpdir do |dir|
+      filename = File.join(dir, "test.bundle")
+
+      entry = "test_1.json"
+      uri = "http://www.example.com/example1"
+      content = File.read($man_ex3)
+
+      ROBundle::File.create(filename) do |b|
+        b.add_aggregate(entry, $man_ex3)
+        b.add_aggregate(uri)
+
+        ann = b.add_annotation(entry, content)
+        b.add_annotation(entry, content, :aggregate => true)
+        b.add_annotation(uri, content)
+
+        assert ann.instance_of?(ROBundle::Annotation)
+
+        ann1, ann2, ann3 = b.annotations
+
+        assert b.annotation?(ann1.annotation_id)
+        refute b.aggregate?(ann1.content)
+        assert_equal content, b.file.read(".ro/#{ann1.content}")
+
+        assert b.annotation?(ann2.annotation_id)
+        assert b.aggregate?(ann2.content)
+        assert_equal content, b.file.read(ann2.content)
+
+        assert b.annotation?(ann3)
+        refute b.aggregate?(ann3.content)
+        assert_equal content, b.file.read(".ro/#{ann3.content}")
+      end
+
+      ROBundle::File.open(filename) do |b|
+        refute b.aggregates.empty?
+        refute b.annotations.empty?
+        refute b.commit_required?
+
+        ann1, ann2, ann3 = b.annotations
+
+        assert b.annotation?(ann1.annotation_id)
+        refute b.aggregate?(ann1.content)
+        assert_equal content, b.file.read(".ro/#{ann1.content}")
+
+        assert b.annotation?(ann2.annotation_id)
+        assert b.aggregate?(ann2.content)
+        assert_equal content, b.file.read(ann2.content)
+
+        assert b.annotation?(ann3)
+        refute b.aggregate?(ann3.content)
+        assert_equal content, b.file.read(".ro/#{ann3.content}")
+      end
+    end
+  end
+
+  def test_add_file_annotations_to_uri
+    Dir.mktmpdir do |dir|
+      filename = File.join(dir, "test.bundle")
+
+      uri1 = "http://www.example.com/example1"
+      uri2 = URI.parse("http://www.example.com/example2")
+      entry1 = "test_1.json"
+      entry2 = "test_2.json"
+      entry3 = "test_3.json"
+
+      ROBundle::File.create(filename) do |b|
+        b.add_aggregate(uri2)
+        b.add_aggregate(entry3, $man_ex3)
+
+        ann = b.add_annotation(uri1, entry1)
+        b.add_annotation(uri1, entry2, :aggregate => true)
+        b.add_annotation(uri2, entry3)
+
+        assert ann.instance_of?(ROBundle::Annotation)
+
+        ann1, ann2, ann3 = b.annotations
+
+        assert b.annotation?(ann1.annotation_id)
+        refute b.aggregate?(ann1.content)
+
+        assert b.annotation?(ann2.annotation_id)
+        refute b.aggregate?(uri1)
+        assert b.aggregate?(ann2.content)
+
+        assert b.annotation?(ann3)
+        assert b.aggregate?(ann3.content)
+      end
+
+      ROBundle::File.open(filename) do |b|
+        refute b.aggregates.empty?
+        refute b.annotations.empty?
+        refute b.commit_required?
+
+        ann1, ann2, ann3 = b.annotations
+
+        assert b.annotation?(ann1.annotation_id)
+        refute b.aggregate?(ann1.content)
+
+        assert b.annotation?(ann2.annotation_id)
+        refute b.aggregate?(uri1)
+        assert b.aggregate?(ann2.content)
+
+        assert b.annotation?(ann3)
+        assert b.aggregate?(ann3.content)
+      end
+    end
+  end
+
+  def test_add_uri_annotations_to_uri
+    Dir.mktmpdir do |dir|
+      filename = File.join(dir, "test.bundle")
+
+      uri1 = "http://www.example.com/example1"
+      uri2 = URI.parse("http://www.example.com/example2")
+      uri3 = "http://www.example.com/example3"
+      uri4 = "http://www.example.com/example4"
+      uri5 = "http://www.example.com/example5"
+
+      ROBundle::File.create(filename) do |b|
+        b.add_aggregate(uri3)
+        b.add_aggregate(uri5)
+
+        ann = b.add_annotation(uri1, uri2)
+        b.add_annotation(uri1, uri4, :aggregate => true)
+        b.add_annotation(uri3, uri5)
+
+        assert ann.instance_of?(ROBundle::Annotation)
+
+        ann1, ann2, ann3 = b.annotations
+
+        assert b.annotation?(ann1.annotation_id)
+        refute b.aggregate?(ann1.content)
+
+        assert b.annotation?(ann2.annotation_id)
+        refute b.aggregate?(uri1)
+        assert b.aggregate?(ann2.content)
+
+        assert b.annotation?(ann3)
+        assert b.aggregate?(ann3.content)
+      end
+
+      ROBundle::File.open(filename) do |b|
+        refute b.aggregates.empty?
+        refute b.annotations.empty?
+        refute b.commit_required?
+
+        ann1, ann2, ann3 = b.annotations
+
+        assert b.annotation?(ann1.annotation_id)
+        refute b.aggregate?(ann1.content)
+
+        assert b.annotation?(ann2.annotation_id)
+        refute b.aggregate?(uri1)
+        assert b.aggregate?(ann2.content)
+
+        assert b.annotation?(ann3)
+        assert b.aggregate?(ann3.content)
+      end
+    end
+  end
+
+  def test_add_content_annotations_to_uri
+    Dir.mktmpdir do |dir|
+      filename = File.join(dir, "test.bundle")
+
+      uri1 = "http://www.example.com/example1"
+      uri2 = "http://www.example.com/example2"
+      content = File.read($man_ex3)
+
+      ROBundle::File.create(filename) do |b|
+        b.add_aggregate(uri2)
+
+        ann = b.add_annotation(uri1, content)
+        b.add_annotation(uri1, content, :aggregate => true)
+        b.add_annotation(uri2, content)
+
+        assert ann.instance_of?(ROBundle::Annotation)
+
+        ann1, ann2, ann3 = b.annotations
+
+        assert b.annotation?(ann1.annotation_id)
+        refute b.aggregate?(ann1.content)
+        assert_equal content, b.file.read(".ro/#{ann1.content}")
+
+        assert b.annotation?(ann2.annotation_id)
+        assert b.aggregate?(ann2.content)
+        assert_equal content, b.file.read(ann2.content)
+
+        assert b.annotation?(ann3)
+        refute b.aggregate?(ann3.content)
+        assert_equal content, b.file.read(".ro/#{ann3.content}")
+      end
+
+      ROBundle::File.open(filename) do |b|
+        refute b.aggregates.empty?
+        refute b.annotations.empty?
+        refute b.commit_required?
+
+        ann1, ann2, ann3 = b.annotations
+
+        assert b.annotation?(ann1.annotation_id)
+        refute b.aggregate?(ann1.content)
+        assert_equal content, b.file.read(".ro/#{ann1.content}")
+
+        assert b.annotation?(ann2.annotation_id)
+        assert b.aggregate?(ann2.content)
+        assert_equal content, b.file.read(ann2.content)
+
+        assert b.annotation?(ann3)
+        refute b.aggregate?(ann3.content)
+        assert_equal content, b.file.read(".ro/#{ann3.content}")
+      end
+    end
+  end
+
+  def test_add_file_annotations_to_annotation
+    Dir.mktmpdir do |dir|
+      filename = File.join(dir, "test.bundle")
+
+      ro = "/"
+      uri = "http://www.example.com"
+      annotation1 = ROBundle::Annotation.new(ro)
+      annotation2 = ROBundle::Annotation.new(ro, uri)
+      entry = "test_1.json"
+
+      ROBundle::File.create(filename) do |b|
+        b.add_aggregate(entry, $man_ex3)
+        b.add_annotation(annotation1)
+        b.add_annotation(annotation2)
+
+        ann = b.add_annotation(annotation1.annotation_id, $man_ex3)
+        b.add_annotation(annotation1, $man_ex3, :aggregate => true)
+        b.add_annotation(annotation2, entry)
+
+        assert ann.instance_of?(ROBundle::Annotation)
+
+        _, _, ann1, ann2, ann3 = b.annotations
+
+        assert b.annotation?(ann1.annotation_id)
+        refute b.aggregate?(ann1.content)
+
+        assert b.annotation?(ann2.annotation_id)
+        assert b.aggregate?(ann2.content)
+
+        assert b.annotation?(ann3)
+        assert b.aggregate?(ann3.content)
+      end
+
+      ROBundle::File.open(filename) do |b|
+        refute b.aggregates.empty?
+        refute b.annotations.empty?
+        refute b.commit_required?
+
+        _, _, ann1, ann2, ann3 = b.annotations
+
+        assert b.annotation?(ann1.annotation_id)
+        refute b.aggregate?(ann1.content)
+
+        assert b.annotation?(ann2.annotation_id)
+        assert b.aggregate?(ann2.content)
+
+        assert b.annotation?(ann3)
+        assert b.aggregate?(ann3.content)
+      end
+    end
+  end
+
+  def test_add_uri_annotations_to_annotation
+    Dir.mktmpdir do |dir|
+      filename = File.join(dir, "test.bundle")
+
+      ro = "/"
+      uri = "http://www.example.com"
+      annotation = ROBundle::Annotation.new(ro, uri)
+      uri1 = "http://www.example.com/example1"
+      uri2 = URI.parse("http://www.example.com/example2")
+      uri3 = "http://www.example.com/example3"
+
+      ROBundle::File.create(filename) do |b|
+        b.add_aggregate(uri3)
+        b.add_annotation(annotation)
+
+        ann = b.add_annotation(annotation, uri1)
+        b.add_annotation(annotation, uri2, :aggregate => true)
+        b.add_annotation(annotation, uri3)
+
+        assert ann.instance_of?(ROBundle::Annotation)
+
+        _, ann1, ann2, ann3 = b.annotations
+
+        assert b.annotation?(ann1.annotation_id)
+        refute b.aggregate?(ann1.content)
+
+        assert b.annotation?(ann2.annotation_id)
+        assert b.aggregate?(ann2.content)
+
+        assert b.annotation?(ann3)
+        assert b.aggregate?(ann3.content)
+      end
+
+      ROBundle::File.open(filename) do |b|
+        refute b.aggregates.empty?
+        refute b.annotations.empty?
+        refute b.commit_required?
+
+        _, ann1, ann2, ann3 = b.annotations
+
+        assert b.annotation?(ann1.annotation_id)
+        refute b.aggregate?(ann1.content)
+
+        assert b.annotation?(ann2.annotation_id)
+        assert b.aggregate?(ann2.content)
+
+        assert b.annotation?(ann3)
+        assert b.aggregate?(ann3.content)
+      end
+    end
+  end
+
+  def test_add_content_annotations_to_annotation
+    Dir.mktmpdir do |dir|
+      filename = File.join(dir, "test.bundle")
+
+      ro = "/"
+      uri = "http://www.example.com"
+      annotation = ROBundle::Annotation.new(ro, uri)
+      content = File.read($man_ex3)
+
+      ROBundle::File.create(filename) do |b|
+        b.add_annotation(annotation)
+
+        ann = b.add_annotation(annotation, content)
+        b.add_annotation(annotation, content, :aggregate => true)
+
+        assert ann.instance_of?(ROBundle::Annotation)
+
+        _, ann1, ann2 = b.annotations
+
+        assert b.annotation?(ann1.annotation_id)
+        refute b.aggregate?(ann1.content)
+        assert_equal content, b.file.read(".ro/#{ann1.content}")
+
+        assert b.annotation?(ann2.annotation_id)
+        assert b.aggregate?(ann2.content)
+        assert_equal content, b.file.read(ann2.content)
+      end
+
+      ROBundle::File.open(filename) do |b|
+        refute b.aggregates.empty?
+        refute b.annotations.empty?
+        refute b.commit_required?
+
+        _, ann1, ann2 = b.annotations
+
+        assert b.annotation?(ann1.annotation_id)
+        refute b.aggregate?(ann1.content)
+        assert_equal content, b.file.read(".ro/#{ann1.content}")
+
+        assert b.annotation?(ann2.annotation_id)
+        assert b.aggregate?(ann2.content)
+        assert_equal content, b.file.read(ann2.content)
+      end
+    end
+  end
+
+end