lutaml-model 0.8.4 → 0.8.5

data/lib/lutaml/rdf/iri.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Rdf
+    class Iri
+      include Comparable
+
+      attr_reader :value
+
+      def initialize(uri_string)
+        @value = uri_string.to_s.freeze
+      end
+
+      def expand(namespace_set)
+        namespace_set.resolve_compact_iri(value)
+      end
+
+      def compact(namespace_set)
+        namespace_set.compact(value)
+      end
+
+      def <=>(other)
+        other.is_a?(self.class) ? value <=> other.value : nil
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && value == other.value
+      end
+      alias_method :eql?, :==
+
+      def hash
+        value.hash
+      end
+
+      def to_s
+        value
+      end
+
+      def inspect
+        "#<#{self.class.name} #{value}>"
+      end
+    end
+  end
+end

data/lib/lutaml/rdf/language_tagged.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Rdf
+    module LanguageTagged
+      def language_tag
+        language
+      end
+    end
+  end
+end

data/lib/lutaml/rdf/literal.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Rdf
+    class Literal
+      include LanguageTagged
+
+      attr_reader :value, :datatype, :language
+
+      def initialize(value, datatype: nil, language: nil)
+        @value = value
+        @datatype = datatype
+        @language = language
+      end
+
+      def to_turtle
+        escaped = escape_turtle(value.to_s)
+        if language
+          "#{escaped}@#{language}"
+        elsif datatype
+          "#{escaped}^^<#{datatype}>"
+        else
+          escaped
+        end
+      end
+
+      def to_jsonld_term
+        if language
+          { "@value" => value, "@language" => language }
+        elsif datatype
+          { "@value" => value, "@type" => datatype.to_s }
+        else
+          value
+        end
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          value == other.value &&
+          datatype == other.datatype &&
+          language == other.language
+      end
+      alias_method :eql?, :==
+
+      def hash
+        [value, datatype, language].hash
+      end
+
+      private
+
+      def escape_turtle(str)
+        escaped = str.gsub(/[\n\r\t"\\]/,
+                           "\\" => "\\\\",
+                           '"' => "\\\"",
+                           "\n" => "\\n",
+                           "\r" => "\\r",
+                           "\t" => "\\t")
+        "\"#{escaped}\""
+      end
+    end
+  end
+end

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