qa 3.1.0 → 4.0.0.rc1

data/app/controllers/qa/linked_data_terms_controller.rb

@@ -18,36 +18,39 @@ class Qa::LinkedDataTermsController < ::ApplicationController
 
   # Return a list of supported authority names
   # get "/list/linked_data/authorities"
-  # @see Qa::Authorities::LinkedData::AuthorityService#authority_names
+  # @see Qa::LinkedData::AuthorityService#authority_names
   def list
-    render json: Qa::Authorities::LinkedData::AuthorityService.authority_names.to_json
+    render json: Qa::LinkedData::AuthorityService.authority_names.to_json
   end
 
   # Reload authority configurations
   # get "/reload/linked_data/authorities?auth_token=YOUR_AUTH_TOKEN_DEFINED_HERE"
-  # @see Qa::Authorities::LinkedData::AuthorityService#load_authorities
+  # @see Qa::LinkedData::AuthorityService#load_authorities
   def reload
-    Qa::Authorities::LinkedData::AuthorityService.load_authorities
+    Qa::LinkedData::AuthorityService.load_authorities
     list
   end
 
   # Return a list of terms based on a query
   # get "/search/linked_data/:vocab(/:subauthority)"
   # @see Qa::Authorities::LinkedData::SearchQuery#search
-  def search
-    terms = @authority.search(query, subauth: subauthority, language: language, replacements: replacement_params)
+  def search # rubocop:disable Metrics/MethodLength
+    terms = @authority.search(query, subauth: subauthority, language: language, replacements: replacement_params, context: context?)
     cors_allow_origin_header(response)
     render json: terms
   rescue Qa::ServiceUnavailable
-    logger.warn "Service Unavailable - Search query #{query} unsuccessful for#{subauth_warn_msg} authority #{vocab_param}"
-    head :service_unavailable
+    msg = "Service Unavailable - Search query #{query} unsuccessful for#{subauth_warn_msg} authority #{vocab_param}"
+    logger.warn msg
+    render json: { errors: msg }, status: :service_unavailable
   rescue Qa::ServiceError
-    logger.warn "Internal Server Error - Search query #{query} unsuccessful for#{subauth_warn_msg} authority #{vocab_param}"
-    head :internal_server_error
+    msg = "Internal Server Error - Search query #{query} unsuccessful for#{subauth_warn_msg} authority #{vocab_param}"
+    logger.warn msg
+    render json: { errors: msg }, status: :internal_server_error
   rescue RDF::FormatError
-    logger.warn "RDF Format Error - Results from search query #{query} for#{subauth_warn_msg} authority #{vocab_param} " \
+    msg = "RDF Format Error - Results from search query #{query} for#{subauth_warn_msg} authority #{vocab_param} " \
                 "was not identified as a valid RDF format.  You may need to include the linkeddata gem."
-    head :internal_server_error
+    logger.warn msg
+    render json: { errors: msg }, status: :internal_server_error
   end
 
   # Return all the information for a given term given an id or URI
@@ -60,18 +63,22 @@ class Qa::LinkedDataTermsController < ::ApplicationController
     content_type = jsonld? ? 'application/ld+json' : 'application/json'
     render json: term, content_type: content_type
   rescue Qa::TermNotFound
-    logger.warn "Term Not Found - Fetch term #{id} unsuccessful for#{subauth_warn_msg} authority #{vocab_param}"
-    head :not_found
+    msg = "Term Not Found - Fetch term #{id} unsuccessful for#{subauth_warn_msg} authority #{vocab_param}"
+    logger.warn msg
+    render json: { errors: msg }, status: :not_found
   rescue Qa::ServiceUnavailable
-    logger.warn "Service Unavailable - Fetch term #{id} unsuccessful for#{subauth_warn_msg} authority #{vocab_param}"
-    head :service_unavailable
+    msg = "Service Unavailable - Fetch term #{id} unsuccessful for#{subauth_warn_msg} authority #{vocab_param}"
+    logger.warn msg
+    render json: { errors: msg }, status: :service_unavailable
   rescue Qa::ServiceError
-    logger.warn "Internal Server Error - Fetch term #{id} unsuccessful for#{subauth_warn_msg} authority #{vocab_param}"
-    head :internal_server_error
+    msg = "Internal Server Error - Fetch term #{id} unsuccessful for#{subauth_warn_msg} authority #{vocab_param}"
+    logger.warn msg
+    render json: { errors: msg }, status: :internal_server_error
   rescue RDF::FormatError
-    logger.warn "RDF Format Error - Results from fetch term #{id} for#{subauth_warn_msg} authority #{vocab_param} " \
+    msg = "RDF Format Error - Results from fetch term #{id} for#{subauth_warn_msg} authority #{vocab_param} " \
                 "was not identified as a valid RDF format.  You may need to include the linkeddata gem."
-    head :internal_server_error
+    logger.warn msg
+    render json: { errors: msg }, status: :internal_server_error
   end
 
   # Return all the information for a given term given a URI
@@ -83,50 +90,58 @@ class Qa::LinkedDataTermsController < ::ApplicationController
     content_type = jsonld? ? 'application/ld+json' : 'application/json'
     render json: term, content_type: content_type
   rescue Qa::TermNotFound
-    logger.warn "Term Not Found - Fetch term #{uri} unsuccessful for#{subauth_warn_msg} authority #{vocab_param}"
-    head :not_found
+    msg = "Term Not Found - Fetch term #{uri} unsuccessful for#{subauth_warn_msg} authority #{vocab_param}"
+    logger.warn msg
+    render json: { errors: msg }, status: :not_found
   rescue Qa::ServiceUnavailable
-    logger.warn "Service Unavailable - Fetch term #{uri} unsuccessful for#{subauth_warn_msg} authority #{vocab_param}"
-    head :service_unavailable
+    msg = "Service Unavailable - Fetch term #{uri} unsuccessful for#{subauth_warn_msg} authority #{vocab_param}"
+    logger.warn msg
+    render json: { errors: msg }, status: :service_unavailable
   rescue Qa::ServiceError
-    logger.warn "Internal Server Error - Fetch term #{uri} unsuccessful for#{subauth_warn_msg} authority #{vocab_param}"
-    head :internal_server_error
+    msg = "Internal Server Error - Fetch term #{uri} unsuccessful for#{subauth_warn_msg} authority #{vocab_param}"
+    logger.warn msg
+    render json: { errors: msg }, status: :internal_server_error
   rescue RDF::FormatError
-    logger.warn "RDF Format Error - Results from fetch term #{uri} for#{subauth_warn_msg} authority #{vocab_param} " \
+    msg = "RDF Format Error - Results from fetch term #{uri} for#{subauth_warn_msg} authority #{vocab_param} " \
                 "was not identified as a valid RDF format.  You may need to include the linkeddata gem."
-    head :internal_server_error
+    logger.warn msg
+    render json: { errors: msg }, status: :internal_server_error
   end
 
   private
 
     def check_authority
       if params[:vocab].nil? || !params[:vocab].size.positive? # rubocop:disable Style/GuardClause
-        logger.warn "Required param 'vocab' is missing or empty"
-        head :bad_request
+        msg = "Required param 'vocab' is missing or empty"
+        logger.warn msg
+        render json: { errors: msg }, status: :bad_request
       end
     end
 
     def check_search_subauthority
       return if subauthority.nil?
       unless @authority.search_subauthority?(subauthority) # rubocop:disable Style/GuardClause
-        logger.warn "Unable to initialize linked data search sub-authority '#{subauthority}' for authority '#{vocab_param}'"
-        head :bad_request
+        msg = "Unable to initialize linked data search sub-authority '#{subauthority}' for authority '#{vocab_param}'"
+        logger.warn msg
+        render json: { errors: msg }, status: :bad_request
       end
     end
 
     def check_show_subauthority
       return if subauthority.nil?
       unless @authority.term_subauthority?(subauthority) # rubocop:disable Style/GuardClause
-        logger.warn "Unable to initialize linked data term sub-authority '#{subauthority}' for authority '#{vocab_param}'"
-        head :bad_request
+        msg = "Unable to initialize linked data term sub-authority '#{subauthority}' for authority '#{vocab_param}'"
+        logger.warn msg
+        render json: { errors: msg }, status: :bad_request
       end
     end
 
     def init_authority
       @authority = Qa::Authorities::LinkedData::GenericAuthority.new(vocab_param)
     rescue Qa::InvalidLinkedDataAuthority => e
-      logger.warn e.message
-      head :bad_request
+      msg = e.message
+      logger.warn msg
+      render json: { errors: msg }, status: :bad_request
     end
 
     def vocab_param
@@ -146,8 +161,9 @@ class Qa::LinkedDataTermsController < ::ApplicationController
     end
 
     def missing_required_param(action_name, param_name)
-      logger.warn "Required #{action_name} param '#{param_name}' is missing or empty"
-      head :bad_request
+      msg = "Required #{action_name} param '#{param_name}' is missing or empty"
+      logger.warn msg
+      render json: { errors: msg }, status: :bad_request
     end
 
     # converts wildcards into URL-encoded characters
@@ -176,7 +192,7 @@ class Qa::LinkedDataTermsController < ::ApplicationController
     end
 
     def subauth_warn_msg
-      subauthority.nil? ? "" : " sub-authority #{subauthority} in"
+      subauthority.blank? ? "" : " sub-authority #{subauthority} in"
     end
 
     def format
@@ -186,15 +202,21 @@ class Qa::LinkedDataTermsController < ::ApplicationController
     end
 
     def jsonld?
-      format == 'jsonld'
+      format.casecmp('jsonld').zero?
+    end
+
+    def context?
+      context = params.fetch(:context, 'false')
+      context.casecmp('true').zero?
     end
 
     def validate_auth_reload_token
       token = params.key?(:auth_token) ? params[:auth_token] : nil
       valid = Qa.config.valid_authority_reload_token?(token)
       return true if valid
-      logger.warn "FAIL: unable to reload authorities; error_msg: Invalid token (#{token}) does not match expected token."
-      head :unauthorized
+      msg = "FAIL: unable to reload authorities; error_msg: Invalid token (#{token}) does not match expected token."
+      logger.warn msg
+      render json: { errors: msg }, status: :unauthorized
       false
     end
 end

data/app/controllers/qa/terms_controller.rb

@@ -34,15 +34,19 @@ class Qa::TermsController < ::ApplicationController
   end
 
   def check_vocab_param
-    head :not_found unless params[:vocab].present?
+    return if params[:vocab].present?
+    msg = "Required param 'vocab' is missing or empty"
+    logger.warn msg
+    render json: { errors: msg }, status: :bad_request
   end
 
   def init_authority # rubocop:disable Metrics/MethodLength
     begin
       mod = authority_class.camelize.constantize
     rescue NameError
-      logger.warn "Unable to initialize authority #{authority_class}"
-      head :not_found
+      msg = "Unable to initialize authority #{authority_class}"
+      logger.warn msg
+      render json: { errors: msg }, status: :bad_request
       return
     end
     begin
@@ -53,13 +57,17 @@ class Qa::TermsController < ::ApplicationController
                      mod.subauthority_for(params[:subauthority])
                    end
     rescue Qa::InvalidSubAuthority, Qa::MissingSubAuthority => e
-      logger.warn e.message
-      head :not_found
+      msg = e.message
+      logger.warn msg
+      render json: { errors: msg }, status: :bad_request
     end
   end
 
   def check_query_param
-    head :not_found unless params[:q].present?
+    return if params[:q].present?
+    msg = "Required param 'q' is missing or empty"
+    logger.warn msg
+    render json: { errors: msg }, status: :bad_request
   end
 
   private

data/app/models/qa/iri_template/url_config.rb

@@ -0,0 +1,47 @@
+# Provide access to iri template configuration.
+# See https://www.hydra-cg.com/spec/latest/core/#templated-links for information on IRI Templated Links.
+# TODO: It would be good to find a more complete resource describing templated links.
+module Qa
+  module IriTemplate
+    class UrlConfig
+      TYPE = "IriTemplate".freeze
+      CONTEXT = "http://www.w3.org/ns/hydra/context.jsonld".freeze
+      attr_reader :template # [String] the URL template with variables for substitution (required)
+      attr_reader :variable_representation # [String] always "BasicRepresentation" # TODO what other values are supported and what do they mean
+      attr_reader :mapping # [Array<Qa::IriTempalte::VariableMap>] array of maps for use with a template (required)
+
+      # @param [Hash] url_config configuration hash for the iri template
+      # @option url_config [String] :template the URL template with variables for substitution (required)
+      # @option url_config [String] :variable_representation always "BasicRepresentation" # TODO what other values are supported and what do they mean
+      # @option url_config [Array<Hash>] :mapping array of maps for use with a template (required)
+      def initialize(url_config)
+        @url_config = url_config
+        @template = Qa::LinkedData::Config::Helper.fetch_required(url_config, :template, nil)
+        @mapping = extract_mapping
+        @variable_representation = Qa::LinkedData::Config::Helper.fetch(url_config, :variable_representation, 'BasicRepresentation')
+      end
+
+      # Selective extract substitution variable-value pairs from the provided substitutions.
+      # @param [Hash, ActionController::Parameters] full set of passed in substitution values
+      # @return [HashWithIndifferentAccess] Only variable-value pairs for variables defined in the variable mapping.
+      def extract_substitutions(substitutions)
+        selected_substitutions = HashWithIndifferentAccess.new
+        mapping.each do |m|
+          selected_substitutions[m.variable] = substitutions[m.variable] if substitutions.key? m.variable
+        end
+        selected_substitutions
+      end
+
+      private
+
+        # Initialize the variable maps
+        # @param config [Hash] configuration holding the variable maps to be extracted
+        # @return [Array<IriTemplate::Map>] array of the variable maps
+        def extract_mapping
+          mapping = Qa::LinkedData::Config::Helper.fetch_required(@url_config, :mapping, nil)
+          raise Qa::InvalidConfiguration, "mapping must include at least one map" if mapping.empty?
+          mapping.collect { |m| Qa::IriTemplate::VariableMap.new(m) }
+        end
+    end
+  end
+end

data/app/models/qa/iri_template/variable_map.rb

@@ -0,0 +1,62 @@
+# Provide access to iri template variable map configuration.
+# See https://www.hydra-cg.com/spec/latest/core/#templated-links for information on IRI Templated Links - Variable Mapping.
+# TODO: It would be good to find a more complete resource describing templated links.
+
+module Qa
+  module IriTemplate
+    class VariableMap
+      TYPE = "IriTemplateMapping".freeze
+      attr_reader :variable
+      attr_reader :default
+      private :default
+
+      # @param [Hash] variable_map configuration hash for the variable map
+      # @option variable_map [String] :variable (required) name of the variable in the template (e.g. {?query} has the name 'query')
+      # @option variable_map [String] :property (optional) always "hydra:freetextQuery" # TODO what other values are supported and what do they mean
+      # @option variable_map [Boolean] :required (required) is this variable required
+      # @option variable_map [String] :default (optional) value to use if a value is not provided in the request (default: '')
+      # @option variable_map [Boolean] :encode (optional) whether to url_encode the value (default: false)
+      def initialize(variable_map)
+        @variable = Qa::LinkedData::Config::Helper.fetch_required(variable_map, :variable, nil)
+        @required = Qa::LinkedData::Config::Helper.fetch_boolean(variable_map, :required, nil)
+        @default = Qa::LinkedData::Config::Helper.fetch(variable_map, :default, '').to_s
+        @encode = Qa::LinkedData::Config::Helper.fetch_boolean(variable_map, :encode, false)
+        @property = Qa::LinkedData::Config::Helper.fetch(variable_map, :property, 'hydra:freetextQuery')
+      end
+
+      # Value to use in substitution, using default if one isn't passed in.  Use when template url specifies variable as {var_name}.
+      # @param [Object] value to use if it exists
+      # @return the value to use (e.g. 'fr')
+      def simple_value(sub_value = nil)
+        raise Qa::IriTemplate::MissingParameter, "#{variable} is required, but missing" if sub_value.blank? && required?
+        return default if sub_value.blank?
+        sub_value = sub_value.to_s
+        sub_value = ERB::Util.url_encode(sub_value).gsub(".", "%2E") if encode?
+        sub_value
+      end
+
+      # Parameter and value to use in substitution, using default is one isn't passed in. Use when template url specifies variable as {?var_name}.
+      # @param [Object] value to use if it exists
+      # @return the parameter and value to use (e.g. 'language=fr')
+      def parameter_value(sub_value = nil)
+        simple_value = simple_value(sub_value)
+        return '' if simple_value.blank?
+        "#{variable}=#{simple_value}"
+      end
+
+      private
+
+        # Is this variable required?
+        # @return true if required; otherwise, false
+        def required?
+          @required
+        end
+
+        # Should the variable's value be encoded?
+        # @return true if should encode; otherwise, false
+        def encode?
+          @encode
+        end
+    end
+  end
+end

data/app/models/qa/linked_data/config/context_map.rb

@@ -0,0 +1,77 @@
+# Defines the external authority predicates used to extract additional context from the graph.
+module Qa
+  module LinkedData
+    module Config
+      class ContextMap
+        attr_reader :properties # [Array<Qa::LinkedData::Config::ContextPropertyMap>] set of property map models
+
+        attr_reader :context_map, :groups, :prefixes
+        private :context_map, :groups, :prefixes
+
+        # @param [Hash] context_map that defines groups and properties for additional context to display during the selection process
+        # @option context_map [Hash] :groups (optional) predefine group ids and labels to be used in the properties section to group properties
+        # @option groups [Hash] key=group_id; value=[Hash] with group_label_i18n and/or group_label_default
+        # @option context_map [Array<Hash>] :properties (optional) property maps defining how to get and display the additional context (if none, context will not be added)
+        # @param [Hash] shortcut names for URI prefixes with key = part of predicate that is the same for all terms (e.g. { "madsrdf": "http://www.loc.gov/mads/rdf/v1#" })
+        # @example context_map example
+        #   {
+        #     "groups": {
+        #       "dates": {
+        #         "group_label_i18n": "qa.linked_data.authority.locnames_ld4l_cache.dates",
+        #         "group_label_default": "Dates"
+        #       }
+        #     },
+        #     "properties": [
+        #       {
+        #         "property_label_i18n": "qa.linked_data.authority.locgenres_ld4l_cache.authoritative_label",
+        #         "property_label_default": "Authoritative Label",
+        #         "ldpath": "madsrdf:authoritativeLabel",
+        #         "selectable": true,
+        #         "drillable": false
+        #       },
+        #       {
+        #         "group_id": "dates",
+        #         "property_label_i18n": "qa.linked_data.authority.locnames_ld4l_cache.birth_date",
+        #         "property_label_default": "Birth",
+        #         "ldpath": "madsrdf:identifiesRWO/madsrdf:birthDate/schema:label",
+        #         "selectable": false,
+        #         "drillable": false
+        #       }
+        #     ]
+        #   }
+        def initialize(context_map = {}, prefixes = {})
+          @context_map = context_map
+          @prefixes = prefixes
+          extract_groups
+          extract_properties
+        end
+
+        def group_label(group_id)
+          groups[group_id]
+        end
+
+        private
+
+          def extract_properties
+            @properties = []
+            properties_map = Qa::LinkedData::Config::Helper.fetch(context_map, :properties, {})
+            properties_map.each { |property_map| @properties << ContextPropertyMap.new(property_map, prefixes) }
+          end
+
+          def extract_groups
+            @groups = {}
+            groups_map = Qa::LinkedData::Config::Helper.fetch(context_map, :groups, {})
+            groups_map.each { |group_id, group_map| add_group(group_id, group_map) }
+          end
+
+          def add_group(group_id, group_map)
+            return if groups.key? group_id
+            i18n_key = Qa::LinkedData::Config::Helper.fetch(group_map, :group_label_i18n, nil)
+            default = Qa::LinkedData::Config::Helper.fetch(group_map, :group_label_default, nil)
+            return groups[group_id] = I18n.t(i18n_key, default: default) if i18n_key.present?
+            groups[group_id] = default
+          end
+      end
+    end
+  end
+end

data/app/models/qa/linked_data/config/context_property_map.rb

@@ -0,0 +1,144 @@
+# Defines the external authority predicates used to extract additional context from the graph.
+require 'ldpath'
+
+module Qa
+  module LinkedData
+    module Config
+      class ContextPropertyMap
+        VALUE_ON_ERROR = [].freeze
+
+        attr_reader :group_id, # id that identifies which group the property should be in
+                    :label
+
+        attr_reader :property_map, :ldpath, :expansion_label_ldpath, :expansion_id_ldpath, :prefixes
+        private :property_map, :ldpath, :expansion_label_ldpath, :expansion_id_ldpath, :prefixes
+
+        # @param [Hash] property_map defining information to return to provide context
+        # @option property_map [String] :group_id (optional) default label to use for a property (default: no label)
+        # @option property_map [String] :property_label_i18n (optional) i18n key to use to get the label for a property (default: property_label_default OR no label if neither are defined)
+        # @option property_map [String] :property_label_default (optional) default label to use for a property (default: no label)
+        # @option property_map [String] :ldpath (required) identifies the values to extract from the graph (based on http://marmotta.apache.org/ldpath/language.html)
+        # @option property_map [Boolean] :selectable (optional) if true, this property can selected as the value (default: false)
+        # @option property_map [Boolean] :drillable (optional) if true, the label for this property can be used to execute a second query allowing navi (default: false)
+        # @param [Hash] shortcut names for URI prefixes with key = part of predicate that is the same for all terms (e.g. { "madsrdf": "http://www.loc.gov/mads/rdf/v1#" })
+        # @example property_map example
+        #   {
+        #     "group_id": "dates",
+        #     "property_label_i18n": "qa.linked_data.authority.locnames_ld4l_cache.birth_date",
+        #     "property_label_default": "Birth",
+        #     "ldpath": "madsrdf:identifiesRWO/madsrdf:birthDate/schema:label",
+        #     "selectable": false,
+        #     "drillable": false
+        #   }
+        def initialize(property_map = {}, prefixes = {})
+          @property_map = property_map
+          @group_id = Qa::LinkedData::Config::Helper.fetch_symbol(property_map, :group_id, nil)
+          @label = extract_label
+          @ldpath = Qa::LinkedData::Config::Helper.fetch_required(property_map, :ldpath, false)
+          @selectable = Qa::LinkedData::Config::Helper.fetch_boolean(property_map, :selectable, false)
+          @drillable = Qa::LinkedData::Config::Helper.fetch_boolean(property_map, :drillable, false)
+          @expansion_label_ldpath = Qa::LinkedData::Config::Helper.fetch(property_map, :expansion_label_ldpath, nil)
+          @expansion_id_ldpath = Qa::LinkedData::Config::Helper.fetch(property_map, :expansion_id_ldpath, nil)
+          @prefixes = prefixes
+        end
+
+        # Can this property be the selected value?
+        # @return [Boolean] true if this property's value can be selected; otherwise, false
+        def selectable?
+          @selectable
+        end
+
+        # Can this property be used as a new query
+        # @return [Boolean] true if this property's value can be used to drill up/down to another level; otherwise, false
+        def drillable?
+          @drillable
+        end
+
+        def group?
+          group_id.present?
+        end
+
+        # Should this URI value be expanded to include its label?
+        # @return [Boolean] true if this property's value is expected to be a URI and its label should be included in the value; otherwise, false
+        def expand_uri?
+          expansion_label_ldpath.present?
+        end
+
+        # Values of this property for a specfic subject URI
+        # @return [Array<String>] values for this property
+        def values(graph, subject_uri)
+          ldpath_evaluate(basic_program, graph, subject_uri)
+        end
+
+        # Values of this property for a specfic subject URI with URI values expanded to include id and label.
+        # @return [Array<Hash>] expanded values for this property
+        # @example returned values
+        #   [{
+        #     uri: "http://id.loc.gov/authorities/genreForms/gf2014026551",
+        #     id: "gf2014026551",
+        #     label: "Space operas"
+        #   }]
+        def expanded_values(graph, subject_uri)
+          values = values(graph, subject_uri)
+          return values unless expand_uri?
+          return values unless values.respond_to? :map!
+          values.map! do |uri|
+            { uri: uri, id: expansion_id(graph, uri), label: expansion_label(graph, uri) }
+          end
+          values
+        end
+
+        private
+
+          def extract_label
+            i18n_key = Qa::LinkedData::Config::Helper.fetch(property_map, :property_label_i18n, nil)
+            default = Qa::LinkedData::Config::Helper.fetch(property_map, :property_label_default, nil)
+            return I18n.t(i18n_key, default: default) if i18n_key.present?
+            default
+          end
+
+          def basic_program
+            @basic_program ||= ldpath_program(ldpath)
+          end
+
+          def expansion_label_program
+            @expansion_label_program ||= ldpath_program(expansion_label_ldpath)
+          end
+
+          def expansion_id_program
+            @expansion_id_program ||= ldpath_program(expansion_id_ldpath)
+          end
+
+          def ldpath_program(ldpath)
+            program_code = ""
+            prefixes.each { |key, url| program_code << "@prefix #{key} : <#{url}> \;\n" }
+            program_code << "property = #{ldpath} \;"
+            Ldpath::Program.parse program_code
+          rescue => e
+            Rails.logger.warn("WARNING: #{I18n.t('qa.linked_data.ldpath.parse_logger_error')} (ldpath='#{ldpath}')\n    cause: #{e.message}")
+            raise StandardError, I18n.t('qa.linked_data.ldpath.parse_error')
+          end
+
+          def ldpath_evaluate(program, graph, subject_uri)
+            return VALUE_ON_ERROR if program.blank?
+            output = program.evaluate subject_uri, graph
+            output.present? ? output['property'].uniq : nil
+          rescue => e
+            Rails.logger.warn("WARNING: #{I18n.t('qa.linked_data.ldpath.evaluate_logger_error')} (ldpath='#{ldpath}')\n    cause: #{e.message}")
+            raise StandardError, I18n.t('qa.linked_data.ldpath.evaluate_error')
+          end
+
+          def expansion_label(graph, uri)
+            label = ldpath_evaluate(expansion_label_program, graph, RDF::URI(uri))
+            label.size == 1 ? label.first : label
+          end
+
+          def expansion_id(graph, uri)
+            return uri if expansion_id_ldpath.blank?
+            id = ldpath_evaluate(expansion_id_program, graph, RDF::URI(uri))
+            id.size == 1 ? id.first : id
+          end
+      end
+    end
+  end
+end