glossarist 2.6.6 → 2.6.7

data/lib/glossarist/rdf/ext/mapping_ext.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Extends Lutaml::Rdf::Mapping with support for multiple rdf:type values.
+#
+# Usage in rdf do blocks:
+#   type "gloss:Concept"                    # single type (original API)
+#   types "gloss:Concept", "skos:Concept"   # multiple types (new API)
+module Lutaml
+  module Rdf
+    class Mapping
+      attr_writer :namespace_set, :rdf_subject, :rdf_type, :rdf_predicates,
+                  :rdf_members
+
+      def types(*values)
+        @rdf_types = values.flatten.map(&:to_s)
+      end
+
+      def rdf_types
+        if defined?(@rdf_types) && @rdf_types
+          @rdf_types
+        elsif @rdf_type
+          [@rdf_type.to_s]
+        else
+          []
+        end
+      end
+
+      def rdf_types=(values)
+        @rdf_types = values
+      end
+
+      def has_types_or_predicates?
+        rdf_types.any? || rdf_predicates.any?
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/ext/mapping_rule_ext.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# Extends Lutaml::Rdf::MappingRule with `as:` option for URI-valued predicates.
+#
+# Usage:
+#   predicate :hasStatus, namespace: Ns, to: :status, as: :uri
+#   predicate :name, namespace: Ns, to: :name                   # default: :literal
+module Lutaml
+  module Rdf
+    class MappingRule
+      attr_reader :as
+
+      def initialize(predicate_name, namespace:, to:, lang_tagged: false, as: :literal)
+        validate!(predicate_name, namespace, to)
+        @predicate_name = predicate_name.to_s.freeze
+        @namespace = namespace
+        @to = to
+        @lang_tagged = lang_tagged
+        @as = as
+      end
+
+      def uri_value?
+        @as == :uri
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/ext/member_rule_ext.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Extends Lutaml::Rdf::MemberRule with `inline:` and `link:` options.
+#
+# Usage:
+#   members :localizations, link: "gloss:hasLocalization"
+#   members :designations, link: ->(d) { skosxl_predicate_for(d) }
+#   members :definitions, link: "gloss:hasDefinition"
+#   members :sources                                # no linking predicate
+module Lutaml
+  module Rdf
+    class MemberRule
+      attr_reader :attr_name, :inline, :link
+
+      def initialize(attr_name, inline: true, link: nil)
+        @attr_name = attr_name.to_sym
+        @inline = inline
+        @link = link
+      end
+
+      def link_predicate_for(member, mapping)
+        return nil unless @link
+
+        case @link
+        when String
+          mapping.namespace_set.resolve_compact_iri(@link)
+        when Proc
+          uri = @link.call(member)
+          uri.include?(":") ? mapping.namespace_set.resolve_compact_iri(uri) : uri
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/ext/turtle_transform_ext.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require "rdf/turtle"
+
+# Extends Lutaml::Turtle::Transform to handle:
+# - Multiple rdf:type values (types method)
+# - URI-valued predicates (as: :uri)
+# - Reference-only members (inline: false)
+# - Linking predicates for members (link option)
+# - Recursive prefix collection
+# - Polymorphic member collections
+module Lutaml
+  module Turtle
+    class Transform < Lutaml::Rdf::Transform
+      def model_to_data(instance, _format, options = {})
+        mapping = extract_turtle_mapping(options)
+        return "" unless mapping
+
+        if !mapping.rdf_subject && mapping.has_types_or_predicates? && mapping.rdf_members.empty?
+          raise MissingSubjectError,
+                "Turtle mapping requires a subject block"
+        end
+
+        graph = build_graph(mapping, instance)
+        return "" if graph.empty?
+
+        prefixes = collect_all_prefixes(mapping, instance)
+        RDF::Turtle::Writer.buffer(prefixes: prefixes) do |writer|
+          graph.each_statement { |stmt| writer << stmt }
+        end.strip
+      end
+
+      def data_to_model(data, _format, options = {})
+        mapping = extract_turtle_mapping(options)
+        unless mapping&.rdf_subject
+          raise MissingSubjectError,
+                "Turtle mapping requires a subject block"
+        end
+
+        graph = data.is_a?(RDF::Graph) ? data : Lutaml::Turtle::Adapter.parse(data)
+        attrs = extract_attributes(graph, mapping)
+        build_instance(attrs, options)
+      end
+
+      private
+
+      def extract_turtle_mapping(options)
+        options[:mappings] || mappings_for(:turtle, lutaml_register)
+      end
+
+      def build_graph(mapping, instance)
+        graph = RDF::Graph.new
+
+        if mapping.has_types_or_predicates?
+          subject_uri = if mapping.rdf_subject
+                          RDF::URI(resolve_subject_uri(mapping, instance))
+                        else
+                          RDF::Node.new
+                        end
+
+          emit_type_statements(graph, subject_uri, mapping)
+          emit_predicate_statements(graph, subject_uri, instance, mapping)
+          emit_member_link_statements(graph, subject_uri, instance, mapping)
+          emit_relationship_statements(graph, subject_uri, instance)
+        end
+
+        emit_child_resources(graph, instance, mapping)
+
+        graph
+      end
+
+      def emit_type_statements(graph, subject_uri, mapping)
+        mapping.rdf_types.each do |type_str|
+          type_uri = RDF::URI(mapping.namespace_set.resolve_compact_iri(type_str))
+          graph << RDF::Statement.new(subject_uri, RDF.type, type_uri)
+        end
+      end
+
+      def emit_predicate_statements(graph, subject_uri, instance, mapping)
+        mapping.rdf_predicates.each do |rule|
+          value = instance.public_send(rule.to)
+          next if value.nil?
+
+          Array(value).each do |v|
+            next if v.is_a?(String) && v.empty?
+
+            object = build_rdf_object(v, rule, mapping)
+            graph << RDF::Statement.new(subject_uri, RDF::URI(rule.uri), object)
+          end
+        end
+      end
+
+      def emit_member_link_statements(graph, subject_uri, instance, mapping)
+        mapping.rdf_members.each do |member_rule|
+          next unless member_rule.link
+
+          collection = Array(instance.public_send(member_rule.attr_name))
+          collection.each do |member|
+            child_mapping = member.class.mappings[:turtle]
+            next unless child_mapping&.rdf_subject
+
+            child_uri = RDF::URI(resolve_subject_uri(child_mapping, member))
+            link_uri = RDF::URI(member_rule.link_predicate_for(member, mapping))
+            next unless link_uri
+
+            graph << RDF::Statement.new(subject_uri, link_uri, child_uri)
+          end
+        end
+      end
+
+      def emit_relationship_statements(graph, subject_uri, instance)
+        return unless instance.is_a?(Glossarist::Rdf::Relationships)
+
+        Array(instance.relationship_triples).each do |pred_uri, obj_uri|
+          graph << RDF::Statement.new(subject_uri, RDF::URI(pred_uri), RDF::URI(obj_uri))
+        end
+      end
+
+      def emit_child_resources(graph, instance, mapping)
+        mapping.rdf_members.each do |member_rule|
+          collection = Array(instance.public_send(member_rule.attr_name))
+          collection.each do |member|
+            member_mapping = member.class.mappings[:turtle]
+            next unless member_mapping
+
+            graph << build_graph(member_mapping, member)
+          end
+        end
+      end
+
+      def build_rdf_object(value, rule, mapping = nil)
+        if rule.uri_value?
+          resolved = if mapping && value.include?(":")
+                       mapping.namespace_set.resolve_compact_iri(value)
+                     else
+                       value
+                     end
+          RDF::URI(resolved)
+        elsif rule.lang_tagged
+          lang = extract_language(value)
+          RDF::Literal.new(value.to_s, language: lang)
+        else
+          case value
+          when Integer then RDF::Literal.new(value, datatype: RDF::XSD.integer)
+          when Float then RDF::Literal.new(value, datatype: RDF::XSD.double)
+          when TrueClass, FalseClass then RDF::Literal.new(value, datatype: RDF::XSD.boolean)
+          else RDF::Literal.new(value.to_s)
+          end
+        end
+      end
+
+      def collect_all_prefixes(mapping, instance)
+        ns_set = collect_namespaces_recursive(mapping, instance)
+        ns_set.each.with_object({}) do |ns, h|
+          h[ns.prefix.to_sym] = ns.uri if ns.prefix && ns.uri
+        end
+      end
+
+      def collect_namespaces_recursive(mapping, instance)
+        ns_set = mapping.namespace_set
+
+        mapping.rdf_members.each do |member_rule|
+          collection = Array(instance.public_send(member_rule.attr_name))
+          next if collection.empty?
+
+          collection.map(&:class).uniq.each do |klass|
+            member_mapping = klass.mappings[:turtle]
+            next unless member_mapping
+
+            ns_set = ns_set.merge(member_mapping.namespace_set)
+            # Recurse into child members
+            child_ns = collect_namespaces_recursive(member_mapping, collection.first)
+            ns_set = ns_set.merge(child_ns)
+          end
+        end
+
+        ns_set
+      end
+
+      def extract_attributes(graph, mapping)
+        attrs = {}
+        first_type_uri = mapping.rdf_types.first
+        return attrs unless first_type_uri
+
+        type_uri = RDF::URI(mapping.namespace_set.resolve_compact_iri(first_type_uri))
+        matching_subjects = find_subjects_by_type(graph, type_uri)
+
+        matching_subjects.each do |subject|
+          mapping.rdf_predicates.each do |rule|
+            stmts = graph.query([subject, RDF::URI(rule.uri), nil])
+            next if stmts.empty?
+
+            values = stmts.map do |s|
+              rule.uri_value? ? s.object.to_s : literal_to_ruby(s.object)
+            end
+            attrs[rule.to] = values.length == 1 ? values.first : values
+          end
+        end
+
+        attrs
+      end
+
+      def find_subjects_by_type(graph, type_uri)
+        graph.query([nil, RDF.type, RDF::URI(type_uri)]).map(&:subject).uniq
+      end
+
+      def literal_to_ruby(rdf_object)
+        case rdf_object
+        when RDF::Literal
+          case rdf_object.datatype
+          when RDF::XSD.integer then rdf_object.value.to_i
+          when RDF::XSD.double, RDF::XSD.decimal, RDF::XSD.float then rdf_object.value.to_f
+          when RDF::XSD.boolean then rdf_object.value == "true"
+          else rdf_object.value
+          end
+        else
+          rdf_object.to_s
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/ext.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "lutaml/turtle"
+require "lutaml/jsonld"
+
+require_relative "ext/mapping_ext"
+require_relative "ext/mapping_rule_ext"
+require_relative "ext/member_rule_ext"
+require_relative "ext/turtle_transform_ext"
+require_relative "ext/jsonld_transform_ext"
+
+# Update Lutaml::Rdf::Mapping#predicate to pass through `as` option.
+# Update Lutaml::Rdf::Mapping#members to pass through `inline` and `link` options.
+Lutaml::Rdf::Mapping.class_eval do
+  def predicate(name, namespace:, to:, lang_tagged: false, as: :literal)
+    @rdf_predicates << Lutaml::Rdf::MappingRule.new(
+      name,
+      namespace: namespace,
+      to: to,
+      lang_tagged: lang_tagged,
+      as: as,
+    )
+  end
+
+  def members(attr_name, inline: true, link: nil)
+    @rdf_members << Lutaml::Rdf::MemberRule.new(attr_name, inline: inline, link: link)
+  end
+
+  def deep_dup
+    self.class.new.tap do |new_mapping|
+      new_mapping.namespace_set = @namespace_set
+      new_mapping.rdf_subject = @rdf_subject
+      new_mapping.rdf_type = @rdf_type
+      new_mapping.rdf_types = @rdf_types&.dup
+      new_mapping.rdf_predicates = @rdf_predicates.dup
+      new_mapping.rdf_members = @rdf_members.dup
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_citation.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    class GlossCitation < Lutaml::Model::Serializable
+      attribute :source, :string
+      attribute :id, :string
+      attribute :version, :string
+      attribute :link, :string
+      attribute :locality, GlossLocality
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace
+
+        subject { |c| "citation/#{GlossCitation.slug(c)}" }
+
+        types "gloss:Citation"
+
+        predicate :citationSource, namespace: Namespaces::GlossaristNamespace, to: :source
+        predicate :citationId, namespace: Namespaces::GlossaristNamespace, to: :id
+        predicate :citationVersion, namespace: Namespaces::GlossaristNamespace, to: :version
+        predicate :citationLink, namespace: Namespaces::GlossaristNamespace, to: :link
+
+        members :locality, link: "gloss:hasLocality"
+      end
+
+      def self.slug(citation)
+        slug = [citation.source, citation.id].compact.join("/")
+        slug = Digest::MD5.hexdigest(citation.source || "")[0..11] if slug.empty?
+        slug
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_concept.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    class GlossConcept < Lutaml::Model::Serializable
+      include Relationships
+
+      attribute :identifier, :string
+      attribute :status, :string
+      attribute :localizations, GlossLocalizedConcept, collection: true
+      attribute :sources, GlossConceptSource, collection: true
+      attribute :domains, GlossConceptReference, collection: true
+      attribute :dates, GlossConceptDate, collection: true
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace,
+                  Namespaces::SkosNamespace,
+                  Namespaces::DctermsNamespace,
+                  Namespaces::SkosxlNamespace,
+                  Namespaces::IsoThesNamespace,
+                  Namespaces::RdfNamespace
+
+        subject { |c| "concept/#{c.identifier}" }
+
+        types "gloss:Concept", "skos:Concept"
+
+        predicate :identifier, namespace: Namespaces::GlossaristNamespace, to: :identifier
+        predicate :hasStatus, namespace: Namespaces::GlossaristNamespace, to: :status, as: :uri
+
+        members :localizations,
+                link: "gloss:hasLocalization"
+        members :sources,
+                link: "gloss:hasSource"
+        members :domains,
+                link: "gloss:hasDomain"
+        members :dates,
+                link: "gloss:hasDate"
+      end
+    end
+
+    class GlossDocument < Lutaml::Model::Serializable
+      attribute :concepts, GlossConcept, collection: true
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace,
+                  Namespaces::SkosNamespace,
+                  Namespaces::DctermsNamespace,
+                  Namespaces::SkosxlNamespace,
+                  Namespaces::IsoThesNamespace,
+                  Namespaces::RdfNamespace
+
+        members :concepts
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_concept_date.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    class GlossConceptDate < Lutaml::Model::Serializable
+      attribute :date_value, :string
+      attribute :date_type, :string
+      attribute :concept_id, :string
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace
+
+        subject { |d| "concept/#{d.concept_id}/date/#{d.date_type}" }
+
+        types "gloss:ConceptDate"
+
+        predicate :dateValue, namespace: Namespaces::GlossaristNamespace, to: :date_value
+        predicate :dateType, namespace: Namespaces::GlossaristNamespace, to: :date_type, as: :uri
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_concept_reference.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    class GlossConceptReference < Lutaml::Model::Serializable
+      attribute :term, :string
+      attribute :concept_id, :string
+      attribute :source, :string
+      attribute :ref_type, :string
+      attribute :urn, :string
+      attribute :parent_id, :string
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace
+
+        subject { |r| "concept/#{r.parent_id}/ref/#{r.concept_id || r.urn}" }
+
+        types "gloss:ConceptReference"
+
+        predicate :refType, namespace: Namespaces::GlossaristNamespace, to: :ref_type
+        predicate :conceptId, namespace: Namespaces::GlossaristNamespace, to: :concept_id
+        predicate :sourceUri, namespace: Namespaces::GlossaristNamespace, to: :source
+        predicate :urn, namespace: Namespaces::GlossaristNamespace, to: :urn
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_concept_source.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    class GlossConceptSource < Lutaml::Model::Serializable
+      attribute :status, :string
+      attribute :type, :string
+      attribute :modification, :string
+      attribute :origin, GlossCitation
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace
+
+        subject { |s| "source/#{GlossConceptSource.deterministic_id(s)}" }
+
+        types "gloss:ConceptSource"
+
+        predicate :sourceStatus, namespace: Namespaces::GlossaristNamespace, to: :status, as: :uri
+        predicate :sourceType, namespace: Namespaces::GlossaristNamespace, to: :type, as: :uri
+        predicate :modification, namespace: Namespaces::GlossaristNamespace, to: :modification
+
+        members :origin, link: "gloss:sourceOrigin"
+      end
+
+      def self.deterministic_id(source)
+        parts = [source.status, source.type, source.modification]
+        origin = source.origin
+        if origin
+          parts << origin.source << origin.id << origin.version << origin.link
+        end
+        Digest::MD5.hexdigest(parts.compact.join("|"))[0..11]
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_designation.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    COMMON_DESIGNATION_PREDICATES = lambda { |dsl|
+      dsl.predicate :literalForm, namespace: Namespaces::SkosxlNamespace, to: :designation
+      dsl.predicate :normativeStatus, namespace: Namespaces::GlossaristNamespace, to: :normative_status, as: :uri
+      dsl.predicate :hasTermType, namespace: Namespaces::GlossaristNamespace, to: :term_type, as: :uri
+      dsl.predicate :isInternational, namespace: Namespaces::GlossaristNamespace, to: :international
+      dsl.predicate :isAbsent, namespace: Namespaces::GlossaristNamespace, to: :absent
+      dsl.predicate :geographicalArea, namespace: Namespaces::GlossaristNamespace, to: :language
+      dsl.predicate :language, namespace: Namespaces::DctermsNamespace, to: :lang_code
+      dsl.predicate :script, namespace: Namespaces::GlossaristNamespace, to: :script
+      dsl.predicate :conversionSystem, namespace: Namespaces::GlossaristNamespace, to: :system
+      dsl.members :pronunciations, link: "gloss:hasPronunciation"
+      dsl.members :sources
+    }.freeze
+
+    DESIGNATION_NAMESPACES = [
+      Namespaces::GlossaristNamespace,
+      Namespaces::SkosxlNamespace,
+      Namespaces::SkosNamespace,
+      Namespaces::DctermsNamespace,
+      Namespaces::IsoThesNamespace,
+    ].freeze
+
+    class GlossDesignation < Lutaml::Model::Serializable
+      include Relationships
+
+      attribute :designation, :string
+      attribute :normative_status, :string
+      attribute :type, :string
+      attribute :language, :string
+      attribute :script, :string
+      attribute :system, :string
+      attribute :international, :boolean
+      attribute :absent, :boolean
+      attribute :term_type, :string
+      attribute :concept_id, :string
+      attribute :lang_code, :string
+      attribute :index, :string
+      attribute :pronunciations, GlossPronunciation, collection: true
+      attribute :sources, GlossConceptSource, collection: true
+
+      rdf do
+        namespace(*DESIGNATION_NAMESPACES)
+
+        subject { |d| "concept/#{d.concept_id}/#{d.lang_code}/designation/#{d.index}" }
+
+        types "gloss:Designation", "skosxl:Label"
+
+        COMMON_DESIGNATION_PREDICATES.call(self)
+      end
+    end
+
+    class GlossExpression < GlossDesignation
+      attribute :prefix, :string
+      attribute :usage_info, :string
+      attribute :field_of_application, :string
+      attribute :grammar_info, GlossGrammarInfo, collection: true
+
+      rdf do
+        namespace(*DESIGNATION_NAMESPACES)
+
+        subject { |d| "concept/#{d.concept_id}/#{d.lang_code}/designation/#{d.index}" }
+
+        types "gloss:Expression", "skosxl:Label"
+
+        COMMON_DESIGNATION_PREDICATES.call(self)
+        predicate :prefix, namespace: Namespaces::GlossaristNamespace, to: :prefix
+        predicate :usageInfo, namespace: Namespaces::GlossaristNamespace, to: :usage_info
+        predicate :fieldOfApplication, namespace: Namespaces::GlossaristNamespace, to: :field_of_application
+        members :grammar_info, link: "gloss:hasGrammarInfo"
+      end
+    end
+
+    class GlossAbbreviation < GlossExpression
+      attribute :acronym, :boolean
+      attribute :initialism, :boolean
+      attribute :truncation, :boolean
+
+      rdf do
+        namespace(*DESIGNATION_NAMESPACES)
+
+        subject { |d| "concept/#{d.concept_id}/#{d.lang_code}/designation/#{d.index}" }
+
+        types "gloss:Abbreviation", "skosxl:Label"
+
+        COMMON_DESIGNATION_PREDICATES.call(self)
+        predicate :prefix, namespace: Namespaces::GlossaristNamespace, to: :prefix
+        predicate :usageInfo, namespace: Namespaces::GlossaristNamespace, to: :usage_info
+        predicate :fieldOfApplication, namespace: Namespaces::GlossaristNamespace, to: :field_of_application
+        members :grammar_info, link: "gloss:hasGrammarInfo"
+        predicate :isAcronym, namespace: Namespaces::GlossaristNamespace, to: :acronym
+        predicate :isInitialism, namespace: Namespaces::GlossaristNamespace, to: :initialism
+        predicate :isTruncation, namespace: Namespaces::GlossaristNamespace, to: :truncation
+      end
+    end
+
+    class GlossSymbol < GlossDesignation
+      rdf do
+        namespace(*DESIGNATION_NAMESPACES)
+
+        subject { |d| "concept/#{d.concept_id}/#{d.lang_code}/designation/#{d.index}" }
+
+        types "gloss:Symbol", "skosxl:Label"
+
+        COMMON_DESIGNATION_PREDICATES.call(self)
+      end
+    end
+
+    class GlossLetterSymbol < GlossSymbol
+      attribute :text, :string
+
+      rdf do
+        namespace(*DESIGNATION_NAMESPACES)
+
+        subject { |d| "concept/#{d.concept_id}/#{d.lang_code}/designation/#{d.index}" }
+
+        types "gloss:LetterSymbol", "skosxl:Label"
+
+        COMMON_DESIGNATION_PREDICATES.call(self)
+        predicate :text, namespace: Namespaces::GlossaristNamespace, to: :text
+      end
+    end
+
+    class GlossGraphicalSymbol < GlossSymbol
+      attribute :text, :string
+      attribute :image, :string
+
+      rdf do
+        namespace(*DESIGNATION_NAMESPACES)
+
+        subject { |d| "concept/#{d.concept_id}/#{d.lang_code}/designation/#{d.index}" }
+
+        types "gloss:GraphicalSymbol", "skosxl:Label"
+
+        COMMON_DESIGNATION_PREDICATES.call(self)
+        predicate :text, namespace: Namespaces::GlossaristNamespace, to: :text
+        predicate :image, namespace: Namespaces::GlossaristNamespace, to: :image
+      end
+    end
+  end
+end