lutaml-model 0.1.0

data/lib/lutaml/model/type.rb

@@ -0,0 +1,114 @@
+# lib/lutaml/model/type.rb
+require "date"
+require "bigdecimal"
+require "securerandom"
+require "uri"
+require "ipaddr"
+require "json"
+
+module Lutaml
+  module Model
+    module Type
+      class Boolean; end
+
+      %w(String
+         Integer
+         Float
+         Date
+         Time
+         Boolean
+         Decimal
+         Hash
+         UUID
+         Symbol
+         BigInteger
+         Binary
+         URL
+         Email
+         IPAddress
+         JSON
+         Enum).each do |t|
+        class_eval <<~HEREDOC
+                      class #{t}
+                        def self.cast(value)
+                         Type.cast(value, #{t})
+                       end
+                     end
+
+                   HEREDOC
+      end
+
+      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
+
+      class DateTime
+        def self.cast(value)
+          ::DateTime.parse(value.to_s).new_offset(0).iso8601
+        end
+      end
+
+      def self.cast(value, type)
+        case type
+        when String
+          value.to_s
+        when Integer
+          value.to_i
+        when Float
+          value.to_f
+        when Date
+          begin
+            ::Date.parse(value.to_s)
+          rescue ArgumentError
+            nil
+          end
+        when DateTime
+          DateTime.cast(value)
+        when Time
+          ::Time.parse(value.to_s)
+        when TimeWithoutDate
+          TimeWithoutDate.cast(value)
+        when Boolean
+          to_boolean(value)
+        when Decimal
+          BigDecimal(value.to_s)
+        when Hash
+          Hash(value)
+        when UUID
+          value =~ /\A[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\z/ ? value : SecureRandom.uuid
+        when Symbol
+          value.to_sym
+        when BigInteger
+          value.to_i
+        when Binary
+          value.force_encoding("BINARY")
+        when URL
+          URI.parse(value.to_s)
+        when Email
+          value.to_s
+        when IPAddress
+          IPAddr.new(value.to_s)
+        when JSON
+          ::JSON.parse(value)
+        when Enum
+          value
+        else
+          value
+        end
+      end
+
+      def self.to_boolean(value)
+        return true if value == true || value.to_s =~ (/^(true|t|yes|y|1)$/i)
+        return false if value == false || value.nil? || value.to_s =~ (/^(false|f|no|n|0)$/i)
+        raise ArgumentError.new("invalid value for Boolean: \"#{value}\"")
+      end
+    end
+  end
+end

data/lib/lutaml/model/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    VERSION = "0.1.0"
+  end
+end

data/lib/lutaml/model/xml_adapter/nokogiri_adapter.rb

@@ -0,0 +1,117 @@
+# lib/lutaml/model/xml_adapter/nokogiri_adapter.rb
+require "nokogiri"
+require_relative "../xml_adapter"
+
+module Lutaml
+  module Model
+    module XmlAdapter
+      class NokogiriDocument < Document
+        def self.parse(xml)
+          parsed = Nokogiri::XML(xml)
+          root = NokogiriElement.new(parsed.root)
+          new(root)
+        end
+
+        def initialize(root)
+          @root = root
+        end
+
+        def to_h
+          { @root.name => parse_element(@root) }
+        end
+
+        def to_xml(options = {})
+          builder = Nokogiri::XML::Builder.new do |xml|
+            build_element(xml, @root, options)
+          end
+
+          xml_data = builder.to_xml(options[:pretty] ? { indent: 2 } : {})
+          options[:declaration] ? declaration(options) + xml_data : xml_data
+        end
+
+        private
+
+        def build_element(xml, element, options = {})
+          xml_mapping = element.class.mappings_for(:xml)
+          return xml unless xml_mapping
+
+          attributes = build_attributes(element, xml_mapping)
+
+          xml.send(xml_mapping.root_element, attributes) do
+            xml_mapping.elements.each do |element_rule|
+              attribute_def = element.class.attributes[element_rule.to]
+              value = element.send(element_rule.to)
+
+              if attribute_def&.type <= Lutaml::Model::Serialize
+                handle_nested_elements(xml, element_rule, value)
+              else
+                xml.send(element_rule.name) { xml.text value }
+              end
+            end
+            xml.text element.text unless xml_mapping.elements.any?
+          end
+        end
+
+        def build_attributes(element, xml_mapping)
+          xml_mapping.attributes.each_with_object(namespace_attributes(xml_mapping)) do |mapping_rule, hash|
+            full_name = if mapping_rule.namespace
+                "#{mapping_rule.prefix ? "#{mapping_rule.prefix}:" : ""}#{mapping_rule.name}"
+              else
+                mapping_rule.name
+              end
+            hash[full_name] = element.send(mapping_rule.to)
+          end
+        end
+
+        def namespace_attributes(xml_mapping)
+          return {} unless xml_mapping.namespace_uri
+
+          if xml_mapping.namespace_prefix
+            { "xmlns:#{xml_mapping.namespace_prefix}" => xml_mapping.namespace_uri }
+          else
+            { "xmlns" => xml_mapping.namespace_uri }
+          end
+        end
+
+        def handle_nested_elements(xml, element_rule, value)
+          case value
+          when Array
+            value.each { |val| build_element(xml, val) }
+          else
+            build_element(xml, value)
+          end
+        end
+
+        def parse_element(element)
+          result = element.children.each_with_object({}) do |child, hash|
+            next if child.text?
+
+            hash[child.name] ||= []
+            hash[child.name] << parse_element(child)
+          end
+          result["_text"] = element.text if element.text?
+          result
+        end
+      end
+
+      class NokogiriElement < Element
+        def initialize(node)
+          attributes = node.attributes.transform_values do |attr|
+            Attribute.new(attr.name, attr.value, namespace: attr.namespace&.href, namespace_prefix: attr.namespace&.prefix)
+          end
+          super(node.name, attributes, parse_children(node), node.text, namespace: node.namespace&.href, namespace_prefix: node.namespace&.prefix)
+        end
+
+        def text?
+          false
+        end
+
+        private
+
+        def parse_children(node)
+          node.children.select(&:element?).map { |child| NokogiriElement.new(child) }
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/xml_adapter/oga_adapter.rb

@@ -0,0 +1,75 @@
+# lib/lutaml/model/xml_adapter/oga_adapter.rb
+require "oga"
+require_relative "../xml_adapter"
+
+module Lutaml
+  module Model
+    module XmlAdapter
+      class OgaDocument < Document
+        def self.parse(xml)
+          parsed = Oga.parse_xml(xml)
+          root = OgaElement.new(parsed)
+          new(root)
+        end
+
+        def initialize(root)
+          @root = root
+        end
+
+        def to_h
+          { @root.name => parse_element(@root) }
+        end
+
+        def to_xml(options = {})
+          builder = Oga::XML::Builder.new
+          build_element(builder, @root, options)
+          xml_data = builder.to_xml
+          options[:declaration] ? declaration(options) + xml_data : xml_data
+        end
+
+        private
+
+        def build_element(builder, element, options = {})
+          attributes = build_attributes(element.attributes)
+          builder.element(element.name, attributes) do
+            element.children.each do |child|
+              build_element(builder, child, options)
+            end
+            builder.text(element.text) if element.text
+          end
+        end
+
+        def build_attributes(attributes)
+          attributes.each_with_object({}) do |(name, attr), hash|
+            hash[name] = attr.value
+          end
+        end
+
+        def parse_element(element)
+          result = { "_text" => element.text }
+          element.children.each do |child|
+            next if child.is_a?(Oga::XML::Text)
+            result[child.name] ||= []
+            result[child.name] << parse_element(child)
+          end
+          result
+        end
+      end
+
+      class OgaElement < Element
+        def initialize(node)
+          attributes = node.attributes.each_with_object({}) do |attr, hash|
+            hash[attr.name] = Attribute.new(attr.name, attr.value)
+          end
+          super(node.name, attributes, parse_children(node), node.text)
+        end
+
+        private
+
+        def parse_children(node)
+          node.children.select { |child| child.is_a?(Oga::XML::Element) }.map { |child| OgaElement.new(child) }
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/xml_adapter/ox_adapter.rb

@@ -0,0 +1,75 @@
+# lib/lutaml/model/xml_adapter/ox_adapter.rb
+require "ox"
+require_relative "../xml_adapter"
+
+module Lutaml
+  module Model
+    module XmlAdapter
+      class OxDocument < Document
+        def self.parse(xml)
+          parsed = Ox.parse(xml)
+          root = OxElement.new(parsed)
+          new(root)
+        end
+
+        def initialize(root)
+          @root = root
+        end
+
+        def to_h
+          { @root.name => parse_element(@root) }
+        end
+
+        def to_xml(options = {})
+          builder = Ox::Builder.new
+          build_element(builder, @root, options)
+          xml_data = Ox.dump(builder)
+          options[:declaration] ? declaration(options) + xml_data : xml_data
+        end
+
+        private
+
+        def build_element(builder, element, options = {})
+          attributes = build_attributes(element.attributes)
+          builder.element(element.name, attributes) do
+            element.children.each do |child|
+              build_element(builder, child, options)
+            end
+            builder.text(element.text) if element.text
+          end
+        end
+
+        def build_attributes(attributes)
+          attributes.each_with_object({}) do |(name, attr), hash|
+            hash[name] = attr.value
+          end
+        end
+
+        def parse_element(element)
+          result = { "_text" => element.text }
+          element.nodes.each do |child|
+            next if child.is_a?(Ox::Raw) || child.is_a?(Ox::Comment)
+            result[child.name] ||= []
+            result[child.name] << parse_element(child)
+          end
+          result
+        end
+      end
+
+      class OxElement < Element
+        def initialize(node)
+          attributes = node.attributes.each_with_object({}) do |(name, value), hash|
+            hash[name.to_s] = Attribute.new(name.to_s, value)
+          end
+          super(node.name.to_s, attributes, parse_children(node), node.text)
+        end
+
+        private
+
+        def parse_children(node)
+          node.nodes.select { |child| child.is_a?(Ox::Element) }.map { |child| OxElement.new(child) }
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/xml_adapter.rb

@@ -0,0 +1,60 @@
+# lib/lutaml/model/xml_adapter.rb
+
+module Lutaml
+  module Model
+    module XmlAdapter
+      class Document
+        attr_reader :root
+
+        def initialize(root)
+          @root = root
+        end
+
+        def self.parse(xml)
+          raise NotImplementedError, "Subclasses must implement `parse`."
+        end
+
+        def children
+          @root.children
+        end
+
+        def declaration(options)
+          version = options[:declaration].is_a?(String) ? options[:declaration] : "1.0"
+          encoding = options[:encoding].is_a?(String) ? options[:encoding] : (options[:encoding] ? "UTF-8" : nil)
+          declaration = "<?xml version=\"#{version}\""
+          declaration += " encoding=\"#{encoding}\"" if encoding
+          declaration += "?>\n"
+          declaration
+        end
+      end
+
+      class Element
+        attr_reader :name, :attributes, :children, :text, :namespace, :namespace_prefix
+
+        def initialize(name, attributes = {}, children = [], text = nil, namespace: nil, namespace_prefix: nil)
+          @name = name
+          @attributes = attributes.map { |k, v| Attribute.new(k, v) }
+          @children = children
+          @text = text
+          @namespace = namespace
+          @namespace_prefix = namespace_prefix
+        end
+
+        def document
+          Document.new(self)
+        end
+      end
+
+      class Attribute
+        attr_reader :name, :value, :namespace, :namespace_prefix
+
+        def initialize(name, value, namespace: nil, namespace_prefix: nil)
+          @name = name
+          @value = value
+          @namespace = namespace
+          @namespace_prefix = namespace_prefix
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/xml_mapping.rb

@@ -0,0 +1,65 @@
+# lib/lutaml/model/xml_mapping.rb
+require_relative "xml_mapping_rule"
+
+module Lutaml
+  module Model
+    class XmlMapping
+      attr_reader :root_element, :namespace_uri, :namespace_prefix
+
+      def initialize
+        @elements = []
+        @attributes = []
+        @content_mapping = nil
+      end
+
+      def root(name)
+        @root_element = name
+      end
+
+      def namespace(uri, prefix = nil)
+        @namespace_uri = uri
+        @namespace_prefix = prefix
+      end
+
+      def map_element(name, to:, render_nil: false, with: {}, delegate: nil, namespace: nil, prefix: nil)
+        @elements << XmlMappingRule.new(name, to: to, render_nil: render_nil, with: with, delegate: delegate, namespace: namespace, prefix: prefix)
+      end
+
+      def map_attribute(name, to:, render_nil: false, with: {}, delegate: nil, namespace: nil, prefix: nil)
+        @attributes << XmlMappingRule.new(name, to: to, render_nil: render_nil, with: with, delegate: delegate, namespace: namespace, prefix: prefix)
+      end
+
+      def map_content(to:, render_nil: false, with: {}, delegate: nil)
+        @content_mapping = XmlMappingRule.new(nil, to: to, render_nil: render_nil, with: with, delegate: delegate)
+      end
+
+      def elements
+        @elements
+      end
+
+      def attributes
+        @attributes
+      end
+
+      def content_mapping
+        @content_mapping
+      end
+
+      def mappings
+        elements + attributes + [content_mapping].compact
+      end
+
+      def element(name)
+        elements.detect do |rule|
+          name == rule.to
+        end
+      end
+
+      def attribute(name)
+        attributes.detect do |rule|
+          name == rule.to
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/xml_mapping_rule.rb

@@ -0,0 +1,16 @@
+# lib/lutaml/model/xml_mapping_rule.rb
+require_relative "mapping_rule"
+
+module Lutaml
+  module Model
+    class XmlMappingRule < MappingRule
+      attr_reader :namespace, :prefix
+
+      def initialize(name, to:, render_nil: false, with: {}, delegate: nil, namespace: nil, prefix: nil)
+        super(name, to: to, render_nil: render_nil, with: with, delegate: delegate)
+        @namespace = namespace
+        @prefix = prefix
+      end
+    end
+  end
+end

data/lib/lutaml/model/yaml_adapter.rb

@@ -0,0 +1,24 @@
+# lib/lutaml/model/yaml_adapter.rb
+require "yaml"
+
+module Lutaml
+  module Model
+    module YamlAdapter
+      module Standard
+        def self.to_yaml(model, *args)
+          YAML.dump(model.hash_representation(:yaml), *args)
+        end
+
+        def self.from_yaml(yaml, klass)
+          data = parse(yaml)
+          mapped_attrs = klass.send(:apply_mappings, data, :yaml)
+          klass.new(mapped_attrs)
+        end
+
+        def self.parse(yaml)
+          YAML.safe_load(yaml, permitted_classes: [Date, Time, DateTime, Symbol, BigDecimal, Hash, Array])
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "model/version"
+
+# lib/lutaml/model.rb
+require "nokogiri"
+require "json"
+require "yaml"
+require_relative "model/type"
+require_relative "model/serializable"
+require_relative "model/json_adapter"
+require_relative "model/yaml_adapter"
+require_relative "model/xml_adapter"
+require_relative "model/toml_adapter"
+
+module Lutaml
+  module Model
+    class BaseModel < Serializable
+    end
+  end
+end

data/lutaml-model.gemspec

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "lib/lutaml/model/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "lutaml-model"
+  spec.version = Lutaml::Model::VERSION
+  spec.authors = ["Ribose Inc."]
+  spec.email = ["open.source@ribose.com"]
+
+  spec.summary = "LutaML creating data models in Ruby"
+  spec.description = <<~DESCRIPTION
+    LutaML creating data models in Ruby
+  DESCRIPTION
+
+  spec.homepage = "https://github.com/lutaml/lutaml-model"
+  spec.license = "BSD-2-Clause"
+
+  spec.bindir = "bin"
+  spec.require_paths = ["lib"]
+  spec.files = `git ls-files`.split("\n")
+  spec.test_files = `git ls-files -- {spec}/*`.split("\n")
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{^(test|spec|features)/})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # spec.add_runtime_dependency "expressir"
+  # spec.add_runtime_dependency "metanorma-cli"
+  # spec.add_runtime_dependency "shale"
+  # spec.add_runtime_dependency "thor", ">= 0.20"
+  spec.add_development_dependency "multi_json"
+  spec.add_development_dependency "tomlib"
+  spec.add_development_dependency "toml-rb"
+  spec.add_development_dependency "oga"
+  spec.add_development_dependency "ox"
+  spec.add_development_dependency "nokogiri"
+  spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "rubocop-performance"
+  spec.add_development_dependency "rubocop-rails"
+  spec.add_development_dependency "equivalent-xml"
+end

data/sig/lutaml/model.rbs

@@ -0,0 +1,6 @@
+module Lutaml
+  module Model
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end