lutaml-model 0.8.4 → 0.8.6

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/adapter_helpers.rb

@@ -29,7 +29,7 @@ module Lutaml
           when Moxml::Cdata
             "#cdata-section"
           when Moxml::ProcessingInstruction
-            "processing_instruction"
+            element.target
           when Moxml::Comment
             "comment"
           else
@@ -102,47 +102,6 @@ module Lutaml
         def text_node?(node)
           TEXT_CLASSES.include?(node.class)
         end
-
-        # Build Element object from child node
-        #
-        # @param child [Moxml::Node] The child node
-        # @return [Element] The Element object
-        def build_element_from_child(child)
-          if text_node?(child)
-            Element.new("Text", "text", node_type: :text)
-          else
-            Element.new("Element", name_of(child), node_type: :element)
-          end
-        end
-
-        # Get the prefix for a namespace URI from hoisted declarations
-        #
-        # This checks if a namespace URI is already declared in hoisted_declarations
-        # and returns the prefix that should be used. This prevents duplicate xmlns
-        # declarations when both hoisted_declarations and attribute code try to add
-        # the same namespace.
-        #
-        # @param namespace_uri [String] The namespace URI to look up
-        # @param hoisted_declarations [Hash{String, nil => String}] The hoisted declarations
-        #   (keys are prefixes or nil for default, values are URIs)
-        # @return [String, nil] The prefix if found, nil if not hoisted
-        def prefix_for_namespace_uri(namespace_uri, hoisted_declarations)
-          return nil unless hoisted_declarations
-
-          hoisted_declarations.each do |prefix, uri|
-            return prefix if uri == namespace_uri
-          end
-          nil
-        end
-
-        # Check if a namespace URI is already hoisted
-        #
-        # @param namespace_uri [String] The namespace URI to check
-        # @param hoisted_declarations [Hash{String, nil => String}] The hoisted declarations
-        # @return [Boolean] true if the namespace is already hoisted
-        def namespace_uri_hoisted?(namespace_uri, hoisted_declarations)
-          prefix_for_namespace_uri(namespace_uri, hoisted_declarations) != nil
-        end
       end
     end
   end