qa 4.2.0 → 4.3.0

data/lib/qa/authorities/discogs/discogs_translation.rb

@@ -11,14 +11,14 @@ module Qa::Authorities
       # to the URIs of corresponding objects in the Library of Congress vocabulary.
       # @param [Hash] the http response from discogs
       # @param [String] the subauthority
-      # @return [Array] jsonld
-      def build_graph(response, subauthority = "")
+      # @return [Array, String] requested RDF serialzation (supports: jsonld Array, n3 String, n-triples String)
+      def build_graph(response, subauthority = "", format: :jsonld)
         graph = RDF::Graph.new
 
         rdf_statements = compile_rdf_statements(response, subauthority)
         graph.insert_statements(rdf_statements)
 
-        graph.dump(:jsonld, standard_prefixes: true)
+        graph.dump(format, standard_prefixes: true)
       end
 
       # @param [Hash] the http response from discogs
@@ -30,14 +30,16 @@ module Qa::Authorities
         # all we need is a work and not an instance. If there's no subauthority, we can determine
         # if the discogs record is a master because it will have a main_release field.
         if master_only(response, subauthority)
+          self.work_uri = response["uri"].present? ? response["uri"] : response["resource_url"]
           complete_rdf_stmts.concat(build_master_statements(response))
         else
-          # If the subauthority is not "master," we need to define an instance as well as a
+          # If the subauthority is "release," we need to define an instance as well as a
           # work. If the discogs record has a master_id, fetch that and use the results to
           # build the statements for the work.
           master_resp = response["master_id"].present? ? json("https://api.discogs.com/masters/#{response['master_id']}") : response
           complete_rdf_stmts.concat(build_master_statements(master_resp))
-          # Now do the statements for the instance.
+          # Now do the statements for the release/instance.
+          self.instance_uri = response["uri"].present? ? response["uri"] : response["resource_url"]
           complete_rdf_stmts.concat(build_instance_statements(response))
         end
       end
@@ -77,11 +79,12 @@ module Qa::Authorities
       # @return [Array] rdf statements
       def get_primary_work_definition(response)
         stmts = []
-        stmts << contruct_stmt_uri_object("Work1", rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/Work")
-        stmts << contruct_stmt_uri_object("Work1", "http://id.loc.gov/ontologies/bibframe/title", "Work1Title")
-        stmts << contruct_stmt_literal_object("Work1Title", bf_main_title_predicate, response["title"])
-        stmts << contruct_stmt_uri_object("Work1", rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/Audio")
-        stmts.concat(build_year_statements(response, "Work"))
+        stmts << contruct_stmt_uri_object(work_uri, rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/Work")
+        stmts << contruct_stmt_uri_object(work_uri, "http://id.loc.gov/ontologies/bibframe/title", "titlen1")
+        stmts << contruct_stmt_literal_object("titlen1", bf_main_title_predicate, response["title"])
+        stmts << contruct_stmt_uri_object("titlen1", rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/Title")
+        stmts << contruct_stmt_uri_object(work_uri, rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/Audio")
+        stmts << contruct_stmt_literal_object(work_uri, "http://id.loc.gov/ontologies/bibframe/originDate", response["year"].to_s) if response["year"].present?
         stmts # w/out this line, building the graph throws an undefined method `graph_name=' error
       end
 
@@ -89,14 +92,14 @@ module Qa::Authorities
       # @return [Array] rdf statements
       def get_primary_instance_definition(response)
         stmts = []
-        stmts << contruct_stmt_uri_object("Work1", "http://id.loc.gov/ontologies/bibframe/hasInstance", "Instance1")
-        stmts << contruct_stmt_uri_object("Instance1", rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/Instance")
-        stmts << contruct_stmt_uri_object("Instance1", "http://id.loc.gov/ontologies/bibframe/title", "Instance1Title")
-        stmts << contruct_stmt_literal_object("Instance1Title", bf_main_title_predicate, response["title"])
-        stmts << contruct_stmt_uri_object("Instance1", "http://id.loc.gov/ontologies/bibframe/identifiedBy", "IdentifierPrimary")
-        stmts << contruct_stmt_uri_object("IdentifierPrimary", rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/Identifier")
-        stmts << contruct_stmt_literal_object("IdentifierPrimary", "http://www.w3.org/1999/02/22-rdf-syntax-ns#value", response["id"])
-        stmts.concat(build_year_statements(response, "Instance"))
+        stmts << contruct_stmt_uri_object(instance_uri, "http://id.loc.gov/ontologies/bibframe/instanceOf", work_uri)
+        stmts << contruct_stmt_uri_object(instance_uri, rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/Instance")
+        stmts << contruct_stmt_uri_object(instance_uri, "http://id.loc.gov/ontologies/bibframe/title", "titlen2")
+        stmts << contruct_stmt_literal_object("titlen2", bf_main_title_predicate, response["title"])
+        stmts << contruct_stmt_uri_object("titlen2", rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/Title")
+        stmts << contruct_stmt_uri_object(instance_uri, "http://id.loc.gov/ontologies/bibframe/identifiedBy", "widn1")
+        stmts << contruct_stmt_uri_object("widn1", rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/Identifier")
+        stmts << contruct_stmt_literal_object("widn1", "http://www.w3.org/1999/02/22-rdf-syntax-ns#value", response["id"])
         stmts # w/out this line, building the graph throws an undefined method `graph_name=' error
       end
 
@@ -112,10 +115,11 @@ module Qa::Authorities
             # we need the primary artists later when we loop through the track list, so build this array
             primary_artists << artist
 
-            stmts << contruct_stmt_uri_object("Work1", "http://id.loc.gov/ontologies/bibframe/contribution", "Work1PrimaryContribution#{count}")
-            stmts << contruct_stmt_uri_object("Work1PrimaryContribution#{count}", rdf_type_predicate, "http://id.loc.gov/ontologies/bflc/PrimaryContribution")
-            stmts << contruct_stmt_uri_object("Work1PrimaryContribution#{count}", bf_agent_predicate, artist["name"])
-            stmts << contruct_stmt_uri_object(artist["name"], rdf_type_predicate, bf_agent_type_object)
+            stmts << contruct_stmt_uri_object(work_uri, "http://id.loc.gov/ontologies/bibframe/contribution", "contrbn#{count}")
+            stmts << contruct_stmt_uri_object("contrbn#{count}", rdf_type_predicate, "http://id.loc.gov/ontologies/bflc/PrimaryContribution")
+            stmts << contruct_stmt_uri_object("contrbn#{count}", bf_agent_predicate, "agentn#{count}")
+            stmts << contruct_stmt_uri_object("agentn#{count}", rdf_type_predicate, bf_agent_type_object)
+            stmts << contruct_stmt_literal_object("agentn#{count}", rdfs_label_predicate, artist["name"])
             count += 1
           end
         end

data/lib/qa/authorities/discogs/discogs_utils.rb

@@ -9,9 +9,11 @@ module Qa::Authorities
       # @param [String] either a string used to create a unique URI or an LOC uri in string format
       # @param [String] or [Class] either a BIBFRAME property uri in string format or an RDF::URI
       # @param [String] or [Class] strings can be a label or BIBFRAME class uri; class is always RDF::URI
-      # @return [Class] RDF::Statement with uri as the object
+      # @return [Class] RDF::Statement with either a uri or a bnode as the object
       def contruct_stmt_uri_object(subject, predicate, object)
-        RDF::Statement(RDF::URI.new(subject), RDF::URI(predicate), RDF::URI.new(object))
+        s = subject.include?("http") ? RDF::URI.new(subject) : subject.to_sym
+        o = object.to_s.include?("http") ? RDF::URI.new(object) : object.to_sym
+        RDF::Statement(s, RDF::URI(predicate), o)
       end
 
       # Constructs an RDF statement where the subject and predicate are URIs and the object is a literal
@@ -20,7 +22,8 @@ module Qa::Authorities
       # @param [String] or [Class] strings can be a label or BIBFRAME class uri; class is always RDF::URI
       # @return [Class] RDF::Statement with a literal as the object
       def contruct_stmt_literal_object(subject, predicate, object)
-        RDF::Statement(RDF::URI.new(subject), RDF::URI(predicate), RDF::Literal.new(object))
+        s = subject.include?("http") ? RDF::URI.new(subject) : subject.to_sym
+        RDF::Statement(s, RDF::URI(predicate), RDF::Literal.new(object))
       end
 
       # frequently used predicates and objects
@@ -41,7 +44,7 @@ module Qa::Authorities
       end
 
       def bf_agent_type_object
-        RDF::URI("http://id.loc.gov/ontologies/bibframe/Agent")
+        "http://id.loc.gov/ontologies/bibframe/Agent"
       end
 
       def bf_role_predicate
@@ -49,7 +52,7 @@ module Qa::Authorities
       end
 
       def bf_role_type_object
-        RDF::URI("http://id.loc.gov/ontologies/bibframe/Role")
+        "http://id.loc.gov/ontologies/bibframe/Role"
       end
 
       def discogs_genres
@@ -62,27 +65,36 @@ module Qa::Authorities
 
       # both the work and the instance require a statement for the release year
       # @param [Hash] the http response from discogs
-      # @param [String] either "Work" or "Instance"
       # @return [Array] rdf statements
-      def build_year_statements(response, type)
+      def build_year_statements(response)
         year_stmts = []
-        if type == "Work" && response["year"].present?
-          year_stmts = get_year_rdf(type + "1", response["year"])
-        elsif response["released"].present?
-          year_stmts = get_year_rdf(type + "1", response["released"])
-        end
+        year_stmts << contruct_stmt_uri_object(instance_uri, "http://id.loc.gov/ontologies/bibframe/provisionActivity", "daten1")
+        year_stmts << contruct_stmt_uri_object("daten1", rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/Publication")
+        year_stmts << contruct_stmt_literal_object("daten1", RDF::URI("http://id.loc.gov/ontologies/bibframe/date"), response["released"].to_s)
         year_stmts # w/out this line, building the graph throws an undefined method `graph_name=' error
       end
 
-      # @param [String] either "Work1" or "Instance1"
-      # @param [String] 4-digit year in string format
+      # @param [Hash] the extraartists defined at the release level, not the track level
+      # @param [Integer] gives the role a unique uri
+      # @param [String] the entity type name
       # @return [Array] rdf statements
-      def get_year_rdf(type, year)
-        year_stmts = []
-        year_stmts << contruct_stmt_uri_object(type, "http://id.loc.gov/ontologies/bibframe/provisionActivity", "#{type}ProvisionActivityDate")
-        year_stmts << contruct_stmt_uri_object("#{type}ProvisionActivityDate", rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/ProvisionActivity")
-        # Full RDF statement syntax as this one requires a datatype
-        year_stmts << RDF::Statement(RDF::URI.new("#{type}ProvisionActivityDate"), RDF::URI("http://id.loc.gov/ontologies/bibframe/date"), RDF::Literal.new(year.to_s, datatype: RDF::XSD.date))
+      def build_role_stmts(subject_node, role_node, label)
+        stmts = []
+        stmts << contruct_stmt_uri_object(subject_node, bf_role_predicate, role_node)
+        stmts << contruct_stmt_uri_object(role_node, rdf_type_predicate, bf_role_type_object)
+        stmts << contruct_stmt_literal_object(role_node, rdfs_label_predicate, label)
+        stmts # w/out this line, building the graph throws an undefined method `graph_name=' error
+      end
+
+      # @param [String] the playing speed in string format
+      # @param [Integer] gives the playing speed a unique uri
+      # @return [Array] rdf statements
+      def build_playing_speed_stmts(label, count)
+        stmts = []
+        stmts << contruct_stmt_uri_object(instance_uri, "http://id.loc.gov/ontologies/bibframe/soundCharacteristic", "speed#{count}")
+        stmts << contruct_stmt_uri_object("speed#{count}", rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/PlayingSpeed")
+        stmts << contruct_stmt_literal_object("speed#{count}", rdfs_label_predicate, label)
+        stmts # w/out this line, building the graph throws an undefined method `graph_name=' error
       end
     end
   end

data/lib/qa/authorities/discogs/discogs_works_builder.rb

@@ -1,7 +1,7 @@
 require 'rdf'
 module Qa::Authorities
   module Discogs
-    module DiscogsWorksBuilder # rubocop:disable Metrics/ModuleLength
+    module DiscogsWorksBuilder
       include Discogs::DiscogsUtils
 
       # @param [Hash] the http response from discogs
@@ -12,27 +12,17 @@ module Qa::Authorities
         count = 1
         return stmts unless response["extraartists"].present?
         response["extraartists"].each do |artist|
-          stmts << contruct_stmt_uri_object("Work1", "http://id.loc.gov/ontologies/bibframe/contribution", "Work1SecondaryContribution#{count}")
-          stmts << contruct_stmt_uri_object("Work1SecondaryContribution#{count}", rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/Contribution")
-          stmts << contruct_stmt_uri_object("Work1SecondaryContribution#{count}", bf_agent_predicate, artist["name"])
-          stmts << contruct_stmt_uri_object(artist["name"], rdf_type_predicate, bf_agent_type_object)
-          stmts += build_artist_role_stmts(artist, count)
+          stmts << contruct_stmt_uri_object(work_uri, "http://id.loc.gov/ontologies/bibframe/contribution", "contrbn1#{count}")
+          stmts << contruct_stmt_uri_object("contrbn1#{count}", rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/Contribution")
+          stmts << contruct_stmt_uri_object("contrbn1#{count}", bf_agent_predicate, "agentn1#{count}")
+          stmts << contruct_stmt_uri_object("agentn1#{count}", rdf_type_predicate, bf_agent_type_object)
+          stmts << contruct_stmt_literal_object("agentn1#{count}", rdfs_label_predicate, artist["name"])
+          stmts += build_role_stmts("agentn1#{count}", "rolen1#{count}", artist["role"])
           count += 1
         end
         stmts # w/out this line, building the graph throws an undefined method `graph_name=' error
       end
 
-      # @param [Hash] the extraartists defined at the release level, not the track level
-      # @param [Integer] gives the role a unique uri
-      # @return [Array] rdf statements
-      def build_artist_role_stmts(artist, count)
-        stmts = []
-        stmts << contruct_stmt_uri_object(artist["name"], bf_role_predicate, "Work1SecondaryContributor_Role#{count}")
-        stmts << contruct_stmt_uri_object("Work1SecondaryContributor_Role#{count}", rdf_type_predicate, bf_role_type_object)
-        stmts << contruct_stmt_literal_object("Work1SecondaryContributor_Role#{count}", rdfs_label_predicate, artist["role"])
-        stmts # w/out this line, building the graph throws an undefined method `graph_name=' error
-      end
-
       # @param [Hash] the http response from discogs
       # @return [Array] rdf statements
       def get_genres_stmts(response)
@@ -54,24 +44,13 @@ module Qa::Authorities
         stmts = []
         dg = discogs_genres[genre.gsub(/\s+/, "")]
         if dg.present?
-          stmts << contruct_stmt_uri_object("Work1", "http://id.loc.gov/ontologies/bibframe/genreForm", dg["uri"])
+          stmts << contruct_stmt_uri_object(work_uri, "http://id.loc.gov/ontologies/bibframe/genreForm", dg["uri"])
           stmts << contruct_stmt_uri_object(dg["uri"], rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/GenreForm")
           stmts << contruct_stmt_literal_object(dg["uri"], rdfs_label_predicate, dg["label"])
         end
         stmts # w/out this line, building the graph throws an undefined method `graph_name=' error
       end
 
-      # @param [String] the uri of the genreForm
-      # @param [String] the genreForm label
-      # @return [Array] rdf statements
-      def build_genres_and_styles(uri, dg_label)
-        stmts = []
-        stmts << contruct_stmt_uri_object("Work1", "http://id.loc.gov/ontologies/bibframe/genreForm", uri)
-        stmts << contruct_stmt_uri_object(uri, rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/GenreForm")
-        stmts << contruct_stmt_literal_object(uri, rdfs_label_predicate, dg_label)
-        stmts # w/out this line, building the graph throws an undefined method `graph_name=' error
-      end
-
       # @param [Hash] the http response from discogs
       # @return [Array] rdf statements
       def get_tracklist_artists_stmts(response)
@@ -103,13 +82,13 @@ module Qa::Authorities
       # @return [Array] rdf statements
       def build_secondary_works(track, w_count)
         stmts = []
-        stmts << contruct_stmt_uri_object("Work1", "http://id.loc.gov/ontologies/bibframe/hasPart", "Work#{w_count}")
-        stmts << contruct_stmt_uri_object("Work#{w_count}", rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/Work")
-        stmts << contruct_stmt_uri_object("Work#{w_count}", rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/Audio")
-        stmts << contruct_stmt_uri_object("Work#{w_count}", "http://id.loc.gov/ontologies/bibframe/title", "Work#{w_count}Title")
-        stmts << contruct_stmt_uri_object("Work#{w_count}Title", rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/Title")
-        stmts << contruct_stmt_literal_object("Work#{w_count}Title", bf_main_title_predicate, track["title"])
-        stmts << contruct_stmt_literal_object("Work#{w_count}", "http://id.loc.gov/ontologies/bibframe/duration", track["duration"]) if track["duration"].present?
+        stmts << contruct_stmt_uri_object(work_uri, "http://id.loc.gov/ontologies/bibframe/hasPart", "workn#{w_count}")
+        stmts << contruct_stmt_uri_object("workn#{w_count}", rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/Work")
+        stmts << contruct_stmt_uri_object("workn#{w_count}", rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/Audio")
+        stmts << contruct_stmt_uri_object("workn#{w_count}", "http://id.loc.gov/ontologies/bibframe/title", "titlen3#{w_count}")
+        stmts << contruct_stmt_uri_object("titlen3#{w_count}", rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/Title")
+        stmts << contruct_stmt_literal_object("titlen3#{w_count}", bf_main_title_predicate, track["title"])
+        stmts << contruct_stmt_literal_object("workn#{w_count}", "http://id.loc.gov/ontologies/bibframe/duration", track["duration"]) if track["duration"].present?
         stmts # w/out this line, building the graph throws an undefined method `graph_name=' error
       end
 
@@ -120,10 +99,11 @@ module Qa::Authorities
         stmts = []
         count = 1
         artists.each do |artist|
-          stmts << contruct_stmt_uri_object("Work#{w_count}", "http://id.loc.gov/ontologies/bibframe/contribution", "Work#{w_count}PrimaryContribution#{count}")
-          stmts << contruct_stmt_uri_object("Work#{w_count}PrimaryContribution#{count}", rdf_type_predicate, "http://id.loc.gov/ontologies/bflc/PrimaryContribution")
-          stmts << contruct_stmt_uri_object("Work#{w_count}PrimaryContribution#{count}", bf_agent_predicate, artist["name"])
-          stmts << contruct_stmt_uri_object(artist["name"], rdf_type_predicate, bf_agent_type_object)
+          stmts << contruct_stmt_uri_object("workn#{w_count}", "http://id.loc.gov/ontologies/bibframe/contribution", "contrbn#{w_count}#{count}")
+          stmts << contruct_stmt_uri_object("contrbn#{w_count}#{count}", rdf_type_predicate, "http://id.loc.gov/ontologies/bflc/PrimaryContribution")
+          stmts << contruct_stmt_uri_object("contrbn#{w_count}#{count}", bf_agent_predicate, "agentn#{w_count}#{count}")
+          stmts << contruct_stmt_uri_object("agentn#{w_count}#{count}", rdf_type_predicate, bf_agent_type_object)
+          stmts << contruct_stmt_literal_object("agentn#{w_count}#{count}", rdfs_label_predicate, artist["name"])
           count += 1
         end
         stmts # w/out this line, building the graph throws an undefined method `graph_name=' error
@@ -137,13 +117,12 @@ module Qa::Authorities
         # to distinguish among contributors to a track/work and their roles
         count = 1
         extraartists.each do |artist|
-          stmts << contruct_stmt_uri_object("Work#{w_count}", "http://id.loc.gov/ontologies/bibframe/contribution", "Work#{w_count}Contribution#{count}")
-          stmts << contruct_stmt_uri_object("Work#{w_count}Contribution#{count}", rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/Contribution")
-          stmts << contruct_stmt_uri_object("Work#{w_count}Contribution#{count}", bf_agent_predicate, artist["name"])
-          stmts << contruct_stmt_uri_object(artist["name"], rdf_type_predicate, bf_agent_type_object)
-          stmts << contruct_stmt_uri_object(artist["name"], bf_role_predicate, "Work#{w_count}ContributorRole#{count}")
-          stmts << contruct_stmt_uri_object("Work#{w_count}ContributorRole#{count}", rdf_type_predicate, bf_role_type_object)
-          stmts << contruct_stmt_literal_object("Work#{w_count}ContributorRole#{count}", rdfs_label_predicate, artist["role"])
+          stmts << contruct_stmt_uri_object("workn#{w_count}", "http://id.loc.gov/ontologies/bibframe/contribution", "contrbn#{w_count}2#{count}")
+          stmts << contruct_stmt_uri_object("contrbn#{w_count}2#{count}", rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/Contribution")
+          stmts << contruct_stmt_uri_object("contrbn#{w_count}2#{count}", bf_agent_predicate, "agentn#{w_count}2#{count}")
+          stmts << contruct_stmt_uri_object("agentn#{w_count}2#{count}", rdf_type_predicate, bf_agent_type_object)
+          stmts << contruct_stmt_literal_object("agentn#{w_count}2#{count}", rdfs_label_predicate, artist["name"])
+          stmts += build_role_stmts("agentn#{w_count}2#{count}", "role2#{w_count}#{count}", artist["role"])
           count += 1
         end
         stmts # w/out this line, building the graph throws an undefined method `graph_name=' error

data/lib/qa/authorities/discogs/generic_authority.rb

@@ -1,16 +1,19 @@
 require 'rdf'
+require 'rdf/ntriples'
 module Qa::Authorities
   class Discogs::GenericAuthority < Base
     include WebServiceBase
     include Discogs::DiscogsTranslation
 
     class_attribute :discogs_secret, :discogs_key
-    attr_accessor :primary_artists
+    attr_accessor :primary_artists, :selected_format, :work_uri, :instance_uri
 
     # @param [String] subauthority to use
     def initialize(subauthority)
       @subauthority = subauthority
       self.primary_artists = []
+      self.work_uri = "workn1"
+      self.instance_uri = "instn1"
     end
 
     # @param [String] the query
@@ -35,10 +38,14 @@ module Qa::Authorities
     #
     # @param [String] the Discogs id of the selected item
     # @param [Class] QA::TermsController
-    # @return either json results or jsonld
+    # @return results in requested format (supports: json, jsonld, n3, ntriples)
     def find(id, tc)
       response = tc.params["subauthority"].include?("all") ? fetch_discogs_results(id) : json(find_url(id, tc.params["subauthority"]))
-      return build_graph(response) unless tc.params["format"] != "jsonld" || response["message"].present?
+      self.selected_format = tc.params["format"]
+      return response if response["message"].present?
+      return build_graph(response, format: :jsonld) if jsonld?(tc)
+      return build_graph(response, format: :n3) if n3?(tc)
+      return build_graph(response, format: :ntriples) if ntriples?(tc)
       response
     end
 
@@ -94,46 +101,48 @@ module Qa::Authorities
 
       # @param [Hash] the http response from discogs
       # @example returns parsed discogs data with context
-      # {
-      #   "uri": "https://api.discogs.com/releases/4212473",
-      #   "id": "4212473",
-      #   "label": "Frank Sinatra And The Modernaires - Sorry / Why Remind Me",
-      # }
-      #   "context": {
-      #     "Image URL": [
-      #       "https://img.discogs.com/2e-YoNr0dvmMgbzEN0hjHD6X0sU=/fit-in/600x580/filters:strip_icc():format(jpeg):mode_rgb():quality(90)/discogs-images/R-4212473-1358693671-5430.jpeg.jpg"
-      #     ],
-      #     "Year": [
-      #       "1950"
-      #     ],
-      #     "Record Labels": [
-      #       "Columbia"
-      #     ],
-      #     "Formats": [
-      #       "Shellac",
-      #       "10\"",
-      #       "78 RPM"
-      #     ],
-      #     "Type": [
-      #       "release"
-      #     ]
-      #   }
+      # [{
+      # 	"uri": "https://www.discogs.com/Frank-Sinatra-And-The-Modernaires-Sorry-Why-Remind-Me/release/4212473",
+      # 	"id": "4212473",
+      # 	"label": "Frank Sinatra And The Modernaires - Sorry / Why Remind Me",
+      # 	"context": [{
+      # 		"property": "Image URL",
+      # 		"values": ["https://img.discogs.com/1358693671-5430.jpeg.jpg"]
+      # 	}, {
+      # 		"property": "Year",
+      # 		"values": ["1950"]
+      # 	}, {
+      # 		"property": "Record Labels",
+      # 		"values": ["Columbia"]
+      # 	}, {
+      # 		"property": "Formats",
+      # 		"values": ["Shellac", "10\"", "78 RPM"]
+      # 	}, {
+      # 		"property": "Type",
+      # 		"values": ["release"]
+      # 	}]
+      # }]
       def parse_authority_response(response)
         response['results'].map do |result|
-          { 'uri' => result['resource_url'].to_s,
+          { 'uri' => build_uri(result),
             'id' => result['id'].to_s,
             'label' => result['title'].to_s,
             'context' => assemble_search_context(result) }
         end
       end
 
+      # @param [Hash] the results hash from the JSON returned by Discogs
+      def build_uri(result)
+        result['uri'].present? ? "https://www.discogs.com" + result['uri'].to_s : result['resource_url'].to_s
+      end
+
       # @param [Hash] the results hash from the JSON returned by Discogs
       def assemble_search_context(result)
-        { "Image URL" => get_context_for_string(result['cover_image']),
-          "Year" =>  get_context_for_string(result['year']),
-          "Record Labels" => get_context_for_array(result['label']),
-          "Formats" => get_context_for_array(result['format']),
-          "Type" => get_context_for_string(result['type']) }
+        [{ "property" => "Image URL", "values" => get_context_for_string(result['cover_image']) },
+         { "property" => "Year", "values" => get_context_for_string(result['year']) },
+         { "property" => "Record Labels", "values" => get_context_for_array(result['label']) },
+         { "property" => "Formats", "values" => get_context_for_array(result['format']) },
+         { "property" => "Type", "values" => get_context_for_string(result['type']) }]
       end
 
       # checks if the param is null, returns appropriate value
@@ -147,5 +156,27 @@ module Qa::Authorities
       def get_context_for_array(item)
         item.present? ? item : [""]
       end
+
+      def format(tc)
+        return 'json' unless tc.params.key?('format')
+        return 'json' if tc.params['format'].blank?
+        tc.params['format']
+      end
+
+      def jsonld?(tc)
+        format(tc).casecmp?('jsonld')
+      end
+
+      def n3?(tc)
+        format(tc).casecmp?('n3')
+      end
+
+      def ntriples?(tc)
+        format(tc).casecmp?('ntriples')
+      end
+
+      def graph_format?(tc)
+        jsonld?(tc) || n3?(tc) || ntriples?(tc)
+      end
   end
 end