lutaml-model 0.8.4 → 0.8.6

data/lib/lutaml/jsonld/context.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module JsonLd
+    class Context
+      attr_reader :prefixes, :terms
+
+      def initialize
+        @prefixes = {}
+        @terms = {}
+        @vocab = nil
+        @language = nil
+        @base = nil
+      end
+
+      def prefix(namespace_class)
+        @prefixes[namespace_class.prefix] = namespace_class.uri
+      end
+
+      def vocab(uri = nil)
+        @vocab = uri if uri
+        @vocab
+      end
+
+      def language(lang = nil)
+        @language = lang if lang
+        @language
+      end
+
+      def base(uri = nil)
+        @base = uri if uri
+        @base
+      end
+
+      def term(name, id: nil, type: nil, container: nil, language: nil,
+reverse: false)
+        @terms[name] = TermDefinition.new(
+          name: name,
+          id: id,
+          type: type,
+          container: container,
+          language: language,
+          reverse: reverse,
+        )
+      end
+
+      def to_hash
+        ctx = {}
+        ctx["@vocab"] = @vocab if @vocab
+        ctx["@language"] = @language if @language
+        ctx["@base"] = @base if @base
+        @prefixes.each { |pfx, uri| ctx[pfx] = uri }
+        @terms.each_value { |td| ctx.merge!(td.to_context_hash) }
+        ctx
+      end
+
+      def resolve(term_name)
+        if term_name.include?(":")
+          pfx, local = term_name.split(":", 2)
+          "#{@prefixes[pfx]}#{local}" if @prefixes.key?(pfx)
+        elsif @terms.key?(term_name)
+          @terms[term_name].id
+        elsif @vocab
+          "#{@vocab}#{term_name}"
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/jsonld/term_definition.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module JsonLd
+    class TermDefinition
+      attr_reader :name, :id, :type, :container, :language, :reverse
+
+      def initialize(name:, id: nil, type: nil, container: nil, language: nil,
+reverse: false)
+        @name = name
+        @id = id
+        @type = type
+        @container = container
+        @language = language
+        @reverse = reverse
+      end
+
+      def to_context_hash
+        if simple_mapping?
+          { @name => @id }
+        else
+          defn = {}
+          defn["@id"] = @id if @id
+          defn["@type"] = @type if @type
+          defn["@container"] = "@#{@container}" if @container
+          defn["@language"] = @language if @language
+          defn["@reverse"] = @reverse if @reverse
+          { @name => defn }
+        end
+      end
+
+      private
+
+      def simple_mapping?
+        @id && @type.nil? && @container.nil? && @language.nil? && !@reverse
+      end
+    end
+  end
+end

data/lib/lutaml/jsonld/transform.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Lutaml
+  module JsonLd
+    class Transform < Lutaml::Rdf::Transform
+      def model_to_data(instance, _format, options = {})
+        mapping = extract_mapping(options)
+        return {} unless mapping
+
+        if mapping.rdf_members.any?
+          build_graph_document(mapping, instance)
+        else
+          build_resource_object(mapping, instance)
+        end
+      end
+
+      def data_to_model(data, _format, options = {})
+        mapping = extract_mapping(options)
+        return model_class.new unless mapping
+
+        hash = data.is_a?(String) ? JSON.parse(data) : data
+
+        if hash.key?("@graph") && hash["@graph"].is_a?(Array) && !hash["@graph"].empty?
+          graph_data = hash["@graph"]
+          first = graph_data.first
+          hash = first.is_a?(Hash) ? first : {}
+        end
+
+        hash = strip_jsonld_keywords(hash)
+
+        attrs = {}
+        mapping.rdf_predicates.each do |rule|
+          value = hash[rule.predicate_name]
+          next if value.nil?
+
+          attrs[rule.to] = if rule.lang_tagged && value.is_a?(Hash)
+                             flatten_language_map(value)
+                           else
+                             value
+                           end
+        end
+
+        build_instance(attrs, options)
+      end
+
+      private
+
+      def extract_mapping(options)
+        options[:mappings] || mappings_for(:jsonld, lutaml_register)
+      end
+
+      def build_graph_document(mapping, instance)
+        context = build_merged_context(mapping, instance)
+        graph = []
+
+        if mapping.rdf_subject
+          resource = build_resource_data(mapping, instance)
+          graph << resource unless resource.empty?
+        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[:jsonld]
+            next unless member_mapping
+
+            resource = build_resource_data(member_mapping, member)
+            graph << resource unless resource.empty?
+          end
+        end
+
+        { "@context" => context, "@graph" => graph }
+      end
+
+      def build_merged_context(mapping, instance)
+        context_hash = build_context_from_mapping(mapping).to_hash
+
+        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[:jsonld]
+          next unless member_mapping
+
+          context_hash.merge!(build_context_from_mapping(member_mapping).to_hash)
+        end
+
+        context_hash
+      end
+
+      def build_context_from_mapping(mapping)
+        context = Context.new
+        mapping.namespace_set.each { |ns| context.prefix(ns) }
+        mapping.rdf_predicates.each do |pred|
+          if pred.lang_tagged
+            context.term(pred.predicate_name,
+                         id: pred.uri,
+                         container: :language)
+          else
+            context.term(pred.predicate_name, id: pred.uri)
+          end
+        end
+        context
+      end
+
+      def build_resource_object(mapping, instance)
+        context = build_context_from_mapping(mapping).to_hash
+        data = build_resource_data(mapping, instance)
+        { "@context" => context }.merge(data)
+      end
+
+      def build_resource_data(mapping, instance)
+        result = {}
+
+        if mapping.rdf_type
+          result["@type"] = resolve_type_compact(mapping)
+        end
+
+        if mapping.rdf_subject
+          result["@id"] = resolve_subject_uri(mapping, instance)
+        end
+
+        mapping.rdf_predicates.each do |rule|
+          value = instance.public_send(rule.to)
+          next if value.nil?
+          next if value.is_a?(String) && value.empty?
+
+          result[rule.predicate_name] = if rule.lang_tagged
+                                          build_language_map(value)
+                                        else
+                                          serialize_rdf_value(value)
+                                        end
+        end
+
+        result
+      end
+
+      def build_language_map(values)
+        case values
+        when Array
+          map = {}
+          values.each do |v|
+            lang = extract_language(v)
+            map[lang] = v.to_s if lang
+          end
+          map.empty? ? nil : map
+        else
+          lang = extract_language(values)
+          lang ? { lang => values.to_s } : values.to_s
+        end
+      end
+
+      def flatten_language_map(lang_map)
+        lang_map.values
+      end
+
+      def serialize_rdf_value(value)
+        case value
+        when Array then value.map { |v| serialize_rdf_value(v) }
+        when Integer, Float, TrueClass, FalseClass then value
+        else value.to_s
+        end
+      end
+
+      def strip_jsonld_keywords(data)
+        return data unless data.is_a?(Hash)
+
+        data.reject { |key, _| key.start_with?("@") }
+      end
+    end
+  end
+end

data/lib/lutaml/jsonld.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "model"
+require_relative "rdf"
+
+module Lutaml
+  module JsonLd
+    autoload :Context, "#{__dir__}/jsonld/context"
+    autoload :TermDefinition, "#{__dir__}/jsonld/term_definition"
+    autoload :Transform, "#{__dir__}/jsonld/transform"
+    autoload :Adapter, "#{__dir__}/jsonld/adapter"
+  end
+end
+
+Lutaml::Model::FormatRegistry.register(
+  :jsonld,
+  mapping_class: Lutaml::Rdf::Mapping,
+  adapter_class: Lutaml::JsonLd::Adapter,
+  transformer: Lutaml::JsonLd::Transform,
+  key_value: false,
+  rdf: true,
+  error_types: ["JSON::ParserError"],
+)

data/lib/lutaml/model/format_registry.rb

@@ -23,7 +23,7 @@ module Lutaml
         # @param adapter_options [Hash, nil] { available: [...], default: :name }
         def register(format, mapping_class:, adapter_class:, transformer:,
                      adapter_loader: nil, castable_type: nil, key_value: nil,
-                     error_types: nil, adapter_options: nil)
+                     rdf: nil, error_types: nil, adapter_options: nil)
           validate_registration!(format, mapping_class, transformer)
 
           registered_formats[format] = {
@@ -33,6 +33,7 @@ module Lutaml
             adapter_loader: adapter_loader,
             castable_type: castable_type,
             key_value: key_value,
+            rdf: rdf,
             error_types: error_types,
             adapter_options: adapter_options,
             registered_at: Time.now,
@@ -109,6 +110,14 @@ module Lutaml
           registered_formats.dig(format, :key_value) == true
         end
 
+        def rdf_formats
+          registered_formats.select { |_, info| info[:rdf] }.keys
+        end
+
+        def rdf?(format)
+          registered_formats.dig(format, :rdf) == true
+        end
+
         def error_types_for(format)
           registered_formats.dig(format, :error_types)
         end

data/lib/lutaml/model/serialize/format_conversion.rb

@@ -15,7 +15,12 @@ module Lutaml
         # @param block [Proc] The DSL block to evaluate
         def process_mapping(format, *_args, &)
           klass = ::Lutaml::Model::Config.mappings_class_for(format)
-          mappings[format] ||= klass.new
+          existing = mappings[format]
+          mappings[format] = if existing.nil? || !existing.is_a?(klass)
+                               klass.new
+                             else
+                               existing
+                             end
           mappings[format].instance_eval(&)
 
           if mappings[format].respond_to?(:finalize)
@@ -273,6 +278,17 @@ module Lutaml
           end
         end
 
+        # Define RDF mappings for multiple formats (Turtle, JSON-LD, etc.).
+        # Discovers RDF formats dynamically from FormatRegistry.
+        #
+        # @param block [Proc] The DSL block
+        def rdf(&block)
+          Lutaml::Model::FormatRegistry.rdf_formats.each do |format|
+            mappings[format] = Lutaml::Rdf::Mapping.new
+            mappings[format].instance_eval(&block)
+          end
+        end
+
         # Get resolved mapping for a format
         #
         # Delegates to TransformationRegistry for centralized caching

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.4"
+    VERSION = "0.8.6"
   end
 end

data/lib/lutaml/model.rb

@@ -10,6 +10,8 @@ module Lutaml
   autoload :Jsonl, "#{__dir__}/jsonl"
   autoload :Yamls, "#{__dir__}/yamls"
   autoload :Xml, "#{__dir__}/xml"
+  autoload :JsonLd, "#{__dir__}/jsonld"
+  autoload :Turtle, "#{__dir__}/turtle"
 
   module Model
     # Autoloads for lazy loading - set up BEFORE any requires
@@ -241,6 +243,10 @@ require "#{__dir__}/jsonl"
 require "#{__dir__}/yamls"
 require "#{__dir__}/xml"
 
+# Optional formats: require "lutaml/jsonld" or "lutaml/turtle" to enable.
+# These are not eagerly loaded because they depend on optional gems
+# (e.g., rdf-turtle) that most users don't need.
+
 # Prepend builder interface into Serialize
 # Builder must be prepended AFTER XML so its initialize runs first
 # (Builder -> XML InstanceMethods -> Serialize)

data/lib/lutaml/rdf/error.rb

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

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