qa 3.1.0 → 4.0.0.rc1

data/lib/qa/authorities/getty/tgn.rb

@@ -7,7 +7,7 @@ module Qa::Authorities
     end
 
     def build_query_url(q)
-      query = URI.escape(sparql(untaint(q)))
+      query = ERB::Util.url_encode(sparql(untaint(q)))
       # Replace ampersands, otherwise the query will fail
       # Gsub hack to convert the encoded regex in the REPLACE into a form Getty understands
       "http://vocab.getty.edu/sparql.json?query=#{query.gsub('&', '%26').gsub(',[%5E,]+,[%5E,]+$', '%2C[^%2C]%2B%2C[^%2C]%2B%24')}&_implicit=false&implicit=true&_equivalent=false&_form=%2Fsparql"
@@ -44,7 +44,7 @@ module Qa::Authorities
     end
 
     def find_url(id)
-      "http://vocab.getty.edu/tgn/#{id}.json"
+      "http://vocab.getty.edu/download/json?uri=http://vocab.getty.edu/tgn/#{id}.json"
     end
 
     def request_options
@@ -59,6 +59,11 @@ module Qa::Authorities
         response['results']['bindings'].map do |result|
           { 'id' => result['s']['value'], 'label' => result['name']['value'] + ' (' + result['par']['value'].gsub(/\,[^\,]+\,[^\,]+$/, '') + ')' }
         end
+      rescue StandardError => e
+        cause = response.fetch('error', {}).fetch('cause', 'UNKNOWN')
+        cause = cause.present? ? cause : 'UNKNOWN'
+        Rails.logger.warn "  ERROR fetching Getty response: #{e.message}; cause: #{cause}"
+        {}
       end
   end
 end

data/lib/qa/authorities/getty/ulan.rb

@@ -8,7 +8,7 @@ module Qa::Authorities
 
     # Replace ampersands, otherwise the query will fail
     def build_query_url(q)
-      "http://vocab.getty.edu/sparql.json?query=#{URI.escape(sparql(q)).gsub('&', '%26')}&_implicit=false&implicit=true&_equivalent=false&_form=%2Fsparql"
+      "http://vocab.getty.edu/sparql.json?query=#{ERB::Util.url_encode(sparql(q)).gsub('&', '%26')}&_implicit=false&implicit=true&_equivalent=false&_form=%2Fsparql"
     end
 
     def sparql(q) # rubocop:disable Metrics/MethodLength
@@ -42,7 +42,7 @@ module Qa::Authorities
     end
 
     def find_url(id)
-      "http://vocab.getty.edu/ulan/#{id}.json"
+      "http://vocab.getty.edu/download/json?uri=http://vocab.getty.edu/ulan/#{id}.json"
     end
 
     def request_options
@@ -57,6 +57,11 @@ module Qa::Authorities
         response['results']['bindings'].map do |result|
           { 'id' => result['s']['value'], 'label' => result['name']['value'] + ' (' + result['bio']['value'] + ')' }
         end
+      rescue StandardError => e
+        cause = response.fetch('error', {}).fetch('cause', 'UNKNOWN')
+        cause = cause.present? ? cause : 'UNKNOWN'
+        Rails.logger.warn "  ERROR fetching Getty response: #{e.message}; cause: #{cause}"
+        {}
       end
   end
 end

data/lib/qa/authorities/linked_data.rb

@@ -3,7 +3,6 @@ module Qa::Authorities
     extend ActiveSupport::Autoload
     autoload :GenericAuthority
     autoload :RdfHelper
-    autoload :AuthorityService
     autoload :SearchQuery
     autoload :FindTerm
     autoload :Config

data/lib/qa/authorities/linked_data/config.rb

@@ -1,7 +1,6 @@
 require 'qa/authorities/linked_data/config/term_config'.freeze
 require 'qa/authorities/linked_data/config/search_config'.freeze
 require 'json'
-require 'erb'
 
 # Provide attr_reader methods for linked data authority configurations.  Some default configurations are provided for several
 # linked data authorities and can be found at /config/authorities/linked_data.  You can add configurations for new authorities by
@@ -18,34 +17,42 @@ require 'erb'
 module Qa::Authorities
   module LinkedData
     class Config
-      class << self
-        include ERB::Util
-      end
-
       attr_reader :authority_name
-      attr_reader :authority_config
 
       # Initialize to hold the configuration for the specifed authority.  Configurations are defined in config/authorities/linked_data.  See README for more information.
       # @param [String] the name of the configuration file for the authority
       # @return [Qa::Authorities::LinkedData::Config] instance of this class
       def initialize(auth_name)
         @authority_name = auth_name
-        auth_config
+        authority_config
       end
 
       def search
-        @search ||= Qa::Authorities::LinkedData::SearchConfig.new(auth_config.fetch(:search))
+        @search ||= Qa::Authorities::LinkedData::SearchConfig.new(authority_config.fetch(:search), prefixes)
       end
 
       def term
-        @term ||= Qa::Authorities::LinkedData::TermConfig.new(auth_config.fetch(:term))
+        @term ||= Qa::Authorities::LinkedData::TermConfig.new(authority_config.fetch(:term), prefixes)
+      end
+
+      def prefixes
+        @prefixes ||= authority_config.fetch(:prefixes, {})
+      end
+
+      def config_version
+        @config_version ||= authority_config.fetch(:QA_CONFIG_VERSION, '1.0')
+      end
+
+      def config_version?(version)
+        config_version == version
       end
 
       # Return the full configuration for an authority
       # @return [String] the authority configuration
-      def auth_config
-        @authority_config ||= Qa::Authorities::LinkedData::AuthorityService.authority_config(@authority_name)
+      def authority_config
+        @authority_config ||= Qa::LinkedData::AuthorityService.authority_config(@authority_name)
         raise Qa::InvalidLinkedDataAuthority, "Unable to initialize linked data authority '#{@authority_name}'" if @authority_config.nil?
+        convert_1_0_to_2_0 if @authority_config.fetch(:QA_CONFIG_VERSION, '1.0') == '1.0'
         @authority_config
       end
 
@@ -61,26 +68,20 @@ module Qa::Authorities
         pred_uri
       end
 
-      def self.replace_pattern(url, pattern, value, encode = false)
-        value = url_encode(value).gsub(".", "%2E") if encode
-        url.gsub("{?#{pattern}}", value)
-      end
+      private
 
-      def self.process_subauthority(url, subauth_pattern, subauthorities, subauth_key)
-        pattern = subauth_pattern[:pattern]
-        value = subauthorities[subauth_key] || subauth_pattern[:default]
-        replace_pattern(url, pattern, value)
-      end
+        def convert_1_0_to_2_0
+          convert_1_0_url_to_2_0_url(:search)
+          convert_1_0_url_to_2_0_url(:term)
+        end
 
-      def self.apply_replacements(url, config, replacements = {})
-        return url unless config.size.positive?
-        config.each do |param_key, rep_pattern|
-          s_param_key = param_key.to_s
-          value = replacements[param_key] || replacements[s_param_key] || rep_pattern[:default]
-          url = replace_pattern(url, param_key, value, rep_pattern[:encode])
+        # @deprecated Update to linked data config version 2.0 instead
+        def convert_1_0_url_to_2_0_url(action_key)
+          url_template = @authority_config.fetch(action_key, {}).fetch(:url, {}).fetch(:template, "")
+          return if url_template.blank?
+          warn "[DEPRECATED] #Linked data configuration #{authority_name} has 1.0 version format which is deprecated; update to version 2.0 configuration."
+          @authority_config[action_key][:url][:template] = url_template.gsub("{?", "{")
         end
-        url
-      end
     end
   end
 end

data/lib/qa/authorities/linked_data/config/search_config.rb

@@ -5,9 +5,12 @@
 module Qa::Authorities
   module LinkedData
     class SearchConfig
+      attr_reader :prefixes
+
       # @param [Hash] config the search portion of the config
-      def initialize(config)
+      def initialize(config, prefixes = {})
         @search_config = config
+        @prefixes = prefixes
       end
 
       attr_reader :search_config
@@ -19,26 +22,10 @@ module Qa::Authorities
         search_config.present?
       end
 
-      # Return search url encoding defined in the configuration for this authority
-      # if it was provided
-      # @return [Hash,NilClass] the configured search url
-      def url
-        search_config[:url]
-      end
-
       # Return search url template defined in the configuration for this authority.
-      # @return [String] the configured search url template
-      def url_template
-        url.fetch(:template)
-      end
-
-      # Return search url parameter mapping defined in the configuration for this authority.
-      # @return [Hash] the configured search url parameter mappings with variable name as key
-      def url_mappings
-        return @url_mappings unless @url_mappings.nil?
-        mappings = Config.config_value(url, :mapping)
-        return {} if mappings.nil?
-        Hash[*mappings.collect { |m| [m[:variable].to_sym, m] }.flatten]
+      # @return [Qa::IriTemplate::UrlConfig] the configured search url template
+      def url_config
+        @url_config ||= Qa::IriTemplate::UrlConfig.new(search_config[:url]) if supports_search?
       end
 
       # Return the preferred language for literal value selection for search query.
@@ -89,45 +76,24 @@ module Qa::Authorities
         Config.predicate_uri(results, :sort_predicate)
       end
 
-      # Return parameters that are required for QA api
-      # @return [Hash] the configured search url parameter mappings
-      def qa_replacement_patterns
-        search_config.fetch(:qa_replacement_patterns)
-      end
-
-      # Should the replacement pattern be encoded?
-      # @return [Boolean] true, if the pattern should be encoded; otherwise, false
-      def qa_replacement_encoded?(pattern_key)
-        map_key = qa_replacement_patterns[pattern_key].to_sym
-        replacement_encoded? map_key
-      end
-
-      # Are there replacement parameters configured for search query?
-      # @return [True|False] true if there are replacement parameters configured for search query; otherwise, false
-      def replacements?
-        replacement_count.positive?
-      end
-
-      # Should the replacement parameter be encoded?
-      # @return [True|False] true if the replacement parameter should be encoded; otherwise, false
-      def replacement_encoded?(map_key)
-        return false unless url_mappings[map_key].key? :encode
-        url_mappings[map_key][:encode]
+      # Does this authority configuration support additional context in search results?
+      # @return [True|False] true if additional context in search results is supported; otherwise, false
+      def supports_context?
+        return true if context_map.present?
+        false
       end
 
-      # Return the number of possible replacement values to make in the search URL
-      # @return [Integer] the configured number of possible replacements in the search url
-      def replacement_count
-        replacements.size
+      # Return the context map if it is defined
+      # @return [Qa::LinkedData::Config::ContextMap] the context map
+      def context_map
+        return nil unless search_config.key?(:context)
+        @context_map ||= Qa::LinkedData::Config::ContextMap.new(search_config.fetch(:context), prefixes)
       end
 
-      # Return the replacement configurations
-      # @return [Hash] the configurations for search url replacements
-      def replacements
-        return @replacements unless @replacements.nil?
-        @replacements = {}
-        @replacements = url_mappings.select { |k, _v| !qa_replacement_patterns.include?(k) } unless search_config.nil? || url_mappings.nil?
-        @replacements
+      # Return parameters that are required for QA api
+      # @return [Hash] the configured search url parameter mappings
+      def qa_replacement_patterns
+        search_config.fetch(:qa_replacement_patterns)
       end
 
       # Are there subauthorities configured for search query?
@@ -155,30 +121,6 @@ module Qa::Authorities
         @subauthorities ||= {} if search_config.nil? || !(search_config.key? :subauthorities)
         @subauthorities ||= search_config.fetch(:subauthorities)
       end
-
-      # Return the replacement configurations
-      # @return [Hash] the configurations for search url replacements
-      def subauthority_replacement_pattern
-        return {} unless subauthorities?
-        @subauthority_replacement_pattern ||= {} if search_config.nil? || !subauthorities?
-        pattern = qa_replacement_patterns[:subauth]
-        default = url_mappings[pattern.to_sym][:default]
-        @subauthority_replacement_pattern ||= { pattern: pattern, default: default }
-      end
-
-      # Build a linked data authority search url
-      # @param [String] the query
-      # @param [String] (optional) subauthority key
-      # @param [Hash] (optional) replacement values with { pattern_name (defined in YAML config) => value }
-      # @return [String] the search encoded url
-      def url_with_replacements(query, sub_auth = nil, search_replacements = {})
-        return nil unless supports_search?
-        sub_auth = sub_auth.to_sym if sub_auth.present?
-        url = Config.replace_pattern(url_template, qa_replacement_patterns[:query], query, qa_replacement_encoded?(:query))
-        url = Config.process_subauthority(url, subauthority_replacement_pattern, subauthorities, sub_auth) if subauthorities?
-        url = Config.apply_replacements(url, replacements, search_replacements) if replacements?
-        url
-      end
     end
   end
 end

data/lib/qa/authorities/linked_data/config/term_config.rb

@@ -6,8 +6,9 @@ module Qa::Authorities
   module LinkedData
     class TermConfig
       # @param [Hash] config the term portion of the config
-      def initialize(config)
+      def initialize(config, prefixes = {})
         @term_config = config
+        @prefixes = prefixes
       end
 
       attr_reader :term_config
@@ -19,25 +20,10 @@ module Qa::Authorities
         term_config.present?
       end
 
-      # Return term url encoding defined in the configuration for this authority.
-      # @return [Hash] the configured term url
-      def term_url
-        Config.config_value(term_config, :url)
-      end
-
       # Return term url template defined in the configuration for this authority.
-      # @return [String] the configured term url template
-      def term_url_template
-        Config.config_value(term_url, :template)
-      end
-
-      # Return term url parameter mapping defined in the configuration for this authority.
-      # @return [Hash] the configured term url parameter mappings with variable name as key
-      def term_url_mappings
-        return @term_url_mappings unless @term_url_mappings.nil?
-        mappings = Config.config_value(term_url, :mapping)
-        return {} if mappings.nil?
-        Hash[*mappings.collect { |m| [m[:variable].to_sym, m] }.flatten]
+      # @return [Qa::IriTemplate::UrlConfig] the configured term url template
+      def url_config
+        @url_config ||= Qa::IriTemplate::UrlConfig.new(term_config[:url]) if supports_term?
       end
 
       # Is the term_id substitution expected to be a URI?
@@ -111,41 +97,7 @@ module Qa::Authorities
       def term_qa_replacement_patterns
         Config.config_value(term_config, :qa_replacement_patterns)
       end
-
-      # Should the replacement pattern be encoded?
-      # @return [Boolean] true, if the pattern should be encoded; otherwise, false
-      def term_qa_replacement_encoded?(pattern_key)
-        map_key = term_qa_replacement_patterns[pattern_key].to_sym
-        term_replacement_encoded? map_key
-      end
-
-      # Are there replacement parameters configured for term fetch?
-      # @return [Boolean] true if there are replacement parameters configured for term fetch; otherwise, false
-      def term_replacements?
-        term_replacement_count.positive?
-      end
-
-      # Should the replacement parameter be encoded?
-      # @return [Boolean] true if the replacement parameter should be encoded; otherwise, false
-      def term_replacement_encoded?(map_key)
-        return false unless term_url_mappings[map_key].key? :encode
-        term_url_mappings[map_key][:encode]
-      end
-
-      # Return the number of possible replacement values to make in the term URL
-      # @return [Integer] the configured number of possible replacements in the term url
-      def term_replacement_count
-        term_replacements.size
-      end
-
-      # Return the replacement configurations
-      # @return [Hash] the configurations for term url replacements
-      def term_replacements
-        return @term_replacements unless @term_replacements.nil?
-        @term_replacements = {}
-        @term_replacements = term_url_mappings.select { |k, _v| !term_qa_replacement_patterns.value?(k.to_s) } unless term_config.nil? || term_url_mappings.nil?
-        @term_replacements
-      end
+      alias qa_replacement_patterns term_qa_replacement_patterns
 
       # Are there subauthorities configured for term fetch?
       # @return [True|False] true if there are subauthorities configured term fetch; otherwise, false
@@ -172,29 +124,7 @@ module Qa::Authorities
         @term_subauthorities ||= {} if term_config.nil? || !(term_config.key? :subauthorities)
         @term_subauthorities ||= term_config[:subauthorities]
       end
-
-      # Return the replacement configurations
-      # @return [Hash] the configurations for term url replacements
-      def term_subauthority_replacement_pattern
-        return {} unless term_subauthorities?
-        @term_subauthority_replacement_pattern ||= {} if term_config.nil? || !term_subauthorities?
-        pattern = term_qa_replacement_patterns[:subauth]
-        @term_subauthority_replacement_pattern ||= { pattern: pattern, default: term_url_mappings[pattern.to_sym][:default] }
-      end
-
-      # Build a linked data authority term url
-      # @param [String] the id
-      # @param [String] (optional) subauthority key
-      # @param [Hash] (optional) replacement values with { pattern_name (defined in YAML config) => value }
-      # @return [String] the term encoded url
-      def term_url_with_replacements(id, sub_auth = nil, replacements = {})
-        return nil unless supports_term?
-        sub_auth = sub_auth.to_sym if sub_auth.is_a? String
-        url = Config.replace_pattern(term_url_template, term_qa_replacement_patterns[:term_id], id, term_qa_replacement_encoded?(:term_id))
-        url = Config.process_subauthority(url, term_subauthority_replacement_pattern, term_subauthorities, sub_auth) if term_subauthorities?
-        url = Config.apply_replacements(url, term_replacements, replacements) if term_replacements?
-        url
-      end
+      alias subauthorities term_subauthorities
     end
   end
 end

data/lib/qa/authorities/linked_data/find_term.rb

@@ -10,7 +10,8 @@ module Qa::Authorities
         @term_config = term_config
       end
 
-      attr_reader :term_config
+      attr_reader :term_config, :full_graph, :filtered_graph, :language
+      private :full_graph, :filtered_graph, :language
 
       delegate :term_subauthority?, to: :term_config
 
@@ -35,24 +36,31 @@ module Qa::Authorities
       #     "http://schema.org/sameAs":["http://id.loc.gov/authorities/names/n79021621","https://viaf.org/viaf/126293486"] } }
       def find(id, language: nil, replacements: {}, subauth: nil, jsonld: false)
         raise Qa::InvalidLinkedDataAuthority, "Unable to initialize linked data term sub-authority #{subauth}" unless subauth.nil? || term_subauthority?(subauth)
-        language ||= term_config.term_language
-        url = term_config.term_url_with_replacements(id, subauth, replacements)
+        @language = Qa::LinkedData::LanguageService.preferred_language(user_language: language, authority_language: term_config.term_language)
+        url = Qa::LinkedData::AuthorityUrlService.build_url(action_config: term_config, action: :term, action_request: id, substitutions: replacements, subauthority: subauth)
         Rails.logger.info "QA Linked Data term url: #{url}"
-        graph = get_linked_data(url)
-        return "{}" unless graph.size.positive?
-        return graph.dump(:jsonld, standard_prefixes: true) if jsonld
-        parse_term_authority_response(id, graph, language)
+        load_graph(url: url)
+        return "{}" unless full_graph.size.positive?
+        return full_graph.dump(:jsonld, standard_prefixes: true) if jsonld
+        parse_term_authority_response(id)
       end
 
       private
 
-        def parse_term_authority_response(id, graph, language)
-          graph = filter_language(graph, language) unless language.nil?
-          results = extract_preds(graph, preds_for_term)
+        def load_graph(url:)
+          # @graph = Qa::LinkedData::GraphService.load_graph(url: url)
+          @full_graph = Qa::LinkedData::GraphService.load_graph(url: url)
+          return unless @full_graph.size.positive?
+          @filtered_graph = Qa::LinkedData::GraphService.deep_copy(graph: @full_graph)
+          @filtered_graph = Qa::LinkedData::GraphService.filter(graph: @filtered_graph, language: language) unless language.blank?
+        end
+
+        def parse_term_authority_response(id)
+          results = extract_preds(filtered_graph, preds_for_term)
           consolidated_results = consolidate_term_results(results)
           json_results = convert_term_to_json(consolidated_results)
           termhash = select_json_result_for_id(json_results, id)
-          predicates_hash = predicates_with_subject_uri(graph, termhash[:uri])
+          predicates_hash = predicates_with_subject_uri(termhash[:uri])
           termhash['predicates'] = predicates_hash unless predicates_hash.length <= 0
           termhash
         end
@@ -124,22 +132,22 @@ module Qa::Authorities
           json_results.first
         end
 
-        def predicates_with_subject_uri(graph, expected_uri) # rubocop:disable Metrics/MethodLength
+        def predicates_with_subject_uri(expected_uri) # rubocop:disable Metrics/MethodLength
           predicates_hash = {}
-          graph.statements.each do |st|
+          @full_graph.statements.each do |st|
             subj = st.subject.to_s
             next unless subj == expected_uri
             pred = st.predicate.to_s
-            obj  = st.object.to_s
-            next if blank_node? obj
+            obj  = st.object
+            next if obj.anonymous?
             if predicates_hash.key?(pred)
               objs = predicates_hash[pred]
               objs = [] unless objs.is_a?(Array)
               objs << predicates_hash[pred] unless objs.length.positive?
-              objs << obj
+              objs << obj.to_s
               predicates_hash[pred] = objs
             else
-              predicates_hash[pred] = [obj]
+              predicates_hash[pred] = [obj.to_s]
             end
           end
           predicates_hash