lutaml-model 0.1.0

data/lib/lutaml/model/json_adapter/standard.rb

@@ -0,0 +1,20 @@
+# lib/lutaml/model/json_adapter/standard.rb
+require "json"
+require_relative "../json_adapter"
+
+module Lutaml
+  module Model
+    module JsonAdapter
+      class StandardDocument < Document
+        def self.parse(json)
+          attributes = JSON.parse(json, create_additions: false)
+          new(attributes)
+        end
+
+        def to_json(*args)
+          JSON.generate(@attributes, *args)
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/json_adapter.rb

@@ -0,0 +1,38 @@
+# lib/lutaml/model/json_adapter.rb
+require "json"
+
+module Lutaml
+  module Model
+    module JsonAdapter
+      class JsonObject
+        attr_reader :attributes
+
+        def initialize(attributes = {})
+          @attributes = attributes
+        end
+
+        def [](key)
+          @attributes[key]
+        end
+
+        def []=(key, value)
+          @attributes[key] = value
+        end
+
+        def to_h
+          @attributes
+        end
+      end
+
+      class Document < JsonObject
+        def self.parse(json)
+          raise NotImplementedError, "Subclasses must implement `parse`."
+        end
+
+        def to_json(*args)
+          raise NotImplementedError, "Subclasses must implement `to_json`."
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/key_value_mapping.rb

@@ -0,0 +1,20 @@
+# lib/lutaml/model/key_value_mapping.rb
+require_relative "key_value_mapping_rule"
+
+module Lutaml
+  module Model
+    class KeyValueMapping
+      attr_reader :mappings
+
+      def initialize
+        @mappings = []
+      end
+
+      def map(name, to:, render_nil: false, with: {}, delegate: nil)
+        @mappings << KeyValueMappingRule.new(name, to: to, render_nil: render_nil, with: with, delegate: delegate)
+      end
+
+      alias map_element map
+    end
+  end
+end

data/lib/lutaml/model/key_value_mapping_rule.rb

@@ -0,0 +1,10 @@
+# lib/lutaml/model/key_value_mapping_rule.rb
+require_relative "mapping_rule"
+
+module Lutaml
+  module Model
+    class KeyValueMappingRule < MappingRule
+      # No additional attributes or methods required for now
+    end
+  end
+end

data/lib/lutaml/model/mapping_rule.rb

@@ -0,0 +1,34 @@
+# lib/lutaml/model/mapping_rule.rb
+module Lutaml
+  module Model
+    class MappingRule
+      attr_reader :name, :to, :render_nil, :custom_methods, :delegate
+
+      def initialize(name, to:, render_nil: false, with: {}, delegate: nil)
+        @name = name
+        @to = to
+        @render_nil = render_nil
+        @custom_methods = with
+        @delegate = delegate
+      end
+
+      alias from name
+
+      def serialize(model, value)
+        if custom_methods[:to]
+          model.send(custom_methods[:to], model, value)
+        else
+          value
+        end
+      end
+
+      def deserialize(model, doc)
+        if custom_methods[:from]
+          model.send(custom_methods[:from], model, doc)
+        else
+          doc[name.to_s]
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/json_schema.rb

@@ -0,0 +1,63 @@
+# lib/lutaml/model/schema/json_schema.rb
+require "json"
+
+module Lutaml
+  module Model
+    module Schema
+      class JsonSchema
+        def self.generate(klass, options = {})
+          schema = {
+            "$schema" => "https://json-schema.org/draft/2020-12/schema",
+            "$id" => options[:id],
+            "description" => options[:description],
+            "$ref" => "#/$defs/#{klass.name}",
+            "$defs" => generate_definitions(klass),
+          }.compact
+
+          options[:pretty] ? JSON.pretty_generate(schema) : schema.to_json
+        end
+
+        private
+
+        def self.generate_definitions(klass)
+          {
+            klass.name => {
+              "type" => "object",
+              "properties" => generate_properties(klass),
+              "required" => klass.attributes.keys,
+            },
+          }
+        end
+
+        def self.generate_properties(klass)
+          klass.attributes.each_with_object({}) do |(name, attr), properties|
+            properties[name] = generate_property_schema(attr)
+          end
+        end
+
+        def self.generate_property_schema(attr)
+          { "type" => get_json_type(attr.type) }
+        end
+
+        def self.get_json_type(type)
+          case type
+          when Lutaml::Model::Type::String
+            "string"
+          when Lutaml::Model::Type::Integer
+            "integer"
+          when Lutaml::Model::Type::Boolean
+            "boolean"
+          when Lutaml::Model::Type::Float
+            "number"
+          when Lutaml::Model::Type::Array
+            "array"
+          when Lutaml::Model::Type::Hash
+            "object"
+          else
+            "string" # Default to string for unknown types
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/relaxng_schema.rb

@@ -0,0 +1,50 @@
+# lib/lutaml/model/schema/relaxng_schema.rb
+require "nokogiri"
+
+module Lutaml
+  module Model
+    module Schema
+      class RelaxngSchema
+        def self.generate(klass, options = {})
+          schema = Nokogiri::XML::Builder.new do |xml|
+            xml.element(name: klass.name) do
+              xml.complexType do
+                xml.sequence do
+                  generate_elements(klass, xml)
+                end
+              end
+            end
+          end
+          schema.to_xml
+        end
+
+        private
+
+        def self.generate_elements(klass, xml)
+          klass.attributes.each do |name, attr|
+            xml.element(name: name, type: get_relaxng_type(attr.type))
+          end
+        end
+
+        def self.get_relaxng_type(type)
+          case type
+          when Lutaml::Model::Type::String
+            "string"
+          when Lutaml::Model::Type::Integer
+            "integer"
+          when Lutaml::Model::Type::Boolean
+            "boolean"
+          when Lutaml::Model::Type::Float
+            "float"
+          when Lutaml::Model::Type::Array
+            "array"
+          when Lutaml::Model::Type::Hash
+            "object"
+          else
+            "string" # Default to string for unknown types
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/xsd_schema.rb

@@ -0,0 +1,54 @@
+# lib/lutaml/model/schema/xsd_schema.rb
+require "nokogiri"
+
+module Lutaml
+  module Model
+    module Schema
+      class XsdSchema
+        def self.generate(klass, options = {})
+          schema = Nokogiri::XML::Builder.new do |xml|
+            xml.schema(xmlns: "http://www.w3.org/2001/XMLSchema") do
+              xml.element(name: klass.name) do
+                xml.complexType do
+                  xml.sequence do
+                    generate_elements(klass, xml)
+                  end
+                end
+              end
+            end
+          end
+          schema.to_xml
+        end
+
+        private
+
+        def self.generate_elements(klass, xml)
+          klass.attributes.each do |name, attr|
+            xml.element(name: name, type: get_xsd_type(attr.type))
+          end
+        end
+
+        def self.get_xsd_type(type)
+          case type
+          when Lutaml::Model::Type::String
+            "xs:string"
+          when Lutaml::Model::Type::Integer
+            "xs:integer"
+          when Lutaml::Model::Type::Boolean
+            "xs:boolean"
+          when Lutaml::Model::Type::Float
+            "xs:float"
+          when Lutaml::Model::Type::Decimal
+            "xs:decimal"
+          when Lutaml::Model::Type::Array
+            "xs:array"
+          when Lutaml::Model::Type::Hash
+            "xs:object"
+          else
+            "xs:string" # Default to string for unknown types
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/yaml_schema.rb

@@ -0,0 +1,47 @@
+# lib/lutaml/model/schema/yaml_schema.rb
+require "yaml"
+
+module Lutaml
+  module Model
+    module Schema
+      class YamlSchema
+        def self.generate(klass, options = {})
+          schema = {
+            "type" => "map",
+            "mapping" => generate_mapping(klass),
+          }
+          YAML.dump(schema)
+        end
+
+        private
+
+        def self.generate_mapping(klass)
+          klass.attributes.each_with_object({}) do |(name, attr), mapping|
+            mapping[name.to_s] = { "type" => get_yaml_type(attr.type) }
+          end
+        end
+
+        def self.get_yaml_type(type)
+          case type
+          when Lutaml::Model::Type::String
+            "str"
+          when Lutaml::Model::Type::Integer
+            "int"
+          when Lutaml::Model::Type::Boolean
+            "bool"
+          when Lutaml::Model::Type::Float
+            "float"
+          when Lutaml::Model::Type::Decimal
+            "float" # YAML does not have a separate decimal type, so we use float
+          when Lutaml::Model::Type::Array
+            "seq"
+          when Lutaml::Model::Type::Hash
+            "map"
+          else
+            "str" # Default to string for unknown types
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema.rb

@@ -0,0 +1,27 @@
+# lib/lutaml/model/schema.rb
+require_relative "schema/json_schema"
+require_relative "schema/xsd_schema"
+require_relative "schema/relaxng_schema"
+require_relative "schema/yaml_schema"
+
+module Lutaml
+  module Model
+    module Schema
+      def self.to_json(klass, options = {})
+        JsonSchema.generate(klass, options)
+      end
+
+      def self.to_xsd(klass, options = {})
+        XsdSchema.generate(klass, options)
+      end
+
+      def self.to_relaxng(klass, options = {})
+        RelaxngSchema.generate(klass, options)
+      end
+
+      def self.to_yaml(klass, options = {})
+        YamlSchema.generate(klass, options)
+      end
+    end
+  end
+end

data/lib/lutaml/model/serializable.rb

@@ -0,0 +1,10 @@
+# lib/lutaml/model/serializable.rb
+require_relative "serialize"
+
+module Lutaml
+  module Model
+    class Serializable
+      include Serialize
+    end
+  end
+end

data/lib/lutaml/model/serialize.rb

@@ -0,0 +1,179 @@
+# lib/lutaml/model/serialize.rb
+require_relative "json_adapter/standard"
+require_relative "json_adapter/multi_json"
+require_relative "yaml_adapter"
+require_relative "xml_adapter"
+require_relative "toml_adapter/toml_rb_adapter"
+require_relative "toml_adapter/tomlib_adapter"
+require_relative "config"
+require_relative "type"
+require_relative "attribute"
+require_relative "mapping_rule"
+require_relative "xml_mapping"
+require_relative "key_value_mapping"
+require_relative "json_adapter"
+
+module Lutaml
+  module Model
+    module Serialize
+      FORMATS = %i[xml json yaml toml].freeze
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        attr_accessor :attributes, :mappings
+
+        def attribute(name, type, options = {})
+          self.attributes ||= {}
+          attr = Attribute.new(name, type, options)
+          attributes[name] = attr
+
+          define_method(name) do
+            instance_variable_get("@#{name}")
+          end
+
+          define_method("#{name}=") do |value|
+            instance_variable_set("@#{name}", value)
+          end
+        end
+
+        FORMATS.each do |format|
+          define_method(format) do |&block|
+            self.mappings ||= {}
+            klass = format == :xml ? XmlMapping : KeyValueMapping
+            self.mappings[format] = klass.new
+            self.mappings[format].instance_eval(&block)
+          end
+
+          define_method("from_#{format}") do |data|
+            adapter = Lutaml::Model::Config.send("#{format}_adapter")
+            doc = adapter.parse(data)
+            mapped_attrs = apply_mappings(doc.to_h, format)
+            apply_content_mapping(doc, mapped_attrs) if format == :xml
+            new(mapped_attrs)
+          end
+        end
+
+        def mappings_for(format)
+          self.mappings[format] || default_mappings(format)
+        end
+
+        def default_mappings(format)
+          klass = format == :xml ? XmlMapping : KeyValueMapping
+          klass.new.tap do |mapping|
+            attributes&.each do |name, attr|
+              mapping.map_element(name.to_s, to: name, render_nil: attr.render_nil?)
+            end
+          end
+        end
+
+        def apply_mappings(doc, format)
+          mappings = mappings_for(format).mappings
+          mappings.each_with_object({}) do |rule, hash|
+            attr = attributes[rule.to]
+            raise "Attribute '#{rule.to}' not found in #{self}" unless attr
+
+            value = doc[rule.name]
+            if attr.collection?
+              value = (value || []).map { |v| attr.type <= Serialize ? attr.type.new(v) : v }
+            elsif value.is_a?(Hash) && attr.type <= Serialize
+              value = attr.type.new(value)
+            end
+            hash[rule.to] = value
+          end
+        end
+
+        def apply_content_mapping(doc, mapped_attrs)
+          content_mapping = mappings_for(:xml).content_mapping
+          return unless content_mapping
+
+          content = doc.root.children.select(&:text?).map(&:text)
+          mapped_attrs[content_mapping.to] = content
+        end
+      end
+
+      def initialize(attrs = {})
+        return self unless self.class.attributes
+
+        self.class.attributes.each do |name, attr|
+          value = attrs.key?(name) ? attrs[name] : attr.default
+          value = if attr.collection?
+              (value || []).map { |v| Lutaml::Model::Type.cast(v, attr.type) }
+            else
+              Lutaml::Model::Type.cast(value, attr.type)
+            end
+          send("#{name}=", ensure_utf8(value))
+        end
+      end
+
+      # TODO: Make this work
+      # FORMATS.each do |format|
+      #   define_method("to_#{format}") do |options = {}|
+      #     adapter = Lutaml::Model::Config.send("#{format}_adapter")
+      #     representation = format == :yaml ? self : hash_representation(format, options)
+      #     adapter.new(representation).send("to_#{format}", options)
+      #   end
+      # end
+
+      def to_xml(options = {})
+        adapter = Lutaml::Model::Config.xml_adapter
+        adapter.new(self).to_xml(options)
+      end
+
+      def to_json(options = {})
+        adapter = Lutaml::Model::Config.json_adapter
+        adapter.new(hash_representation(:json, options)).to_json(options)
+      end
+
+      def to_yaml(options = {})
+        adapter = Lutaml::Model::Config.yaml_adapter
+        adapter.to_yaml(self, options)
+      end
+
+      def to_toml(options = {})
+        adapter = Lutaml::Model::Config.toml_adapter
+        adapter.new(hash_representation(:toml, options)).to_toml
+      end
+
+      # TODO: END Make this work
+
+      def hash_representation(format, options = {})
+        only = options[:only]
+        except = options[:except]
+        mappings = self.class.mappings_for(format).mappings
+
+        mappings.each_with_object({}) do |rule, hash|
+          name = rule.to
+          next if except&.include?(name) || (only && !only.include?(name))
+
+          value = send(name)
+          next if value.nil? && !rule.render_nil
+
+          hash[rule.from] = case value
+            when Array
+              value.map { |v| v.is_a?(Serialize) ? v.hash_representation(format, options) : v }
+            else
+              value.is_a?(Serialize) ? value.hash_representation(format, options) : value
+            end
+        end
+      end
+
+      private
+
+      def ensure_utf8(value)
+        case value
+        when String
+          value.encode("UTF-8", invalid: :replace, undef: :replace, replace: "")
+        when Array
+          value.map { |v| ensure_utf8(v) }
+        when Hash
+          value.transform_keys { |k| ensure_utf8(k) }.transform_values { |v| ensure_utf8(v) }
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/toml_adapter/toml_rb_adapter.rb

@@ -0,0 +1,20 @@
+# lib/lutaml/model/toml_adapter/toml_rb_adapter.rb
+require "toml-rb"
+require_relative "../toml_adapter"
+
+module Lutaml
+  module Model
+    module TomlAdapter
+      class TomlRbDocument < Document
+        def self.parse(toml)
+          data = TomlRB.parse(toml)
+          new(data)
+        end
+
+        def to_toml(*args)
+          TomlRB.dump(to_h, *args)
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/toml_adapter/tomlib_adapter.rb

@@ -0,0 +1,20 @@
+# lib/lutaml/model/toml_adapter/tomlib_adapter.rb
+require "tomlib"
+require_relative "../toml_adapter"
+
+module Lutaml
+  module Model
+    module TomlAdapter
+      class TomlibDocument < Document
+        def self.parse(toml)
+          data = Tomlib::Parser.new(toml).parsed
+          new(data)
+        end
+
+        def to_toml(*args)
+          Tomlib::Generator.new(to_h).toml_str
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/toml_adapter.rb

@@ -0,0 +1,37 @@
+# lib/lutaml/model/toml_adapter.rb
+
+module Lutaml
+  module Model
+    module TomlAdapter
+      class TomlObject
+        attr_reader :attributes
+
+        def initialize(attributes = {})
+          @attributes = attributes
+        end
+
+        def [](key)
+          @attributes[key]
+        end
+
+        def []=(key, value)
+          @attributes[key] = value
+        end
+
+        def to_h
+          @attributes
+        end
+      end
+
+      class Document < TomlObject
+        def self.parse(toml)
+          raise NotImplementedError, "Subclasses must implement `parse`."
+        end
+
+        def to_toml(*args)
+          raise NotImplementedError, "Subclasses must implement `to_toml`."
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/type/time_without_date.rb

@@ -0,0 +1,17 @@
+# lib/lutaml/model/type/time_without_date.rb
+module Lutaml
+  module Model
+    module Type
+      class TimeWithoutDate
+        def self.cast(value)
+          parsed_time = ::Time.parse(value.to_s)
+          parsed_time.strftime("%H:%M:%S")
+        end
+
+        def self.serialize(value)
+          value.strftime("%H:%M:%S")
+        end
+      end
+    end
+  end
+end