lutaml-model 0.3.23 → 0.3.25

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.3.23"
+    VERSION = "0.3.25"
   end
 end

data/lib/lutaml/model/xml_adapter/builder/nokogiri.rb

@@ -39,6 +39,8 @@ module Lutaml
           )
             add_namespace_prefix(prefix)
 
+            element_name = "#{element_name}_" if respond_to?(element_name)
+
             if block_given?
               public_send(element_name, attributes) do
                 xml.parent.namespace = nil if prefix.nil? && !prefix_unset
@@ -54,7 +56,8 @@ module Lutaml
               element = element.xml.parent
             end
 
-            element << text.to_s
+            text_node = ::Nokogiri::XML::Text.new(text.to_s, element)
+            element.add_child(text_node)
           end
 
           def add_namespace_prefix(prefix)
@@ -64,7 +67,7 @@ module Lutaml
           end
 
           def method_missing(method_name, *args, &block)
-            if block
+            if block_given?
               xml.public_send(method_name, *args, &block)
             else
               xml.public_send(method_name, *args)

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

@@ -14,6 +14,7 @@ module Lutaml
 
         def to_xml(options = {})
           builder = Builder::Ox.build
+          builder.xml.instruct(:xml, encoding: options[:encoding] || "UTF-8", version: options[:version])
 
           if @root.is_a?(Lutaml::Model::XmlAdapter::OxElement)
             @root.build_xml(builder)
@@ -26,7 +27,7 @@ module Lutaml
           end
 
           xml_data = builder.xml.to_s
-          options[:declaration] ? declaration(options) + xml_data : xml_data
+          options[:declaration] ? xml_data : xml_data.sub(/\A<\?xml[^>]*\?>\n?/, "")
         end
 
         private

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

@@ -84,8 +84,6 @@ module Lutaml
 
             value = if child.text?
                       child.text
-                    elsif attr&.raw?
-                      child.children.map(&:to_xml).join
                     else
                       parse_element(child, attr&.type || klass, format)
                     end

data/lutaml-model.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |spec|
   # 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)/})
+      f.match(%r{^(test|features)/})
     end
   end
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }

data/spec/address_spec.rb

@@ -0,0 +1,170 @@
+require "spec_helper"
+require_relative "fixtures/address"
+require_relative "fixtures/person"
+
+RSpec.describe Address do
+  let(:person1) do
+    {
+      first_name: "Tom",
+      last_name: "Warren",
+      age: 40,
+      height: 5.8,
+      birthdate: Date.new(1980, 2, 15),
+      last_login: "1980-02-15T10:00:00Z",
+      wakeup_time: "07:30:00",
+      active: true,
+    }
+  end
+  let(:person2) do
+    {
+      first_name: "Jack",
+      last_name: "Warren",
+      age: 35,
+      height: 5.9,
+      birthdate: Date.new(1985, 5, 20),
+      last_login: "1985-05-20T09:00:00Z",
+      wakeup_time: "06:45:00",
+      active: false,
+    }
+  end
+  let(:attributes) do
+    {
+      country: "USA",
+      post_code: "01001",
+      person: [person1, person2],
+    }
+  end
+  let(:address) { described_class.new(attributes) }
+
+  it "serializes to JSON with a collection of persons" do
+    expected_json = {
+      country: "USA",
+      postCode: "01001",
+      person: [
+        {
+          firstName: "Tom",
+          lastName: "Warren",
+          age: 40,
+          height: 5.8,
+          birthdate: "1980-02-15",
+          lastLogin: "1980-02-15T10:00:00+00:00",
+          wakeupTime: "07:30:00",
+          active: true,
+        },
+        {
+          firstName: "Jack",
+          lastName: "Warren",
+          age: 35,
+          height: 5.9,
+          birthdate: "1985-05-20",
+          lastLogin: "1985-05-20T09:00:00+00:00",
+          wakeupTime: "06:45:00",
+          active: false,
+        },
+      ],
+    }.to_json
+
+    expect(address.to_json).to eq(expected_json)
+  end
+
+  it "deserializes from JSON with a collection of persons" do
+    json = {
+      country: "USA",
+      postCode: "01001",
+      person: [
+        {
+          firstName: "Tom",
+          lastName: "Warren",
+          age: 40,
+          height: 5.8,
+          birthdate: "1980-02-15",
+          lastLogin: "1980-02-15T10:00:00Z",
+          wakeupTime: "07:30:00",
+          active: true,
+        },
+        {
+          firstName: "Jack",
+          lastName: "Warren",
+          age: 35,
+          height: 5.9,
+          birthdate: "1985-05-20",
+          lastLogin: "1985-05-20T09:00:00Z",
+          wakeupTime: "06:45:00",
+          active: false,
+        },
+      ],
+    }.to_json
+
+    address_from_json = described_class.from_json(json)
+    expect(address_from_json.country).to eq("USA")
+    expect(address_from_json.post_code).to eq("01001")
+    expect(address_from_json.person.first.first_name).to eq("Tom")
+    expect(address_from_json.person.last.first_name).to eq("Jack")
+  end
+
+  it "serializes to XML with a collection of persons" do
+    expected_xml = <<~XML
+      <Address xmlns:p="http://example.com/person" xmlns:nsp1="http://example.com/nsp1">
+        <Country>USA</Country>
+        <PostCode>01001</PostCode>
+        <p:Person>
+          <nsp1:FirstName>Tom</nsp1:FirstName>
+          <nsp1:LastName>Warren</nsp1:LastName>
+          <p:Age>40</p:Age>
+          <p:Height>5.8</p:Height>
+          <p:Birthdate>1980-02-15</p:Birthdate>
+          <p:LastLogin>1980-02-15T10:00:00+00:00</p:LastLogin>
+          <p:WakeupTime>07:30:00</p:WakeupTime>
+          <p:Active>true</p:Active>
+        </p:Person>
+        <p:Person>
+          <nsp1:FirstName>Jack</nsp1:FirstName>
+          <nsp1:LastName>Warren</nsp1:LastName>
+          <p:Age>35</p:Age>
+          <p:Height>5.9</p:Height>
+          <p:Birthdate>1985-05-20</p:Birthdate>
+          <p:LastLogin>1985-05-20T09:00:00+00:00</p:LastLogin>
+          <p:WakeupTime>06:45:00</p:WakeupTime>
+          <p:Active>false</p:Active>
+        </p:Person>
+      </Address>
+    XML
+
+    expect(address.to_xml).to be_equivalent_to(expected_xml)
+  end
+
+  it "deserializes from XML with a collection of persons" do
+    xml = <<~XML
+      <Address xmlns:p="http://example.com/person" xmlns:nsp1="http://example.com/nsp1">
+        <Country>USA</Country>
+        <PostCode>01001</PostCode>
+        <Person>
+          <nsp1:FirstName>Tom</nsp1:FirstName>
+          <nsp1:LastName>Warren</nsp1:LastName>
+          <Age>40</Age>
+          <Height>5.8</Height>
+          <Birthdate>1980-02-15</Birthdate>
+          <LastLogin>1980-02-15T10:00:00Z</LastLogin>
+          <WakeupTime>07:30:00</WakeupTime>
+          <Active>true</Active>
+        </Person>
+        <Person>
+          <nsp1:FirstName>Jack</nsp1:FirstName>
+          <nsp1:LastName>Warren</nsp1:LastName>
+          <Age>35</Age>
+          <Height>5.9</Height>
+          <Birthdate>1985-05-20</Birthdate>
+          <LastLogin>1985-05-20T09:00:00Z</LastLogin>
+          <WakeupTime>06:45:00</WakeupTime>
+          <Active>false</Active>
+        </Person>
+      </Address>
+    XML
+
+    address_from_xml = described_class.from_xml(xml)
+    expect(address_from_xml.country).to eq("USA")
+    expect(address_from_xml.post_code).to eq("01001")
+    expect(address_from_xml.person.first.first_name).to eq("Tom")
+    expect(address_from_xml.person.last.first_name).to eq("Jack")
+  end
+end

data/spec/fixtures/address.rb

@@ -0,0 +1,33 @@
+require "lutaml/model"
+require_relative "person"
+
+class Address < Lutaml::Model::Serializable
+  attribute :country, Lutaml::Model::Type::String
+  attribute :post_code, Lutaml::Model::Type::String
+  attribute :person, Person, collection: true
+
+  json do
+    map "country", to: :country
+    map "postCode", to: :post_code
+    map "person", to: :person
+  end
+
+  xml do
+    root "Address"
+    map_element "Country", to: :country
+    map_element "PostCode", to: :post_code
+    map_element "Person", to: :person
+  end
+
+  yaml do
+    map "country", to: :country
+    map "postCode", to: :post_code
+    map "person", to: :person
+  end
+
+  toml do
+    map "country", to: :country
+    map "post_code", to: :post_code
+    map "person", to: :person
+  end
+end

data/spec/fixtures/person.rb

@@ -0,0 +1,73 @@
+require "lutaml/model"
+
+class Person < Lutaml::Model::Serializable
+  attribute :first_name, Lutaml::Model::Type::String
+  attribute :last_name, Lutaml::Model::Type::String
+  attribute :age, Lutaml::Model::Type::Integer
+  attribute :height, Lutaml::Model::Type::Float
+  attribute :birthdate, Lutaml::Model::Type::Date
+  attribute :last_login, Lutaml::Model::Type::DateTime
+  attribute :wakeup_time, Lutaml::Model::Type::TimeWithoutDate
+  attribute :active, Lutaml::Model::Type::Boolean
+
+  xml do
+    root "Person"
+    namespace "http://example.com/person", "p"
+
+    map_element "FirstName",
+                to: :first_name,
+                namespace: "http://example.com/nsp1",
+                prefix: "nsp1"
+    map_element "LastName",
+                to: :last_name,
+                namespace: "http://example.com/nsp1",
+                prefix: "nsp1"
+    map_element "Age", to: :age
+    map_element "Height", to: :height
+    map_element "Birthdate", to: :birthdate
+    map_element "LastLogin", to: :last_login
+    map_element "WakeupTime", to: :wakeup_time
+    map_element "Active", to: :active
+  end
+
+  json do
+    map "firstName", to: :first_name
+    map "lastName", to: :last_name
+    map "age", to: :age
+    map "height", to: :height
+    map "birthdate", to: :birthdate
+    map "lastLogin", to: :last_login
+    map "wakeupTime", to: :wakeup_time
+    map "active", to: :active
+  end
+
+  yaml do
+    map "firstName", to: :first_name
+    map "lastName", with: { to: :yaml_from_last_name, from: :yaml_to_last_name }
+    map "age", to: :age
+    map "height", to: :height
+    map "birthdate", to: :birthdate
+    map "lastLogin", to: :last_login
+    map "wakeupTime", to: :wakeup_time
+    map "active", to: :active
+  end
+
+  toml do
+    map "first_name", to: :first_name
+    map "last_name", to: :last_name
+    map "age", to: :age
+    map "height", to: :height
+    map "birthdate", to: :birthdate
+    map "last_login", to: :last_login
+    map "wakeup_time", to: :wakeup_time
+    map "active", to: :active
+  end
+
+  def yaml_from_last_name(model, doc)
+    doc["lastName"] = model.last_name
+  end
+
+  def yaml_to_last_name(model, value)
+    model.last_name = value
+  end
+end

data/spec/fixtures/sample_model.rb

@@ -0,0 +1,40 @@
+require "lutaml/model"
+
+class SampleModelTag < Lutaml::Model::Serializable
+  attribute :text, :string, default: -> { "" }
+
+  xml do
+    root "Tag"
+    map_content to: :text
+  end
+end
+
+class SampleModel < Lutaml::Model::Serializable
+  attribute :name, :string, default: -> { "Anonymous" }
+  attribute :age, :integer, default: -> { 18 }
+  attribute :balance, :decimal, default: -> { BigDecimal("0.0") }
+  attribute :tags, SampleModelTag, collection: true
+  attribute :preferences, :hash, default: -> { { notifications: true } }
+  attribute :status, :string, default: -> { "active" }
+  attribute :large_number, :integer, default: -> { 0 }
+  attribute :email, :string, default: -> { "example@example.com" }
+  attribute :role, :string, values: %w[user admin guest], default: -> { "user" }
+
+  xml do
+    root "SampleModel"
+    map_element "Name", to: :name
+    map_element "Age", to: :age
+    map_element "Balance", to: :balance
+    map_element "Tags", to: :tags
+    map_element "Preferences", to: :preferences
+    map_element "Status", to: :status
+    map_element "LargeNumber", to: :large_number
+    map_element "Email", to: :email
+    map_element "Role", to: :role
+  end
+
+  yaml do
+    map "name", to: :name
+    map "age", to: :age
+  end
+end

data/spec/fixtures/vase.rb

@@ -0,0 +1,38 @@
+require "lutaml/model"
+
+class Vase < Lutaml::Model::Serializable
+  attribute :height, Lutaml::Model::Type::Float
+  attribute :diameter, Lutaml::Model::Type::Float
+  attribute :material, Lutaml::Model::Type::String
+  attribute :manufacturer, Lutaml::Model::Type::String
+
+  json do
+    map "height", to: :height
+    map "diameter", to: :diameter
+    map "material", to: :material
+    map "manufacturer", to: :manufacturer
+  end
+
+  yaml do
+    map "height", to: :height
+    map "diameter", to: :diameter
+    map "material", to: :material
+    map "manufacturer", to: :manufacturer
+  end
+
+  toml do
+    map "height", to: :height
+    map "diameter", to: :diameter
+    map "material", to: :material
+    map "manufacturer", to: :manufacturer
+  end
+
+  xml do
+    root "vase"
+    namespace "https://example.com/vase/1.0"
+    map_element "height", to: :height
+    map_element "diameter", to: :diameter
+    map_element "material", to: :material
+    map_attribute "manufacturer", to: :manufacturer
+  end
+end

data/spec/fixtures/xml/special_char.xml

@@ -0,0 +1,13 @@
+<article>
+  <back>
+    <ref-list>
+      <ref>
+        <element-citation>
+          <source>Continuity of care: report of a scoping exercise for
+            the national co-ordinating centre for NHS Service Delivery and
+            Organisation R&#x0026;D (NCCSDO), Summer 2000</source>
+        </element-citation>
+      </ref>
+    </ref-list>
+  </back>
+</article>

data/spec/lutaml/model/attribute_spec.rb

@@ -0,0 +1,112 @@
+require "spec_helper"
+require "lutaml/model"
+require "pathname"
+
+RSpec.describe Lutaml::Model::Attribute do
+  subject(:name_attr) do
+    described_class.new("name", :string)
+  end
+
+  let(:test_record_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :age, :integer
+      attribute :image, :string
+    end
+  end
+
+  before do
+    stub_const("TestRecord", test_record_class)
+  end
+
+  it "cast to integer when assigning age" do
+    obj = TestRecord.new
+
+    expect { obj.age = "20" }.to change { obj.age }.from(nil).to(20)
+  end
+
+  it "cast to string when assigning image file" do
+    obj = TestRecord.new
+
+    expect { obj.image = Pathname.new("avatar.png") }
+      .to change { obj.image }
+      .from(nil)
+      .to("avatar.png")
+  end
+
+  describe "#validate_type!" do
+    let(:validate_type) { name_attr.method(:validate_type!) }
+
+    it "return true if type is a class" do
+      expect(validate_type.call(TestRecord)).to be(true)
+    end
+
+    it "return true if type is a valid symbol" do
+      expect(validate_type.call(:string)).to be(true)
+    end
+
+    it "return true if type is a valid string" do
+      expect(validate_type.call("String")).to be(true)
+    end
+
+    it "raise exception if type is invalid symbol" do
+      expect do
+        validate_type.call(:foo)
+      end.to raise_error(StandardError, "Unknown Lutaml::Model::Type: foo")
+    end
+
+    it "raise exception if type is invalid string" do
+      expect do
+        validate_type.call("foo")
+      end.to raise_error(StandardError, "Unknown Lutaml::Model::Type: foo")
+    end
+  end
+
+  describe "#cast_type!" do
+    it "cast :string to Lutaml::Model::Type::String" do
+      expect(name_attr.cast_type!(:string)).to eq(Lutaml::Model::Type::String)
+    end
+
+    it "cast :integer to Lutaml::Model::Type::Integer" do
+      expect(name_attr.cast_type!(:integer)).to eq(Lutaml::Model::Type::Integer)
+    end
+
+    it "raises ArgumentError on unknown type" do
+      expect { name_attr.cast_type!(:foobar) }
+        .to raise_error(ArgumentError, "Unknown Lutaml::Model::Type: foobar")
+    end
+  end
+
+  describe "#default?" do
+    context "when default is not set" do
+      let(:attribute) { described_class.new("name", :string) }
+
+      it { expect(attribute.default).to be_nil }
+    end
+
+    context "when default is set as a proc" do
+      it "returns the value" do
+        attribute = described_class.new("name", :string, default: -> { "John" })
+        expect(attribute.default).to eq("John")
+      end
+
+      it "returns the value casted to correct type" do
+        file = Pathname.new("avatar.png")
+        attribute = described_class.new("image", :string, default: -> { file })
+
+        expect(attribute.default).to eq("avatar.png")
+      end
+    end
+
+    context "when default is set as value" do
+      it "returns the value" do
+        attribute = described_class.new("name", :string, default: "John Doe")
+        expect(attribute.default).to eq("John Doe")
+      end
+
+      it "returns the value casted to correct type" do
+        attribute = described_class.new("age", :integer, default: "24")
+        expect(attribute.default).to eq(24)
+      end
+    end
+  end
+end