annotations2triannon 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bf8a8db6a0fce3d99033b5a6f5c06c48debc16ce
-  data.tar.gz: e76a1f81fc653fad3e592fe7696a490aa288ddf0
+  metadata.gz: e6da8313a7eb7e9653bd04afc165aa32c943fa9c
+  data.tar.gz: aa993a96c3a0d55eb4285a418dcec875c1cd93e2
 SHA512:
-  metadata.gz: d4f8be59545e4488c5afbad2110d607780220a605979f07e50a3665a9aeeacee70b1d97a2e27afd6e1f4c59c920b7df8657f86e39703a93d1b30a769ca52236b
-  data.tar.gz: c9cb96aa7143d99a650fe8e0d3fd8e93ba74b982807c349dbeea599eb6a2cfa03dd9fbce2838efce347217234bf7b8eb9c793e8dda2e140b905f94c73152810f
+  metadata.gz: fe085e82fa5c59527a126a00c59247eb98106117ba67367b83cad3b9b4db9dcda2182c1f8ad56dd8366c9da815d6b596dc064585d5adf992a1e5db72f1121c78
+  data.tar.gz: 1497a34f9cea9f48b0c583fa9d2ece23b3c16d68215e0ba728ad2caaf94c9980b2083d773fd16d436aa5b56807d12f9c2a0f61bb7466844b8166cbbb2eb833d9

data/.env_example

@@ -10,6 +10,7 @@ export DEBUG=false
 
 # limit the depth of IIIF navigation; useful for development
 # or testing a new data source.
+export ANNO_LIMIT_RANDOM=true   # use 0..limit or random sampling?
 export ANNO_LIMIT_MANIFESTS=0   # 0 is all of them
 export ANNO_LIMIT_ANNOLISTS=0   # 0 is all of them
 export ANNO_LIMIT_OPENANNOS=0   # 0 is all of them
@@ -21,9 +22,8 @@ export ANNO_LOG_FILE='log/annotations2triannon.log'
 # http://rtomayko.github.io/rack-cache/storage
 export RACK_CACHE_ENABLED=true
 export RACK_CACHE_VERBOSE=false
-export RACK_CACHE_METASTORE='memcached://localhost:11211/anno_meta'
-#export RACK_CACHE_METASTORE='file:/tmp/cache/anno_meta'
-export RACK_CACHE_ENTITYSTORE='file:/tmp/cache/anno_body'
+export RACK_CACHE_METASTORE='file:tmp/cache/anno_meta'
+export RACK_CACHE_ENTITYSTORE='file:tmp/cache/anno_body'
 
 # Configure the triannon service
 export TRIANNON_LOG_FILE='log/triannon_client.log'

data/annotations2triannon.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'annotations2triannon'
-  s.version     = '0.3.0'
+  s.version     = '0.4.0'
   s.licenses    = ['Apache-2.0']
   s.platform    = Gem::Platform::RUBY
 

data/bin/dms.rb

@@ -59,67 +59,14 @@ end
 # -----------------------------------------------------------------------
 # Annotation tracking using a file
 
-ANNO_TRACKING_FILE = File.join(CONFIG.log_path, 'dms_annotation_tracking.json')
-
-# persist the anno_tracking data to a file
-# @param anno_data [Hash]
-def anno_tracking_save(anno_data)
-  begin
-    dump_json(ANNO_TRACKING_FILE, anno_data)
-    puts "Annotation records updated in: #{ANNO_TRACKING_FILE}"
-  rescue
-    msg = "FAILURE to save annotation tracking file #{ANNO_TRACKING_FILE}"
-    CONFIG.logger.error(msg)
-  end
-end
+anno_file = 'dms_annotation_tracking.json'
+anno_tracker = Annotations2triannon::AnnotationTracker.new(anno_file)
 
-# retrieve the anno_tracking data from a file
-# @returns anno_data [Hash]
-def anno_tracking_load
-  data = {}
-  begin
-    if File.exists? ANNO_TRACKING_FILE
-      if File.size(ANNO_TRACKING_FILE).to_i > 0
-        data = JSON.parse( File.read(ANNO_TRACKING_FILE) )
-      end
-    end
-  rescue
-    msg = "FAILURE to load annotation tracking file #{ANNO_TRACKING_FILE}"
-    CONFIG.logger.error(msg)
-  end
-  return data
-end
-
-
-# -----------------------------------------------------------------------
 # DELETE previous annotations on triannon
-
 puts "\nAnnotation cleanup:"
-anno_tracking = anno_tracking_load
-anno_uris = []
-anno_tracking.each_pair do |manifest_uri, anno_lists|
-  anno_lists.each_pair do |anno_list_uri, anno_list|
-    anno_list.each do |anno_data|
-      anno_uris << RDF::URI.new(anno_data['uri'])
-    end
-  end
-end
-anno_ids = anno_uris.collect {|uri| tc.annotation_id(uri) }
-unless anno_ids.empty?
-  # Find the intersection of the DMS annotations previously
-  # created in triannon and the current set of annotations in triannon.
-  graph = tc.get_annotations
-  uris = tc.annotation_uris(graph)
-  ids = uris.collect {|uri| tc.annotation_id(uri)}
-  annos_to_remove = anno_ids & ids # intersection of arrays
-  annos_to_remove.each do |id|
-    success = tc.delete_annotation(id)
-    CONFIG.logger.error("FAILURE to delete #{id}") unless success
-  end
-end
-# Clear the record of the saved annotations
-anno_tracking_save({})
-
+anno_tracker.delete_annotations
+anno_tracker.archive
+anno_tracker.save({})
 
 # -----------------------------------------------------------------------
 # Loading IIIF annotations from a collection
@@ -194,10 +141,10 @@ text_annotations.each_pair do |m,anno_lists|
         CONFIG.logger.error("FAILURE to POST #{oa.id}")
       end
     end
-    anno_tracking_save(anno_tracking)
+    anno_tracker.save(anno_tracking)
   end
 end
-anno_tracking_save(anno_tracking)
+anno_tracker.save(anno_tracking)
 
 
 

data/lib/annotations2triannon/annotation_list.rb

@@ -23,7 +23,7 @@ module Annotations2triannon
       return @open_annotations unless @open_annotations.nil?
       begin
         oa_graphs = collect_open_annotations
-        oa_graphs = oa_graphs.sample(@@config.limit_openannos) if @@config.limit_openannos > 0
+        oa_graphs = @@config.array_sampler(oa_graphs, @@config.limit_openannos)
         oa_graphs.collect {|oa| Annotations2triannon::OpenAnnotation.new(oa)}
       rescue => e
         binding.pry if @@config.debug

data/lib/annotations2triannon/annotation_tracker.rb

@@ -0,0 +1,151 @@
+
+module Annotations2triannon
+
+  # Annotation tracking
+  class AnnotationTracker
+
+    attr_accessor :anno_file
+    attr_accessor :config
+
+    def initialize(file_name='anno_tracking.json')
+      @config = Annotations2triannon.configuration
+      @anno_file = File.join(@config.log_path, file_name)
+      FileUtils.touch @anno_file
+    end
+
+    # Save the current tracking file to an archive file tagged by timestamp
+    def archive
+      # Date and time of day for calendar date (basic)
+      # %Y%m%dT%H%M%S%z  => 20071119T083748-0600
+      time_stamp = DateTime.now.strftime('%Y%m%dT%H%M%S%z')
+      ext = File.extname(@anno_file)
+      archive = @anno_file.sub(ext, "_#{time_stamp}#{ext}")
+      FileUtils.copy(@anno_file, archive)
+    end
+
+    # retrieve the anno_tracking data from a file
+    # @returns data [Hash]
+    def load
+      begin
+        json_load(@anno_file) || {}
+      rescue
+        msg = "FAILURE to load annotation tracking file #{@anno_file}"
+        @config.logger.error(msg)
+        {}
+      end
+    end
+
+    # Retrieve the annotation URIs from an anno_tracking data file
+    # Assumes the annotation tracking data is a hash with a structure:
+    # {
+    #   manifest_uri: [annotation_list, annotation_list, ]
+    # }
+    # where each annotation_list is a hash with a structure:
+    # {
+    #   anno_list_uri: [annotations, annotations, ]
+    # }
+    # where annotations is an array of hashes, with a structure:
+    # {
+    #      uri: uri,
+    #      chars: body_content_chars
+    # }
+    # and the uri is a triannon annotation URI.
+    # @returns data [Hash]
+    # @returns uris [Array<RDF::URI>] An array of URIs to delete from triannon
+    def load_uris
+      uris = []
+      data = load
+      data.each_pair do |manifest_uri, anno_lists|
+        anno_lists.each_pair do |anno_list_uri, anno_list|
+          anno_list.each do |anno_data|
+            uris << RDF::URI.new(anno_data['uri'])
+          end
+        end
+      end
+      uris
+    end
+
+    # persist the anno_tracking data to a file
+    # @param data [Hash]
+    # @return success [Boolean]
+    def save(data)
+      begin
+        json_save(@anno_file, data)
+        puts "Annotation records updated in: #{@anno_file}"
+        return true
+      rescue
+        msg = "FAILURE to save annotation tracking file #{@anno_file}"
+        @config.logger.error(msg)
+        return false
+      end
+    end
+
+    # DELETE previous annotations loaded to triannon
+    # Accepts an input array of annotation URIs or finds them in the
+    # annotation tracking data and removes them from triannon (if they exist).
+    # Logs warnings or errors for annotations that do not exist or fail to DELETE.
+    # @parameter uris [Array<RDF::URI>] An array of URIs to delete from triannon
+    # @return status [Boolean]
+    def delete_annotations(uris=[])
+      raise ArgumentError, 'uris must be an Array<RDF::URI>' unless uris.instance_of? Array
+      tc = TriannonClient::TriannonClient.new
+      status = true
+      uris = load_uris if uris.empty?
+      anno_ids = uris.collect {|uri| tc.annotation_id(uri) }
+      # TODO: Enable intersection code below when a better set of annotations
+      # can be retrieved from triannon and/or Solr.
+      anno_ids.each do |id|
+        unless tc.delete_annotation(id)
+          @config.logger.error("FAILURE to delete #{id}")
+          status = false
+        end
+      end
+      return status
+
+      # Find the intersection of the annotation URIs and
+      # the current set of annotations in triannon.
+      # Note: the triannon /annotations response may be a limited subset of
+      # annotations that does not include any of the previously submitted
+      # annotation IDs.  If there are some annotations in the intersection,
+      # we have to assume that they are all present and proceed to delete
+      # them all.
+      # TODO: Use Solr to get a better list of current annotation URIs
+      # graph = tc.get_annotations
+      # uris = tc.annotation_uris(graph)
+      # ids = uris.collect {|uri| tc.annotation_id(uri)}
+      # annos_to_remove = anno_ids & ids # intersection of arrays
+      # if annos_to_remove.empty?
+      #   @config.logger.warn("annotations were not found in triannon.")
+      # end
+      # if annos_to_remove.length < anno_ids.length
+      #   @config.logger.warn("annotations are not current in triannon.")
+      # end
+      # annos_to_remove.each do |id|
+      #   unless tc.delete_annotation(id)
+      #     @config.logger.error("FAILURE to delete #{id}")
+      #     status = false
+      #   end
+      # end
+      # return status
+    end
+
+
+    private
+
+    def json_save(filename, data)
+      File.open(filename,'w') do |f|
+        f.write(JSON.pretty_generate(data))
+      end
+    end
+
+    def json_load(filename)
+      if File.exists? filename
+        if File.size(filename).to_i > 0
+          JSON.parse( File.read(filename) )
+        end
+      end
+    end
+
+  end
+
+end

data/lib/annotations2triannon/configuration.rb

@@ -8,6 +8,7 @@ module Annotations2triannon
     attr_reader :logger
 
     attr_accessor :debug
+    attr_accessor :limit_random
     attr_accessor :limit_manifests
     attr_accessor :limit_annolists
     attr_accessor :limit_openannos
@@ -18,7 +19,8 @@ module Annotations2triannon
       @debug = env_boolean('DEBUG')
       logger_init
 
-      # In development, enable options for random sampling the data
+      # In development, enable options for sampling the data
+      @limit_random = env_boolean('ANNO_LIMIT_RANDOM') # 0..limit or random sampling
       @limit_manifests = ENV['ANNO_LIMIT_MANIFESTS'].to_i # 0 disables sampling
       @limit_annolists = ENV['ANNO_LIMIT_ANNOLISTS'].to_i # 0 disables sampling
       @limit_openannos = ENV['ANNO_LIMIT_OPENANNOS'].to_i # 0 disables sampling
@@ -27,6 +29,27 @@ module Annotations2triannon
       redis_init
     end
 
+    # Utility method for sampling annotation arrays, using either linear or
+    # random sampling of a subset of elements.  The instance variable
+    # .limit_random is a configuration parameter that defines whether
+    # linear or random sampling is used.
+    # @param array [Array] An array to be sampled
+    # @param limit [Integer] The number of elements to sample
+    # @returns array [Array] A subset of the input array
+    def array_sampler(array, limit=0)
+      if limit > 0
+        if @limit_random
+          array.sample(limit)
+        else
+          limit = limit - 1
+          array[0..limit]
+        end
+      else
+        array
+      end
+    end
+
+
     private
 
     def env_boolean(var)

data/lib/annotations2triannon/iiif_collection.rb

@@ -38,8 +38,7 @@ module Annotations2triannon
 
     def manifest_uris(q)
       uris = rdf.query(q).collect {|s| s.subject }
-      uris = uris.sample(@@config.limit_manifests) if @@config.limit_manifests > 0
-      uris
+      @@config.array_sampler(uris, @@config.limit_manifests)
     end
 
     def query_iiif_manifests

data/lib/annotations2triannon/manifest.rb

@@ -76,8 +76,7 @@ module Annotations2triannon
 
     def collect_annotation_list_uris(q)
       uris = rdf.query(q).collect {|s| s.subject }
-      uris = uris.sample(@@config.limit_annolists) if @@config.limit_annolists > 0
-      uris
+      @@config.array_sampler(uris, @@config.limit_annolists)
     end
 
   end

data/lib/annotations2triannon/open_annotation.rb

@@ -18,23 +18,24 @@ module Annotations2triannon
     # @param id [UUID|URI|String] to identify an open annotation
     def initialize(graph=RDF::Graph.new, id=nil)
       @@agent ||= Annotations2triannon::AGENT
-      raise ArgumentError, 'graph must be RDF::Graph instance' unless graph.instance_of? RDF::Graph
-      if graph.empty?
-        # create a new open annotation
-        @graph = graph
-        id.nil? ? @id = get_id : @id = RDF::URI.parse(id)
-        insert_annotation
-      else
-        @graph = graph
-        raise ArgumentError, 'graph must be an open annotation' unless is_annotation?
-        id.nil? ? @id = get_id : @id = id
-      end
+      set_graph(graph)
+      # The set_graph will set @graph and also set @id, using the
+      # graph subject with RDF.type of OA.Annotation.  However, the
+      # id parameter for this init can override this default behavior,
+      # but it should be set after calling set_graph so it first has
+      # a chance to extract an ID from the graph.  Once the @id is set,
+      # the set_graph method will not touch it again.
+      @id = parse_id(id)
     end
 
-    def get_id
-      return @id unless @id.nil?
-      q = [nil, RDF.type, OA.Annotation]
-      @id = @graph.query(q).collect {|s| s.subject }.first || RDF::URI.parse(UUID.generate)
+    # @see #parse_id
+    def id=(id)
+      @id = parse_id(id)
+    end
+
+    # @see #set_graph
+    def graph=(graph)
+      set_graph(graph)
     end
 
     # @return [boolean] true if RDF.type is OA.Annotation, with OA.hasBody and OA.hasTarget
@@ -90,21 +91,11 @@ module Annotations2triannon
     end
 
     def body_graph
-      return @body_graph unless @body_graph.nil?
       g = RDF::Graph.new
       hasBody.each do |b|
         @graph.query( [b, :p, :o] ).each_statement {|s| g << s}
-        # if b.uri?
-        #   begin
-        #     b_resource = Resource.new(b)
-        #     b_resource.rdf.each_statement {|s| g << s}
-        #   rescue
-        #     # Nothing to be done here; the Resource#rdf method
-        #     # will log errors in RDF retrieval
-        #   end
-        # end
       end
-      @body_graph = g
+      g
     end
 
     def body_contentAsText
@@ -268,6 +259,43 @@ module Annotations2triannon
       @graph.dump(:ttl, standard_prefixes: true)
     end
 
+    private
+
+    # Sets the annotation ID as an RDF::URI from id, but if the id is nil, it
+    # will try to get the ID from the graph and, as a last resort, it will
+    # generate a unique ID using a UUID.
+    # @param id [URI|UUID|String] to identify an open annotation
+    def parse_id(id=nil)
+      raise ArgumentError, 'id cannot be an empty String' if (id.instance_of?(String) && id.empty?)
+      if id.nil?
+        # Try to get the ID from the graph
+        q = [nil, RDF.type, OA.Annotation]
+        id = @graph.query(q).collect {|s| s.subject }.first
+      else
+        # Try to parse the ID as an RDF::URI
+        id = RDF::URI.parse(id)
+      end
+      # As a last resort, assign a UUID so @id will not be nil; an alternative
+      # could be to assign a blank node, using RDF::Node.new;  TODO: provide a
+      # general configuration option to use blank nodes for OA graphs.
+      id ||= RDF::URI.parse(UUID.generate)
+    end
+
+    # Sets the annotation graph as an RDF::Graph
+    # @param graph [RDF::Graph]
+    def set_graph(graph)
+      raise ArgumentError, 'graph must be RDF::Graph instance' unless graph.instance_of? RDF::Graph
+      @graph = graph
+      # The following code applies consequential rules to ensure the OA has an
+      # ID and that it is an OA graph.  These rules should be invoked whenever
+      # the @graph is initialized or assigned by graph= accessor.
+      # Update the ID using the graph annotation URI, unless it is already set.
+      # The parse_id method depends on @graph to identify the graph ID.
+      @id ||= parse_id
+      # Ensure it's an open annotation; these methods depend on @id to be set.
+      insert_annotation unless is_annotation?
+    end
+
   end
 
 end

data/lib/requires.rb

@@ -10,7 +10,6 @@ require 'rest-client'
 RestClient.proxy = ENV['http_proxy'] unless ENV['http_proxy'].nil?
 RestClient.proxy = ENV['HTTP_PROXY'] unless ENV['HTTP_PROXY'].nil?
 if ENV['RACK_CACHE_ENABLED'].to_s.upcase == 'TRUE'
-  require 'dalli'
   require 'restclient/components'
   require 'rack/cache'
   # RestClient.enable Rack::CommonLogger
@@ -18,8 +17,9 @@ if ENV['RACK_CACHE_ENABLED'].to_s.upcase == 'TRUE'
   # Enable the HTTP cache to store meta and entity data according
   # to the env config values or the defaults given here.  See
   # http://rtomayko.github.io/rack-cache/configuration for available options.
-  metastore = ENV['RACK_CACHE_METASTORE'] || 'file:/tmp/cache/meta'
-  entitystore = ENV['RACK_CACHE_ENTITYSTORE'] || 'file:/tmp/cache/body'
+  metastore = ENV['RACK_CACHE_METASTORE'] || 'file:tmp/cache/meta'
+  entitystore = ENV['RACK_CACHE_ENTITYSTORE'] || 'file:tmp/cache/body'
+  require 'dalli' if ((metastore =~ /memcache/) || (entitystore =~ /memcache/))
   verbose = ENV['RACK_CACHE_VERBOSE'].to_s.upcase == 'TRUE' || false
   RestClient.enable Rack::Cache,
     :metastore => metastore, :entitystore => entitystore, :verbose => verbose
@@ -52,6 +52,7 @@ require_relative 'annotations2triannon/configuration'
 require_relative 'annotations2triannon/resource'
 require_relative 'annotations2triannon/manifest'
 require_relative 'annotations2triannon/annotation_list'
+require_relative 'annotations2triannon/annotation_tracker'
 require_relative 'annotations2triannon/iiif_collection'
 require_relative 'annotations2triannon/iiif_manifest'
 require_relative 'annotations2triannon/iiif_annotation_list'

data/spec/lib/annotations2triannon/configuration_spec.rb

@@ -8,17 +8,129 @@ module Annotations2triannon
       it 'default value is false' do
         ENV['DEBUG'] = nil
         config = Configuration.new
-        expect(config.debug).to be_falsey
+        expect(config.debug).to be false
       end
     end
-
     describe '#debug=' do
       it 'can set value' do
+        ENV['DEBUG'] = nil
         config = Configuration.new
+        expect(config.debug).to be false
         config.debug = true
         expect(config.debug).to be_truthy
       end
     end
 
+    describe '#limit_random' do
+      it 'default value is false' do
+        ENV['ANNO_LIMIT_RANDOM'] = nil
+        config = Configuration.new
+        expect(config.limit_random).to be false
+      end
+    end
+    describe '#limit_random=' do
+      it 'can set value' do
+        ENV['ANNO_LIMIT_RANDOM'] = nil
+        config = Configuration.new
+        expect(config.limit_random).to be false
+        config.limit_random = true
+        expect(config.limit_random).to be true
+      end
+    end
+
+    describe '#limit_manifests' do
+      it 'default value is zero' do
+        ENV['ANNO_LIMIT_MANIFESTS'] = nil
+        config = Configuration.new
+        expect(config.limit_manifests).to eql(0)
+      end
+    end
+    describe '#limit_manifests=' do
+      it 'can set value' do
+        ENV['ANNO_LIMIT_MANIFESTS'] = nil
+        config = Configuration.new
+        expect(config.limit_manifests).to eql(0)
+        config.limit_manifests = 10
+        expect(config.limit_manifests).to eql(10)
+      end
+    end
+
+    describe '#limit_annolists' do
+      it 'default value is zero' do
+        ENV['ANNO_LIMIT_ANNOLISTS'] = nil
+        config = Configuration.new
+        expect(config.limit_annolists).to eql(0)
+      end
+    end
+    describe '#limit_annolists=' do
+      it 'can set value' do
+        ENV['ANNO_LIMIT_ANNOLISTS'] = nil
+        config = Configuration.new
+        expect(config.limit_annolists).to eql(0)
+        config.limit_annolists = 10
+        expect(config.limit_annolists).to eql(10)
+      end
+    end
+
+    describe '#limit_openannos' do
+      it 'default value is zero' do
+        ENV['ANNO_LIMIT_OPENANNOS'] = nil
+        config = Configuration.new
+        expect(config.limit_openannos).to eql(0)
+      end
+    end
+    describe '#limit_openannos=' do
+      it 'can set value' do
+        ENV['ANNO_LIMIT_OPENANNOS'] = nil
+        config = Configuration.new
+        expect(config.limit_openannos).to eql(0)
+        config.limit_openannos = 10
+        expect(config.limit_openannos).to eql(10)
+      end
+    end
+
+    describe '#array_sampler' do
+      it 'returns input array when limit=0, regardless of sampling method' do
+        config = Configuration.new
+        array = [*0..10]
+        limit = 0
+        config.limit_random = false
+        expect(config.array_sampler(array,limit)).to eql(array)
+        config.limit_random = true
+        expect(config.array_sampler(array,limit)).to eql(array)
+      end
+      it 'returns array subset when limit>0, regardless of sampling method' do
+        config = Configuration.new
+        array = [*0..10]
+        limit = 5
+        config.limit_random = false
+        samples = config.array_sampler(array,limit)
+        expect(samples.length).to eql(limit)
+        expect(samples.length < array.length).to be true
+        config.limit_random = true
+        samples = config.array_sampler(array,limit)
+        expect(samples.length).to eql(limit)
+        expect(samples.length < array.length).to be true
+      end
+      it 'returns array[0..(limit-1)] when limit>0, without random sampling' do
+        config = Configuration.new
+        array = [*0..10]
+        limit = 5
+        config.limit_random = false
+        samples = config.array_sampler(array,limit)
+        expect(samples.length).to eql(limit)
+        expect(samples).to eql(array[0..(limit-1)])
+      end
+      it 'returns random array subset when limit>0, with random sampling' do
+        config = Configuration.new
+        array = [*0..100]
+        limit = 5
+        config.limit_random = true
+        samples = config.array_sampler(array,limit)
+        expect(samples.length).to eql(limit)
+        expect(samples).not_to eql(array[0..(limit-1)])
+      end
+    end
+
   end
 end

data/spec/lib/annotations2triannon/open_annotation_spec.rb

@@ -35,6 +35,107 @@ describe Annotations2triannon::OpenAnnotation do
       }' )
   }
 
+
+  describe 'has constants:' do
+    it 'CONTENT vocabulary for http://www.w3.org/2011/content#' do
+      const = Annotations2triannon::OpenAnnotation::CONTENT
+      expect(const).to eql RDF::Vocab::CNT
+    end
+    it 'OA vocabulary for http://www.w3.org/ns/oa#' do
+      const = Annotations2triannon::OpenAnnotation::OA
+      expect(const).to eql RDF::Vocab::OA
+    end
+    it 'IIIF_CONTEXT for http://iiif.io/api/presentation/2/context.json' do
+      const = Annotations2triannon::OpenAnnotation::IIIF_CONTEXT
+      expect(const).to be_instance_of String
+      expect(const).to include('http://iiif.io/api/presentation/2/context.json')
+    end
+    it 'OA_CONTEXT for http://www.w3.org/ns/oa.jsonld' do
+      const = Annotations2triannon::OpenAnnotation::OA_CONTEXT
+      expect(const).to be_instance_of String
+      expect(const).to include('http://www.w3.org/ns/oa.jsonld')
+    end
+  end
+
+  context '#id' do
+    it 'returns an RDF::URI' do
+      expect(g1.id).to be_a RDF::URI
+      expect(g2.id).to be_a RDF::URI
+      expect(g3.id).to be_a RDF::URI
+    end
+  end
+
+  context '#new' do
+    let(:g) { RDF::Graph.new }
+    context 'for default init' do
+      it 'sets the #id as an RDF::URI of a UUID' do
+        oa = Annotations2triannon::OpenAnnotation.new
+        expect(oa.id).to be_a RDF::URI
+        expect(UUID.validate(oa.id)).to be true
+      end
+      it 'sets the #graph as an RDF::Graph' do
+        oa = Annotations2triannon::OpenAnnotation.new
+        expect(oa.graph).to be_a RDF::Graph
+      end
+      it 'the #graph is an open annotation' do
+        oa = Annotations2triannon::OpenAnnotation.new
+        expect(oa.is_annotation?).to be true
+      end
+    end
+    context 'for init with an RDF::Graph' do
+      it 'accepts an empty RDF::Graph' do
+        oa = Annotations2triannon::OpenAnnotation.new(g)
+        expect(oa.graph).to be_a RDF::Graph
+      end
+      it 'ensures an empty RDF::Graph is an open annotation' do
+        oa = Annotations2triannon::OpenAnnotation.new(g)
+        expect(oa.is_annotation?).to be true
+      end
+      it 'ensures a graph with an RDF.type is also an open annotation' do
+        id = RDF::URI.parse(UUID.generate)
+        g << [id, RDF.type, RDF::Vocab::SKOS.Concept]
+        oa = Annotations2triannon::OpenAnnotation.new(g)
+        expect(oa.is_annotation?).to be true
+      end
+    end
+    context 'for init with an ID' do
+      it 'accepts a nil ID and sets the #id as an RDF::URI of a UUID' do
+        oa = Annotations2triannon::OpenAnnotation.new(g, nil)
+        expect(oa.id).to be_a RDF::URI
+        expect(UUID.validate(oa.id)).to be true
+      end
+      it 'accepts a String ID and parses it as an RDF::URI' do
+        id = 'abc'
+        oa = Annotations2triannon::OpenAnnotation.new(g, id)
+        expect(oa.id).to be_a RDF::URI
+        expect(oa.id).to eql RDF::URI.parse(id)
+      end
+      it 'accepts an RDF::URI and parses it as an RDF::URI' do
+        id = RDF::URI.parse('abc')
+        oa = Annotations2triannon::OpenAnnotation.new(g, id)
+        expect(oa.id).to be_a RDF::URI
+        expect(oa.id).to eql id
+      end
+      it 'accepts a UUID and parses it as an RDF::URI' do
+        id = UUID.generate
+        oa = Annotations2triannon::OpenAnnotation.new(g, id)
+        expect(oa.id).to be_a RDF::URI
+        expect(oa.id).to eql RDF::URI.parse(id)
+      end
+      it 'does NOT accept an empty String ID' do
+        expect{Annotations2triannon::OpenAnnotation.new(g, '')}.to raise_error
+      end
+    end
+  end
+
+  context '#graph' do
+    it 'returns an RDF::Graph' do
+      expect(g1.graph).to be_a RDF::Graph
+      expect(g2.graph).to be_a RDF::Graph
+      expect(g3.graph).to be_a RDF::Graph
+    end
+  end
+
   context '#annotatedBy' do
     it 'returns an array' do
       expect(g1.annotatedBy).to be_a Array

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: annotations2triannon
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Darren Weber
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-15 00:00:00.000000000 Z
+date: 2015-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -329,6 +329,7 @@ files:
 - bin/revs_annotations2csv.sh
 - lib/annotations2triannon.rb
 - lib/annotations2triannon/annotation_list.rb
+- lib/annotations2triannon/annotation_tracker.rb
 - lib/annotations2triannon/configuration.rb
 - lib/annotations2triannon/iiif_annotation_list.rb
 - lib/annotations2triannon/iiif_collection.rb