qa 4.0.0 → 4.1.0

data/lib/generators/qa/install/templates/config/initializers/qa.rb

@@ -14,4 +14,8 @@ Qa.config do |config|
   # For linked data access, specify default language for sorting and selection.  The default is only used if a language is not
   # specified in the authority's configuration file and not passed in as a parameter.  (e.g. :en, [:en], or [:en, :fr])
   # config.default_language = :en
+
+  # When true, prevents ldpath requests from making additional network calls.  All values will come from the context graph
+  # passed to the ldpath request.
+  # config.limit_ldpath_to_context = true
 end

data/lib/qa.rb

@@ -24,6 +24,12 @@ module Qa
     @config
   end
 
+  def self.deprecation_warning(in_msg: nil, msg:)
+    return if Rails.env == 'test'
+    in_msg = in_msg.present? ? "In #{in_msg}, " : ''
+    warn "[DEPRECATED] #{in_msg}#{msg}  It will be removed in the next major release."
+  end
+
   # Raised when the configuration directory for local authorities doesn't exist
   class ConfigDirectoryNotFound < StandardError; end
 

data/lib/qa/authorities.rb

@@ -21,4 +21,6 @@ module Qa::Authorities
   autoload :AssignFastSubauthority
   autoload :Crossref
   autoload :LinkedData
+  autoload :Discogs
+  autoload :DiscogsSubauthority
 end

data/lib/qa/authorities/discogs.rb

@@ -0,0 +1,28 @@
+module Qa::Authorities
+  # Provide authority namespace
+  module Discogs
+    extend ActiveSupport::Autoload
+    autoload :GenericAuthority
+    autoload :DiscogsTranslation
+    autoload :DiscogsUtils
+    autoload :DiscogsWorksBuilder
+    autoload :DiscogsInstanceBuilder
+
+    extend AuthorityWithSubAuthority
+    extend DiscogsSubauthority
+
+    require 'qa/authorities/discogs/generic_authority'
+    # Create an authority object for given subauthority
+    #
+    # @param [String] subauthority to use
+    # @return [GenericAuthority]
+    def self.subauthority_for(subauthority)
+      validate_subauthority!(subauthority)
+      GenericAuthority.new(subauthority)
+    end
+
+    def self.subauthorities
+      authorities
+    end
+  end
+end

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

@@ -0,0 +1,145 @@
+require 'rdf'
+module Qa::Authorities
+  module Discogs
+    module DiscogsInstanceBuilder
+      include Discogs::DiscogsUtils
+
+      # @param [Hash] the http response from discogs
+      # @return [Array] rdf statements
+      def get_format_stmts(response)
+        stmts = []
+        # The Discogs formats array contains several types of information: the "name" field defines the type of
+        # audio disc (e.g., CD vs vinyl), and the "descriptions" field can contain the playing speed, playback
+        # and release information. Process the "name" field first, then the "descriptions"
+        # In unusual cases, there can be multiple playing speeds. Need to distinguish among them.
+        count = 1
+        return stmts unless response["formats"].present?
+        response["formats"].each do |format|
+          stmts.concat(build_format_name_stmts(format["name"]))
+          # Now process playing speed, playback channel and release info
+          stmts.concat(build_format_desc_stmts(format["descriptions"], count))
+          count += 1
+        end
+        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_labels_stmts(response)
+        stmts = []
+        # Various roles are defined as provision activities, such as the record company (or label),
+        # the publishing house, the recording studio, etc. These are defined separately in the Discogs
+        # data, so combine them into a single array to be processed in one iteration.
+        provision_activity_array = response["labels"] if response["labels"].present?
+        provision_activity_array += response["companies"] if response["companies"].present?
+        stmts += build_provision_activity_stmts(provision_activity_array) if provision_activity_array.present?
+        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_identifiers_stmts(response)
+        stmts = []
+        # The Discogs data includes identifiers such as side label codes and rights society codes.
+        count = 1
+        return stmts unless response["identifiers"].present?
+        response["identifiers"].each do |activity|
+          stmts << contruct_stmt_uri_object("Instance1", "http://id.loc.gov/ontologies/bibframe/identifiedBy", "Identifier#{count}")
+          stmts << contruct_stmt_uri_object("Identifier#{count}", rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/Identifier")
+          stmts << contruct_stmt_literal_object("Identifier#{count}", rdfs_label_predicate, activity["value"])
+          count += 1
+        end
+        stmts # w/out this line, building the graph throws an undefined method `graph_name=' error
+      end
+
+      # @param [Array] format descriptions discogs
+      # @param [Integer] incremented on the call from get_format_stmts
+      # @return [Array] rdf statements
+      def build_format_desc_stmts(descs, count)
+        stmts = []
+        return stmts unless descs.present?
+        descs.each do |desc|
+          # map discogs description field to the corresponding LOC type
+          df = discogs_formats[desc.gsub(/\s+/, "")]
+          if df.present?
+            stmts += build_format_characteristics(df, count)
+          else
+            stmts << contruct_stmt_literal_object("Instance1", "http://id.loc.gov/ontologies/bibframe/editionStatement", desc)
+          end
+        end
+        stmts
+      end
+
+      # @param [Hash] discogs format descriptions "translated" to BIBFRAME terms
+      # @param [Integer] incremented on the call from build_format_desc_stmts
+      # @return [Array] rdf statements
+      def build_format_characteristics(df, count)
+        stmts = []
+        case df["type"]
+        when "playbackChannel"
+          stmts << contruct_stmt_uri_object("Instance1", "http://id.loc.gov/ontologies/bibframe/soundCharacteristic", df["uri"])
+          stmts << contruct_stmt_uri_object(df["uri"], rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/PlaybackChannel")
+          stmts << contruct_stmt_literal_object(df["uri"], rdfs_label_predicate, df["label"])
+        when "dimension"
+          stmts << contruct_stmt_uri_object("Instance1", "http://id.loc.gov/ontologies/bibframe/dimensions", df["label"])
+        when "playingSpeed"
+          stmts << contruct_stmt_uri_object("Instance1", "http://id.loc.gov/ontologies/bibframe/soundCharacteristic", "PlayingSpeed#{count}")
+          stmts << contruct_stmt_uri_object("PlayingSpeed#{count}", rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/PlayingSpeed")
+          stmts << contruct_stmt_literal_object("PlayingSpeed#{count}", rdfs_label_predicate, df["label"])
+        end
+        stmts # w/out this line, building the graph throws an undefined method `graph_name=' error
+      end
+
+      # map discogs name field to the corresponding LOC carrier
+      # @param [String] format name
+      # @return [Array] rdf statements
+      def build_format_name_stmts(name)
+        stmts = []
+        return stmts unless name.present?
+        dc = discogs_formats[name.gsub(/\s+/, "")]
+        if dc.present?
+          stmts << contruct_stmt_uri_object("Instance1", "http://id.loc.gov/ontologies/bibframe/carrier", dc["uri"])
+          stmts << contruct_stmt_uri_object(dc["uri"], rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/Carrier")
+          stmts << contruct_stmt_literal_object(dc["uri"], rdfs_label_predicate, dc["label"])
+          stmts.concat(build_base_materials(name))
+        else
+          # if it's not a carrier, it's an edition statement
+          stmts << contruct_stmt_literal_object("Instance1", "http://id.loc.gov/ontologies/bibframe/editionStatement", name)
+        end
+        stmts # w/out this line, building the graph throws an undefined method `graph_name=' error
+      end
+
+      # @param [String] format name
+      # @return [Array] rdf statements
+      def build_base_materials(name)
+        stmts = []
+        return stmts unless name == "Vinyl" || name == "Shellac"
+        id = name == "Vinyl" ? "300014502" : "300014918"
+
+        stmts << contruct_stmt_uri_object("Instance1", "http://id.loc.gov/ontologies/bibframe/baseMaterial", "http://vocab.getty.edu/aat/" + id)
+        stmts << contruct_stmt_uri_object("http://vocab.getty.edu/aat/" + id, rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/BaseMaterial")
+        stmts << contruct_stmt_literal_object("http://vocab.getty.edu/aat/" + id, rdfs_label_predicate, name)
+        stmts # w/out this line, building the graph throws an undefined method `graph_name=' error
+      end
+
+      # @param [Array] discogs roles "translated" into BIBFRAME provisional activities
+      # @return [Array] rdf statements
+      def build_provision_activity_stmts(activities)
+        stmts = []
+        # need to distinguish among different provision activities and roles
+        count = 1
+        activities.each do |activity|
+          stmts << contruct_stmt_uri_object("Instance1", "http://id.loc.gov/ontologies/bibframe/provisionActivity", "ProvisionActivity#{count}")
+          stmts << contruct_stmt_uri_object("ProvisionActivity#{count}", rdf_type_predicate, "http://id.loc.gov/ontologies/bibframe/ProvisionActivity")
+          stmts << contruct_stmt_uri_object("ProvisionActivity#{count}", bf_agent_predicate, activity["name"])
+          stmts << contruct_stmt_uri_object(activity["name"], rdf_type_predicate, bf_agent_type_object)
+          stmts << contruct_stmt_uri_object(activity["name"], bf_role_predicate, "PA_Role#{count}")
+          stmts << contruct_stmt_uri_object("PA_Role#{count}", rdf_type_predicate, bf_role_type_object)
+          stmts << contruct_stmt_literal_object("PA_Role#{count}", rdfs_label_predicate, activity["entity_type_name"])
+          count += 1
+        end
+        stmts # w/out this line, building the graph throws an undefined method `graph_name=' error
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+require 'rdf'
+module Qa::Authorities
+  module Discogs
+    module DiscogsTranslation
+      include Discogs::DiscogsUtils
+      include Discogs::DiscogsWorksBuilder
+      include Discogs::DiscogsInstanceBuilder
+
+      # Returns modified Discogs data in json-ld format. The data is first structured as RDF
+      # statements that use the BIBFRAME ontology. Where applicable, Discogs terms are mapped
+      # 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 = "")
+        graph = RDF::Graph.new
+
+        rdf_statements = compile_rdf_statements(response, subauthority)
+        graph.insert_statements(rdf_statements)
+
+        graph.dump(:jsonld, standard_prefixes: true)
+      end
+
+      # @param [Hash] the http response from discogs
+      # @param [String] the subauthority
+      # @return [Array] rdf statements
+      def compile_rdf_statements(response, subauthority)
+        complete_rdf_stmts = []
+        # The necessary statements depend on the subauthority. If the subauthority is master,
+        # 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)
+          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
+          # 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.
+          complete_rdf_stmts.concat(build_instance_statements(response))
+        end
+      end
+
+      # @param [Hash] the http response from discogs
+      # @param [String] the subauthority
+      # @return [Boolean] returns true if the subauthority is "master" or the response contains a master
+      def master_only(response, subauthority)
+        return true if subauthority == "master"
+        return true if response["main_release"].present?
+        false
+      end
+
+      # @param [Hash] the http response from discogs
+      # @return [Array] rdf statements
+      def build_master_statements(response)
+        # get the statements that define the primary work
+        master_stmts = get_primary_work_definition(response)
+        master_stmts.concat(get_primary_artists_stmts(response))
+        master_stmts.concat(get_extra_artists_stmts(response))
+        master_stmts.concat(get_genres_stmts(response))
+        # get the statements that define the secondary works by converting the tracklist
+        master_stmts.concat(get_tracklist_artists_stmts(response))
+      end
+
+      # @param [Hash] the http response from discogs
+      # @return [Array] rdf statements
+      def build_instance_statements(response)
+        # get the statements that define the instance
+        instance_stmts = get_primary_instance_definition(response)
+        instance_stmts.concat(get_format_stmts(response))
+        instance_stmts.concat(get_labels_stmts(response))
+        instance_stmts.concat(get_identifiers_stmts(response))
+      end
+
+      # @param [Hash] the http response from discogs
+      # @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 # 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_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 # 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_primary_artists_stmts(response)
+        stmts = []
+        # can have multiple artists as primary contributors to the work; need to distinguish among them
+        count = 1
+        # for secondary contributors to the work
+        if response["artists"].present?
+          response["artists"].each do |artist|
+            # 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)
+            count += 1
+          end
+        end
+        stmts
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+require 'rdf'
+module Qa::Authorities
+  module Discogs
+    module DiscogsUtils
+      DISCOGS_GENRE_MAPPING = YAML.load_file(Rails.root.join("config", "discogs-genres.yml"))
+      DISCOGS_FORMATS_MAPPING = YAML.load_file(Rails.root.join("config", "discogs-formats.yml"))
+
+      # Constructs an RDF statement where the subject, predicate and object are all URIs
+      # @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
+      def contruct_stmt_uri_object(subject, predicate, object)
+        RDF::Statement(RDF::URI.new(subject), RDF::URI(predicate), RDF::URI.new(object))
+      end
+
+      # Constructs an RDF statement where the subject and predicate are URIs and the object is a literal
+      # @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 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))
+      end
+
+      # frequently used predicates and objects
+      def rdf_type_predicate
+        RDF::URI("http://www.w3.org/1999/02/22-rdf-syntax-ns#type")
+      end
+
+      def rdfs_label_predicate
+        RDF::URI("http://www.w3.org/2000/01/rdf-schema#label")
+      end
+
+      def bf_main_title_predicate
+        RDF::URI("http://id.loc.gov/ontologies/bibframe/mainTitle")
+      end
+
+      def bf_agent_predicate
+        RDF::URI("http://id.loc.gov/ontologies/bibframe/agent")
+      end
+
+      def bf_agent_type_object
+        RDF::URI("http://id.loc.gov/ontologies/bibframe/Agent")
+      end
+
+      def bf_role_predicate
+        RDF::URI("http://id.loc.gov/ontologies/bibframe/role")
+      end
+
+      def bf_role_type_object
+        RDF::URI("http://id.loc.gov/ontologies/bibframe/Role")
+      end
+
+      def discogs_genres
+        DISCOGS_GENRE_MAPPING
+      end
+
+      def discogs_formats
+        DISCOGS_FORMATS_MAPPING
+      end
+
+      # 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)
+        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 # 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
+      # @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))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,153 @@
+require 'rdf'
+module Qa::Authorities
+  module Discogs
+    module DiscogsWorksBuilder # rubocop:disable Metrics/ModuleLength
+      include Discogs::DiscogsUtils
+
+      # @param [Hash] the http response from discogs
+      # @return [Array] rdf statements
+      def get_extra_artists_stmts(response)
+        stmts = []
+        # can have multiple artists as primary contributors to the work; need to distinguish among them
+        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)
+          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)
+        stmts = []
+        all_genres = []
+        all_genres += response["genres"] if response["genres"].present?
+        all_genres += response["styles"] if response["styles"].present?
+        return stmts unless all_genres.any?
+        all_genres.each do |genre|
+          stmts.concat(build_genres(genre))
+        end
+        stmts # w/out this line, building the graph throws an undefined method `graph_name=' error
+      end
+
+      # map discogs genre to LOC genreForm
+      # @param [String] the name of a discogs style or genre
+      # @return [Array] rdf statements
+      def build_genres(genre)
+        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(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)
+        stmts = []
+        # individual tracks become secondary works; need to distinguish among them
+        w_count = 2
+        return stmts unless response["tracklist"].present?
+        response["tracklist"].each do |track|
+          stmts.concat(build_secondary_works(track, w_count))
+          # If the Discogs data includes the primary artists for each track, use those. If not,
+          # use the primary artists that are associated with the main work
+          artist_array = build_artist_array(track["artists"])
+          stmts.concat(build_track_artists(artist_array, w_count))
+          stmts.concat(build_track_extraartists(track["extraartists"], w_count)) if track["extraartists"].present?
+          w_count += 1
+        end
+        stmts # w/out this line, building the graph throws an undefined method `graph_name=' error
+      end
+
+      # If the tracklist does not include the primary artists, use the ones defined at the master or release level
+      # @param [Array] artists from discogs
+      # @return [Array] either the tracklist "artists" or the primary artists
+      def build_artist_array(artists)
+        artists.present? ? artists : primary_artists
+      end
+
+      # @param [Hash] discogs artists associated with the main work (master or release)
+      # @param [Integer] used to give unique URIS for works
+      # @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 # w/out this line, building the graph throws an undefined method `graph_name=' error
+      end
+
+      # @param [Array] discogs artists associated with the main work (master or release)
+      # @param [Integer] used to give unique URIS for works and primary contributions
+      # @return [Array] rdf statements
+      def build_track_artists(artists, w_count)
+        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)
+          count += 1
+        end
+        stmts # w/out this line, building the graph throws an undefined method `graph_name=' error
+      end
+
+      # @param [Array] discogs extraartists associated with a track
+      # @param [Integer] used to give unique URIS for works, contributions and roles
+      # @return [Array] rdf statements
+      def build_track_extraartists(extraartists, w_count)
+        stmts = []
+        # 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"])
+          count += 1
+        end
+        stmts # w/out this line, building the graph throws an undefined method `graph_name=' error
+      end
+    end
+  end
+end