lutaml-model 0.8.3 → 0.8.5

data/lib/lutaml/rdf/mapping.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Rdf
+    class Mapping < Lutaml::Model::Mapping
+      attr_reader :namespace_set, :rdf_subject, :rdf_type, :rdf_predicates,
+                  :rdf_members
+
+      def initialize
+        super
+        @namespace_set = Lutaml::Rdf::NamespaceSet.new
+        @rdf_subject = nil
+        @rdf_type = nil
+        @rdf_predicates = []
+        @rdf_members = []
+      end
+
+      def namespace(*namespace_classes)
+        @namespace_set = Lutaml::Rdf::NamespaceSet.new(*namespace_classes)
+      end
+
+      def subject(&)
+        @rdf_subject = Proc.new(&) if block_given?
+      end
+
+      def type(value)
+        @rdf_type = value
+      end
+
+      def predicate(name, namespace:, to:, lang_tagged: false)
+        @rdf_predicates << Lutaml::Rdf::MappingRule.new(
+          name,
+          namespace: namespace,
+          to: to,
+          lang_tagged: lang_tagged,
+        )
+      end
+
+      def members(attr_name)
+        @rdf_members << Lutaml::Rdf::MemberRule.new(attr_name)
+      end
+
+      def mappings(_register_id = nil)
+        @rdf_predicates
+      end
+
+      def finalize(_mapper_class); end
+
+      def finalized?
+        true
+      end
+
+      def map_element(name, to:)
+        raise Lutaml::Model::IncorrectMappingArgumentsError,
+              "RDF mappings use `predicate` instead of `map_element`. " \
+              "Use `predicate :#{name}, namespace: MyNs, to: :#{to}` inside `rdf do`."
+      end
+
+      def deep_dup
+        self.class.new.tap do |new_mapping|
+          new_mapping.instance_variable_set(:@namespace_set, @namespace_set)
+          new_mapping.instance_variable_set(:@rdf_subject, @rdf_subject)
+          new_mapping.instance_variable_set(:@rdf_type, @rdf_type)
+          new_mapping.instance_variable_set(:@rdf_predicates,
+                                            @rdf_predicates.dup)
+          new_mapping.instance_variable_set(:@rdf_members, @rdf_members.dup)
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/rdf/mapping_rule.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Rdf
+    class MappingRule
+      attr_reader :predicate_name, :namespace, :to, :lang_tagged
+
+      def initialize(predicate_name, namespace:, to:, lang_tagged: false)
+        validate!(predicate_name, namespace, to)
+        @predicate_name = predicate_name.to_s.freeze
+        @namespace = namespace
+        @to = to
+        @lang_tagged = lang_tagged
+      end
+
+      def uri
+        @namespace[@predicate_name]
+      end
+
+      def prefixed_name
+        @namespace.prefixed(@predicate_name)
+      end
+
+      private
+
+      def validate!(name, namespace_class, target)
+        raise ArgumentError, "predicate_name is required" unless name
+        unless namespace_class.is_a?(Class) && namespace_class < Lutaml::Rdf::Namespace
+          raise ArgumentError, "namespace must be a Rdf::Namespace subclass"
+        end
+        raise ArgumentError, ":to is required" unless target
+      end
+    end
+  end
+end

data/lib/lutaml/rdf/member_rule.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Rdf
+    class MemberRule
+      attr_reader :attr_name
+
+      def initialize(attr_name)
+        @attr_name = attr_name.to_sym
+      end
+    end
+  end
+end

data/lib/lutaml/rdf/namespace.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Rdf
+    class Namespace
+      class << self
+        def uri(value = nil)
+          return @uri if value.nil?
+          if @uri
+            raise FrozenError,
+                  "#{name}.uri is already set to #{@uri.inspect}"
+          end
+
+          @uri = value.freeze
+        end
+
+        def prefix(value = nil)
+          return @prefix if value.nil?
+          if @prefix
+            raise FrozenError,
+                  "#{name}.prefix is already set to #{@prefix.inspect}"
+          end
+
+          @prefix = value.to_s.freeze
+        end
+
+        def [](local_name)
+          "#{uri}#{local_name}"
+        end
+
+        def prefixed(local_name)
+          "#{prefix}:#{local_name}"
+        end
+
+        def resolve_compact_iri(compact_iri, namespaces)
+          return compact_iri unless compact_iri.include?(":")
+
+          pfx, local = compact_iri.split(":", 2)
+          ns = namespaces.find { |n| n.prefix == pfx }
+          ns ? ns[local] : compact_iri
+        end
+
+        def ==(other)
+          other.is_a?(Class) && other < Namespace &&
+            other.uri == uri && other.prefix == prefix
+        end
+
+        def hash
+          [uri, prefix].hash
+        end
+
+        def to_s
+          "#{name}(prefix: #{prefix.inspect}, uri: #{uri.inspect})"
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/rdf/namespace_set.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Rdf
+    class NamespaceSet
+      include Enumerable
+
+      def initialize(*namespace_classes)
+        @by_prefix = {}
+        namespace_classes.each { |ns| add(ns) }
+      end
+
+      def add(namespace_class)
+        pfx = namespace_class.prefix
+        if @by_prefix.key?(pfx) && @by_prefix[pfx] != namespace_class
+          raise ArgumentError,
+                "Prefix '#{pfx}' conflicts: #{@by_prefix[pfx].name} vs #{namespace_class.name}"
+        end
+        @by_prefix[pfx] = namespace_class
+        self
+      end
+
+      def [](prefix)
+        @by_prefix[prefix]
+      end
+
+      def resolve_compact_iri(compact_iri)
+        Namespace.resolve_compact_iri(compact_iri, to_a)
+      end
+
+      def compact(full_uri)
+        each do |ns|
+          next unless full_uri.start_with?(ns.uri)
+
+          local = full_uri.delete_prefix(ns.uri)
+          return ns.prefixed(local)
+        end
+        nil
+      end
+
+      def each(&)
+        @by_prefix.each_value(&)
+      end
+
+      def size
+        @by_prefix.size
+      end
+
+      def empty?
+        @by_prefix.empty?
+      end
+
+      def to_a
+        @by_prefix.values
+      end
+
+      def to_hash
+        @by_prefix.transform_values(&:uri)
+      end
+
+      def merge(other_set)
+        return self if equal?(other_set)
+
+        other_set.each { |ns| add(ns) }
+        self
+      end
+    end
+  end
+end

data/lib/lutaml/rdf/namespaces/dcterms_namespace.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Rdf
+    module Namespaces
+      class DctermsNamespace < Lutaml::Rdf::Namespace
+        uri "http://purl.org/dc/terms/"
+        prefix "dcterms"
+      end
+    end
+  end
+end

data/lib/lutaml/rdf/namespaces/owl_namespace.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Rdf
+    module Namespaces
+      class OwlNamespace < Lutaml::Rdf::Namespace
+        uri "http://www.w3.org/2002/07/owl#"
+        prefix "owl"
+      end
+    end
+  end
+end

data/lib/lutaml/rdf/namespaces/rdf_namespace.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Rdf
+    module Namespaces
+      class RdfSyntaxNamespace < Lutaml::Rdf::Namespace
+        uri "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+        prefix "rdf"
+      end
+
+      RdfNamespace = RdfSyntaxNamespace
+    end
+  end
+end

data/lib/lutaml/rdf/namespaces/rdfs_namespace.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Rdf
+    module Namespaces
+      class RdfsNamespace < Lutaml::Rdf::Namespace
+        uri "http://www.w3.org/2000/01/rdf-schema#"
+        prefix "rdfs"
+      end
+    end
+  end
+end

data/lib/lutaml/rdf/namespaces/skos_namespace.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Rdf
+    module Namespaces
+      class SkosNamespace < Lutaml::Rdf::Namespace
+        uri "http://www.w3.org/2004/02/skos/core#"
+        prefix "skos"
+      end
+    end
+  end
+end

data/lib/lutaml/rdf/namespaces/xsd_namespace.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Rdf
+    module Namespaces
+      class XsdNamespace < Lutaml::Rdf::Namespace
+        uri "http://www.w3.org/2001/XMLSchema#"
+        prefix "xsd"
+      end
+    end
+  end
+end

data/lib/lutaml/rdf/namespaces.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Rdf
+    module Namespaces
+      autoload :SkosNamespace, "#{__dir__}/namespaces/skos_namespace"
+      autoload :DctermsNamespace, "#{__dir__}/namespaces/dcterms_namespace"
+      autoload :RdfNamespace, "#{__dir__}/namespaces/rdf_namespace"
+      autoload :RdfsNamespace, "#{__dir__}/namespaces/rdfs_namespace"
+      autoload :OwlNamespace, "#{__dir__}/namespaces/owl_namespace"
+      autoload :XsdNamespace, "#{__dir__}/namespaces/xsd_namespace"
+    end
+  end
+end

data/lib/lutaml/rdf/transform.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Rdf
+    class Transform < Lutaml::Model::Transform
+      protected
+
+      def resolve_subject_uri(mapping, instance)
+        mapping.rdf_subject&.call(instance)
+      end
+
+      def resolve_type_uri(mapping)
+        return unless mapping.rdf_type
+
+        mapping.namespace_set.resolve_compact_iri(mapping.rdf_type)
+      end
+
+      def resolve_type_compact(mapping)
+        mapping.rdf_type
+      end
+
+      def build_instance(attrs, options)
+        child_register = Lutaml::Model::Register.resolve_for_child(
+          model_class, lutaml_register
+        )
+        instance = model_class.new(attrs.merge(lutaml_register: child_register))
+        root_and_parent_assignment(instance, options)
+        instance
+      end
+
+      def extract_language(value)
+        value.language_tag if value.is_a?(Lutaml::Rdf::LanguageTagged)
+      end
+    end
+  end
+end

data/lib/lutaml/rdf.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "model"
+
+module Lutaml
+  module Rdf
+    autoload :Error, "#{__dir__}/rdf/error"
+    autoload :Iri, "#{__dir__}/rdf/iri"
+    autoload :LanguageTagged, "#{__dir__}/rdf/language_tagged"
+    autoload :Literal, "#{__dir__}/rdf/literal"
+    autoload :Namespace, "#{__dir__}/rdf/namespace"
+    autoload :NamespaceSet, "#{__dir__}/rdf/namespace_set"
+    autoload :Mapping, "#{__dir__}/rdf/mapping"
+    autoload :MappingRule, "#{__dir__}/rdf/mapping_rule"
+    autoload :MemberRule, "#{__dir__}/rdf/member_rule"
+    autoload :Namespaces, "#{__dir__}/rdf/namespaces"
+    autoload :Transform, "#{__dir__}/rdf/transform"
+  end
+end

data/lib/lutaml/turtle/adapter.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Turtle
+    class Adapter
+      attr_reader :data, :register
+
+      def initialize(data, register: nil)
+        @data = data
+        @register = register || Lutaml::Model::Config.default_register
+      end
+
+      def self.parse(turtle_string, _options = {})
+        require "rdf/turtle"
+        graph = RDF::Graph.new
+        RDF::Turtle::Reader.new(turtle_string).each_statement do |stmt|
+          graph << stmt
+        end
+        graph
+      end
+
+      def to_turtle(_options = {})
+        require "rdf/turtle"
+        case data
+        when String
+          data
+        when RDF::Enumerable
+          RDF::Turtle::Writer.buffer { |w| data.each_statement { |s| w << s } }
+        else
+          data.to_s
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/turtle/mapping.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Turtle
+    class Mapping < Lutaml::Rdf::Mapping; end
+  end
+end

data/lib/lutaml/turtle/transform.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Turtle
+    class MissingSubjectError < Lutaml::Rdf::Error; end
+
+    class Transform < Lutaml::Rdf::Transform
+      def model_to_data(instance, _format, options = {})
+        require "rdf/turtle"
+        mapping = extract_turtle_mapping(options)
+        return "" unless mapping
+
+        if !mapping.rdf_subject && mapping.rdf_predicates.any? && mapping.rdf_members.empty?
+          raise MissingSubjectError,
+                "Turtle mapping requires a subject block"
+        end
+
+        graph = build_graph(mapping, instance)
+        return "" if graph.empty?
+
+        prefixes = build_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 = {})
+        require "rdf/turtle"
+        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
+
+        has_predicates_or_type = mapping.rdf_type || mapping.rdf_predicates.any?
+
+        if has_predicates_or_type
+          subject_uri = if mapping.rdf_subject
+                          RDF::URI(resolve_subject_uri(mapping, instance))
+                        else
+                          RDF::Node.new
+                        end
+
+          if mapping.rdf_type
+            type_uri = RDF::URI(resolve_type_uri(mapping))
+            graph << RDF::Statement.new(subject_uri, RDF.type, type_uri)
+          end
+
+          mapping.rdf_predicates.each do |rule|
+            value = instance.public_send(rule.to)
+            next if value.nil?
+
+            Array(value).each do |v|
+              object = build_rdf_object(v, rule)
+              graph << RDF::Statement.new(subject_uri, RDF::URI(rule.uri),
+                                          object)
+            end
+          end
+        end
+
+        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
+
+        graph
+      end
+
+      def build_rdf_object(value, rule)
+        if 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 build_prefixes(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?
+
+          member_mapping = collection.first.class.mappings[:turtle]
+          next unless member_mapping
+
+          ns_set = ns_set.merge(member_mapping.namespace_set)
+        end
+
+        ns_set.each.with_object({}) do |ns, h|
+          h[ns.prefix.to_sym] = ns.uri if ns.prefix && ns.uri
+        end
+      end
+
+      def extract_attributes(graph, mapping)
+        attrs = {}
+        type_uri = resolve_type_uri(mapping)
+
+        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 { |s| literal_to_ruby(s.object) }
+            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/lutaml/turtle.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "model"
+require_relative "rdf"
+
+module Lutaml
+  module Turtle
+    autoload :Mapping, "#{__dir__}/turtle/mapping"
+    autoload :Transform, "#{__dir__}/turtle/transform"
+    autoload :Adapter, "#{__dir__}/turtle/adapter"
+  end
+end
+
+Lutaml::Model::FormatRegistry.register(
+  :turtle,
+  mapping_class: Lutaml::Turtle::Mapping,
+  adapter_class: Lutaml::Turtle::Adapter,
+  transformer: Lutaml::Turtle::Transform,
+  key_value: false,
+  rdf: true,
+  error_types: ["RDF::ReaderError"],
+)

data/lib/lutaml/xml/adapter/nokogiri_adapter.rb

@@ -191,9 +191,13 @@ module Lutaml
         def order
           children.filter_map do |child|
             if child.text?
-              next if child.text.nil? || child.text.strip.empty?
+              next if child.text.nil?
 
               Element.new("Text", "text", text_content: child.text)
+            elsif child.comment?
+              Element.new("Comment", "comment",
+                          text_content: child.content,
+                          node_type: :comment)
             else
               Element.new("Element", child.unprefixed_name)
             end
@@ -967,7 +971,7 @@ module Lutaml
           # Pass THIS element as parent so children can inherit namespaces
           child_element_index = 0
           previous_sibling_had_xmlns_blank = false
-          xml_element.children.each do |xml_child|
+          xml_element.children.each do |xml_child| # rubocop:disable Metrics/BlockLength
             # Entity reference nodes are preserved via the marker
             # preprocessing approach in NokogiriAdapter.parse.
             if xml_child.is_a?(Lutaml::Xml::NokogiriElement) &&
@@ -993,6 +997,9 @@ module Lutaml
             elsif xml_child.is_a?(String)
               add_content_node(element, xml_child, doc,
                                cdata: xml_element.cdata && !xml_child.strip.empty?)
+            elsif xml_child.is_a?(::Lutaml::Xml::DataModel::XmlComment)
+              comment_node = doc.create_comment(xml_child.content)
+              element.add_child(comment_node)
             end
           end