lutaml-model 0.6.3 → 0.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99e9857c1f8a86d0fb3566c6d9e5e11723e203e7f58bd7fcfd3c5a0cb1702b6c
-  data.tar.gz: 270002530a82256d2682a060a9616320b76f9592aeb74d17451d26d311a45508
+  metadata.gz: 07d4f2ac62702a8ac27070d4d3246e59c367937cf50b649979ecb3c525f9b60e
+  data.tar.gz: 31adf8c870b4196ea69a065559ebbb5c2f35719aba3256597d9e24474bcbfa57
 SHA512:
-  metadata.gz: f1d98496343787aad60a34ee00c7df537b9fcd4160209cdd920d8265afdc048e7a26dbc3567b30ed1a5f5eb8120684b81dc9bb04a8964fd4495be67ae339bf5e
-  data.tar.gz: d51b92c1bda980ac8f30890236329880db515eb11e20e73a647dc78cdba2de58fc869d58a5905a20681f4b946dff205968f9f1cf619bac10aa677157497f05ff
+  metadata.gz: 5ef7e89a66c74f214202d44a5b8a55d7c2aedde5129e2723f36128e8651a019cd578df6d24c375b2f760f81cd9dcd2d85ed6ae5f8972345467c13466da71c527
+  data.tar.gz: 74aff7dee7711d4c9ec88730332b91f15ba530b92946b50b1cb218157856c1c31e3c6d9bdf292b8d9ab2832586c2ee61ae29d49a8254fecbd44cc92510f6667e

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2025-02-13 10:44:38 UTC using RuboCop version 1.71.2.
+# on 2025-02-21 10:20:24 UTC using RuboCop version 1.71.2.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -27,7 +27,7 @@ Layout/IndentationWidth:
   Exclude:
     - 'lib/lutaml/model/schema/xml_compiler.rb'
 
-# Offense count: 467
+# Offense count: 466
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: Max, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, AllowedPatterns, SplitStrings.
 # URISchemes: http, https
@@ -68,7 +68,7 @@ Metrics/AbcSize:
 Metrics/BlockLength:
   Max: 46
 
-# Offense count: 48
+# Offense count: 47
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/CyclomaticComplexity:
   Exclude:
@@ -85,7 +85,7 @@ Metrics/CyclomaticComplexity:
     - 'lib/lutaml/model/xml_adapter/ox_adapter.rb'
     - 'lib/lutaml/model/xml_adapter/xml_document.rb'
 
-# Offense count: 87
+# Offense count: 86
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 Metrics/MethodLength:
   Max: 45
@@ -95,7 +95,7 @@ Metrics/MethodLength:
 Metrics/ParameterLists:
   Max: 15
 
-# Offense count: 37
+# Offense count: 36
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/PerceivedComplexity:
   Exclude:
@@ -138,7 +138,7 @@ RSpec/DescribedClass:
   Exclude:
     - 'spec/lutaml/model/xml_mapping_spec.rb'
 
-# Offense count: 152
+# Offense count: 157
 # Configuration parameters: CountAsOne.
 RSpec/ExampleLength:
   Max: 54
@@ -149,7 +149,7 @@ RSpec/LeakyConstantDeclaration:
     - 'spec/benchmarks/xml_parsing_benchmark_spec.rb'
     - 'spec/lutaml/model/xml_adapter/xml_namespace_spec.rb'
 
-# Offense count: 206
+# Offense count: 208
 RSpec/MultipleExpectations:
   Max: 14
 
@@ -163,13 +163,12 @@ RSpec/MultipleMemoizedHelpers:
 RSpec/NestedGroups:
   Max: 4
 
-# Offense count: 8
+# Offense count: 5
 RSpec/PendingWithoutReason:
   Exclude:
     - 'spec/lutaml/model/type/date_time_spec.rb'
     - 'spec/lutaml/model/type/time_spec.rb'
     - 'spec/lutaml/model/type/time_without_date_spec.rb'
-    - 'spec/lutaml/model/validation_spec.rb'
 
 # Offense count: 3
 # Configuration parameters: Include, CustomTransform, IgnoreMethods, IgnoreMetadata.

data/Gemfile

@@ -8,6 +8,7 @@ gemspec
 gem "benchmark-ips"
 gem "bigdecimal"
 gem "equivalent-xml"
+gem "liquid"
 gem "lutaml-xsd"
 gem "multi_json"
 gem "nokogiri"

data/README.adoc

@@ -347,6 +347,44 @@ same class and all their attributes are equal.
 
 == Defining attributes
 
+=== Derived Attributes
+
+A derived attribute is computed dynamically based on an instance method instead of storing a static value. It is defined using the `method:` option.
+
+Syntax:
+
+[source,ruby]
+----
+attribute :name_of_attribute, method: :instance_method_name
+----
+
+.Defining methods as attributes
+[example]
+====
+[source,ruby]
+----
+class Invoice < Lutaml::Model::Serializable
+  attribute :subtotal, :float
+  attribute :tax, :float
+  attribute :total, method: :total_value
+
+  def total_value
+    subtotal + tax
+  end
+end
+
+i = Invoice.new(subtotal: 100.0, tax: 12.0)
+i.total
+#=> 112.0
+
+puts i.to_yaml
+#=> ---
+#=> subtotal: 100.0
+#=> tax: 12.0
+#=> total: 112.0
+----
+====
+
 === Supported attribute value types
 
 ==== General types
@@ -413,9 +451,11 @@ end
 
 ==== Decimal type
 
-The Decimal type is an optional type that is disabled by default.
+WARNING: Decimal is an optional feature.
 
-NOTE: The reason why the Decimal type is disalbed by default is that the
+The Decimal type is a value type that is disabled by default.
+
+NOTE: The reason why the Decimal type is disabled by default is that the
 `BigDecimal` class became optional to the standard Ruby library from Ruby 3.4
 onwards. The `Decimal` type is only enabled when the `bigdecimal` library is
 loaded.
@@ -693,7 +733,7 @@ end
 Lutaml lets you create reusable element and attribute collections using `no_root`. These can be imported into other models using:
 
 - `import_model`: imports both attributes and mappings
-- `import_model_attributes`: imports only attributes  
+- `import_model_attributes`: imports only attributes
 - `import_model_mappings`: imports only mappings
 
 NOTE: This feature works with XML. Import order determines how elements and attributes are overwritten.
@@ -3898,7 +3938,7 @@ class Person < Lutaml::Model::Serializable
     }
   end
 
-  # Mapping-level transformation in XML format  
+  # Mapping-level transformation in XML format
   xml do
     map "full-name", to: :name, transform: {
       export: ->(value) { "Dr. #{value}" },
@@ -4098,39 +4138,39 @@ NOTE: For `NokogiriAdapter`, we can also call `to_xml` on `value.node.adapter_no
 
 # Nokogiri Adapter Node
 
-#<Lutaml::Model::XmlAdapter::NokogiriElement:0x0000000107656ed8                                                                 
-#   @attributes={},                                                                                                                
-#   @children=                                                                                                                     
+#<Lutaml::Model::XmlAdapter::NokogiriElement:0x0000000107656ed8
+#   @attributes={},
+#   @children=
 #   [#<Lutaml::Model::XmlAdapter::NokogiriElement:0x0000000107656cd0 @attributes={}, @children=[], @default_namespace=nil, @name="text", @namespace_prefix=nil, @text="\n    ">,
-#   #<Lutaml::Model::XmlAdapter::NokogiriElement:0x00000001076569b0                                                              
-#     @attributes={},                                                                                                             
-#     @children=                                                                                                                  
+#   #<Lutaml::Model::XmlAdapter::NokogiriElement:0x00000001076569b0
+#     @attributes={},
+#     @children=
 #     [#<Lutaml::Model::XmlAdapter::NokogiriElement:0x00000001076567f8 @attributes={}, @children=[], @default_namespace=nil, @name="text", @namespace_prefix=nil, @text="Metadata">],
-#     @default_namespace=nil,                                                                                                     
-#     @name="category",                                                                                                           
-#     @namespace_prefix=nil,                                                                                                      
-#     @text="Metadata">,                                                                                                          
+#     @default_namespace=nil,
+#     @name="category",
+#     @namespace_prefix=nil,
+#     @text="Metadata">,
 #   #<Lutaml::Model::XmlAdapter::NokogiriElement:0x0000000107656028 @attributes={}, @children=[], @default_namespace=nil, @name="text", @namespace_prefix=nil, @text="\n  ">],
-# @default_namespace=nil,                                                                                                        
+# @default_namespace=nil,
 # @name="metadata",
 # @namespace_prefix=nil,
 # @text="\n    Metadata\n  ">
 
 # Ox Adapter Node
 
-#<Lutaml::Model::XmlAdapter::OxElement:0x0000000107584f78                                                                                      
-# @attributes={},                                                                                                                               
-# @children=                                                                                                                                    
-#   [#<Lutaml::Model::XmlAdapter::OxElement:0x0000000107584e60                                                                                   
-#     @attributes={},                                                                                                                            
+#<Lutaml::Model::XmlAdapter::OxElement:0x0000000107584f78
+# @attributes={},
+# @children=
+#   [#<Lutaml::Model::XmlAdapter::OxElement:0x0000000107584e60
+#     @attributes={},
 #     @children=[#<Lutaml::Model::XmlAdapter::OxElement:0x0000000107584d48 @attributes={}, @children=[], @default_namespace=nil, @name="text", @namespace_prefix=nil, @text="Metadata">],
-#     @default_namespace=nil,                                                                                                                    
-#     @name="category",                                                                                                                          
-#     @namespace_prefix=nil,                                                                                                                     
-#     @text="Metadata">],                                                                                                                        
-# @default_namespace=nil,                                                                                                                       
-# @name="metadata",                                                                                                                             
-# @namespace_prefix=nil,                                                                                                                        
+#     @default_namespace=nil,
+#     @name="category",
+#     @namespace_prefix=nil,
+#     @text="Metadata">],
+# @default_namespace=nil,
+# @name="metadata",
+# @namespace_prefix=nil,
 # @text=nil>
 
 # Oga Adapter Node
@@ -4190,7 +4230,7 @@ class CustomModelParentMapper < Lutaml::Model::Serializable
     map_element :CustomModelChild,
                 with: { to: :child_to_xml, from: :child_from_xml }
   end
-  
+
   def child_to_xml(model, parent, doc)
     child_el = doc.create_element("CustomModelChild")
     street_el = doc.create_element("street")
@@ -4227,7 +4267,7 @@ end
 [source,ruby]
 ----
 > instance = CustomModelParentMapper.from_xml(xml)
-> #<CustomModelParent:0x0000000107c9ca68 @child_mapper=#<CustomModelChild:0x0000000107c95218 @city="London", @street="Oxford Street">, @first_name="John"> 
+> #<CustomModelParent:0x0000000107c9ca68 @child_mapper=#<CustomModelChild:0x0000000107c95218 @city="London", @street="Oxford Street">, @first_name="John">
 > CustomModelParentMapper.to_xml(instance)
 > #<CustomModelParent><first_name>John</first_name><CustomModelChild><street>Oxford Street</street><city>London</city></CustomModelChild></CustomModelParent>
 ----
@@ -4595,27 +4635,228 @@ klin.validate
 ====
 
 
-== Liquid Compatability
+== Liquid template access
+
+WARNING: The Liquid template feature is optional. To enable it, please
+explicitly require the `liquid` gem.
+
+The https://shopify.github.io/liquid/[Liquid template language] is an
+open-source template language developed by Shopify and written in Ruby.
 
-`to_liquid` can be used to convert a class that inherit from *Lutaml::Model::Serializable* to `LiquidDrop` to be safely used in liquid templates. The returned drop provides all the attributes defined in the class as methods.
+`Lutaml::Model::Serializable` objects can be safely accessed within Liquid
+templates through a `to_liquid` method that converts the objects into
+`Liquid::Drop` instances.
+
+* All attributes are accessible in the Liquid template by their names.
+* Nested attributes are also converted into `Liquid::Drop` objects so
+inner attributes can be accessed using the Liquid dot notation.
+
+NOTE: Every `Lutaml::Model::Serializable` class extends the `Liquefiable` module
+which generates a corresponding `Liquid::Drop` class.
+
+NOTE: Methods defined in the `Lutaml::Model::Serializable` class are not
+accessible in the Liquid template.
+
+.Using `to_liquid` to convert model instances into corresponding Liquid drop instances
 
 [example]
 ====
 [source,ruby]
 ----
-class Person < Lutaml::Model::Serializable
+class Ceramic < Lutaml::Model::Serializable
+  attribute :name, :string
+  attribute :temperature, :integer
+end
+
+ceramic = Ceramic.new({ name: "Porcelain Vase", temperature: 1200 })
+ceramic_drop = ceramic.to_liquid
+# Ceramic::CeramicDrop
+
+puts ceramic_drop.name
+# "Porcelain Vase"
+puts ceramic_drop.temperature
+# 1200
+----
+====
+
+.Accessing LutaML::Model objects within a Liquid template
+[example]
+====
+[source,ruby]
+----
+class Ceramic < Lutaml::Model::Serializable
+  attribute :name, :string
+  attribute :temperature, :integer
+end
+
+class CeramicCollection < Lutaml::Model::Serializable
+  attribute :ceramics, Ceramic, collection: true
+end
+----
+
+`sample.yml`:
+
+[source,yaml]
+----
+---
+ceramics:
+- name: Porcelain Vase
+  temperature: 1200
+- name: Earthenware Pot
+  temperature: 950
+- name: Stoneware Jug
+  temperature: 1200
+----
+
+`template.liquid`:
+
+[source,liquid]
+----
+{% for ceramic in ceramic_collection.ceramics %}
+* Name: "{{ ceramic.name }}"
+** Temperature: {{ ceramic.temperature }}
+{%- endfor %}
+----
+
+[source,ruby]
+----
+# Load the Lutaml::Model collection
+ceramic_collection = CeramicCollection.from_yaml(File.read("sample.yml"))
+
+# Load the Liquid template
+template = Liquid::Template.parse(File.read("template.liquid"))
+
+# Pass the Lutaml::Model collection to the Liquid template and render
+output = template.render("ceramic_collection" => ceramic_collection)
+puts output
+# >
+# * Name: "Porcelain Vase"
+# ** Temperature: 1200
+# * Name: "Earthenware Pot"
+# ** Temperature: 950
+# * Name: "Stoneware Jug"
+# ** Temperature: 1200
+----
+====
+
+.Accessing nested LutaML::Model objects within nested Liquid templates
+[example]
+====
+[source,ruby]
+----
+class Glaze < Lutaml::Model::Serializable
+  attribute :color, :string
+  attribute :opacity, :string
+end
+
+class CeramicWork < Lutaml::Model::Serializable
   attribute :name, :string
-  attribute :age, integer
+  attribute :glaze, Glaze
+end
+
+class CeramicCollection < Lutaml::Model::Serializable
+  attribute :ceramics, Ceramic, collection: true
 end
 
-person = Person.new({ name: "John", age: 22 })
-person_drop = person.to_liquid
-# Person::PersonDrop
+ceramic_work = CeramicWork.new({
+  name: "Celadon Bowl",
+  glaze: Glaze.new({
+    color: "Jade Green",
+    opacity: "Translucent"
+  })
+})
+ceramic_work_drop = ceramic_work.to_liquid
+# CeramicWork::CeramicWorkDrop
+
+puts ceramic_work_drop.name
+# "Celadon Bowl"
+puts ceramic_work_drop.glaze.color
+# "Jade Green"
+puts ceramic_work_drop.glaze.opacity
+# "Translucent"
+----
+
+`ceramics.yml`:
+
+[source,yaml]
+----
+---
+ceramics:
+- name: Celadon Bowl
+  glaze:
+    color: Jade Green
+    opacity: Translucent
+- name: Earthenware Pot
+  glaze:
+    color: Rust Red
+    opacity: Opaque
+- name: Stoneware Jug
+  glaze:
+    color: Cobalt Blue
+    opacity: Transparent
+----
+
+
+`templates/_ceramics.liquid`:
+
+[source,liquid]
+----
+{% for ceramic in ceramic_collection.ceramics %}
+{% render 'ceramic' ceramic: ceramic %}
+{%- endfor %}
+----
+
+NOTE: `render` is a Liquid tag that renders a partial template, by default
+Liquid uses the pattern `_%s.liquid` to find the partial template. Here
+`ceramic` refers to the file at `templates/_ceramic.liquid`.
+
+`templates/_ceramic.liquid`:
+
+[source,liquid]
+----
+* Name: "{{ ceramic.name }}"
+** Temperature: {{ ceramic.temperature }}
+{%- if ceramic.glaze %}
+** Glaze (color): {{ ceramic.glaze.color }}
+** Glaze (opacity): {{ ceramic.glaze.opacity }}
+{%- endif %}
+----
+
+[source,ruby]
+----
+require 'liquid'
+
+# Create a Liquid template object that supports dynamic loading
+template = Liquid::Template.new
+
+# Link the Liquid template object to a "local file system" (directory)
+file_system = Liquid::LocalFileSystem.new('templates/')
+template.registers[:file_system] = file_system
+
+# Load the partial template, this is necessary.
+# This will also allow Liquid to load any inner partials from the file system
+# dynamically (see `file_system.pattern` to see what it loads)
+template.parse(file_system.read_template_file('ceramics'))
+
+# Read the lutaml-model collection
+ceramic_collection = CeramicCollection.from_yaml(File.read("ceramics.yml"))
 
-puts person_drop.name
-# "John"
-puts person_drop.age
-# 22
+# Render the template with the collection
+output = template.render("ceramic_collection" => ceramic_collection)
+puts output
+# >
+# * Name: "Celadon Bowl"
+# ** Temperature: 1200
+# ** Glaze (color): Jade Green
+# ** Glaze (finish): Translucent
+# * Name: "Earthenware Pot"
+# ** Temperature: 950
+# ** Glaze (color): Rust Red
+# ** Glaze (finish): Opaque
+# * Name: "Stoneware Jug"
+# ** Temperature: 1200
+# ** Glaze (color): Cobalt Blue
+# ** Glaze (finish): Transparent
 ----
 ====
 

data/lib/lutaml/model/attribute.rb

@@ -13,23 +13,20 @@ module Lutaml
         transform
         choice
         sequence
+        method_name
       ].freeze
 
       def initialize(name, type, options = {})
         @name = name
-
-        validate_type!(type)
-        @type = cast_type!(type)
-
-        validate_options!(options)
         @options = options
 
-        @raw = !!options[:raw]
+        validate_presence!(type, options[:method_name])
+        process_type!(type) if type
+        process_options!
+      end
 
-        if collection?
-          validate_collection_range
-          @options[:default] = -> { [] } unless options[:default]
-        end
+      def derived?
+        type.nil?
       end
 
       def delegate
@@ -40,6 +37,10 @@ module Lutaml
         @options[:transform] || {}
       end
 
+      def method_name
+        @options[:method_name]
+      end
+
       def cast_type!(type)
         case type
         when Symbol
@@ -231,20 +232,11 @@ module Lutaml
 
       def serialize(value, format, options = {})
         return if value.nil?
+        return value if derived?
+        return serialize_array(value, format, options) if value.is_a?(Array)
+        return serialize_model(value, format, options) if type <= Serialize
 
-        if value.is_a?(Array)
-          value.map do |v|
-            serialize(v, format, options)
-          end
-        elsif type <= Serialize
-          if Utils.present?(value)
-            type.public_send(:"as_#{format}", value, options)
-          end
-        else
-          # Convert to Value instance if not already
-          value = type.new(value) unless value.is_a?(Type::Value)
-          value.send(:"to_#{format}")
-        end
+        serialize_value(value, format)
       end
 
       def cast(value, format, options = {})
@@ -269,6 +261,41 @@ module Lutaml
           (format == :xml && value.is_a?(Lutaml::Model::XmlAdapter::XmlElement))
       end
 
+      def serialize_array(value, format, options)
+        value.map { |v| serialize(v, format, options) }
+      end
+
+      def serialize_model(value, format, options)
+        type.as(format, value, options) if Utils.present?(value)
+      end
+
+      def serialize_value(value, format)
+        value = type.new(value) unless value.is_a?(Type::Value)
+        value.send(:"to_#{format}")
+      end
+
+      def validate_presence!(type, method_name)
+        return if type || method_name
+
+        raise ArgumentError, "method or type must be set for an attribute"
+      end
+
+      def process_type!(type)
+        validate_type!(type)
+        @type = cast_type!(type)
+      end
+
+      def process_options!
+        validate_options!(@options)
+        @raw = !!@options[:raw]
+        set_default_for_collection if collection?
+      end
+
+      def set_default_for_collection
+        validate_collection_range
+        @options[:default] ||= -> { [] }
+      end
+
       def validate_options!(options)
         if (invalid_opts = options.keys - ALLOWED_OPTIONS).any?
           raise StandardError,
@@ -277,7 +304,8 @@ module Lutaml
 
         if options.key?(:pattern) && type != Lutaml::Model::Type::String
           raise StandardError,
-                "Invalid option `pattern` given for `#{name}`, `pattern` is only allowed for :string type"
+                "Invalid option `pattern` given for `#{name}`, " \
+                "`pattern` is only allowed for :string type"
         end
 
         true

data/lib/lutaml/model/error/liquid_not_enabled_error.rb

@@ -0,0 +1,9 @@
+module Lutaml
+  module Model
+    class LiquidNotEnabledError < Error
+      def to_s
+        "Liquid functionality is not available by default; please install and require `liquid` gem to use this functionality"
+      end
+    end
+  end
+end

data/lib/lutaml/model/error.rb

@@ -6,6 +6,7 @@ module Lutaml
 end
 
 require_relative "error/invalid_value_error"
+require_relative "error/liquid_not_enabled_error"
 require_relative "error/incorrect_mapping_argument_error"
 require_relative "error/pattern_not_matched_error"
 require_relative "error/unknown_adapter_type_error"

data/lib/lutaml/model/liquefiable.rb

@@ -1,5 +1,3 @@
-require "liquid"
-
 module Lutaml
   module Model
     module Liquefiable
@@ -9,6 +7,7 @@ module Lutaml
 
       module ClassMethods
         def register_liquid_drop_class
+          validate_liquid!
           if drop_class
             raise "#{drop_class_name} Already exists!"
           end
@@ -38,6 +37,7 @@ module Lutaml
 
         def register_drop_method(method_name)
           register_liquid_drop_class unless drop_class
+          return if drop_class.method_defined?(method_name)
 
           drop_class.define_method(method_name) do
             value = @object.public_send(method_name)
@@ -49,9 +49,22 @@ module Lutaml
             end
           end
         end
+
+        def validate_liquid!
+          return if Object.const_defined?(:Liquid)
+
+          raise Lutaml::Model::LiquidNotEnabledError
+        end
       end
 
       def to_liquid
+        self.class.validate_liquid!
+
+        if is_a?(Lutaml::Model::Serializable)
+          self.class.attributes.each_key do |attr_name|
+            self.class.register_drop_method(attr_name)
+          end
+        end
         self.class.drop_class.new(self)
       end
     end

data/lib/lutaml/model/serialize.rb

@@ -96,6 +96,11 @@ module Lutaml
 
         # Define an attribute for the model
         def attribute(name, type, options = {})
+          if type.is_a?(Hash)
+            options[:method_name] = type[:method]
+            type = nil
+          end
+
           attr = Attribute.new(name, type, options)
           attributes[name] = attr
 
@@ -106,6 +111,10 @@ module Lutaml
               options[:values],
               collection: options[:collection],
             )
+          elsif attr.derived? && name != attr.method_name
+            define_method(name) do
+              public_send(attr.method_name)
+            end
           else
             define_method(name) do
               instance_variable_get(:"@#{name}")
@@ -117,8 +126,6 @@ module Lutaml
             end
           end
 
-          register_drop_method(name)
-
           attr
         end
 
@@ -285,6 +292,10 @@ module Lutaml
           end
         end
 
+        def as(format, instance, options = {})
+          public_send(:"as_#{format}", instance, options)
+        end
+
         def key_value(&block)
           Lutaml::Model::Config::KEY_VALUE_FORMATS.each do |format|
             mappings[format] ||= KeyValueMapping.new
@@ -486,8 +497,7 @@ module Lutaml
           return instance unless doc
 
           if options[:default_namespace].nil?
-            options[:default_namespace] =
-              mappings_for(:xml)&.namespace_uri
+            options[:default_namespace] = mappings_for(:xml)&.namespace_uri
           end
           mappings = options[:mappings] || mappings_for(:xml).mappings
 
@@ -519,6 +529,7 @@ module Lutaml
             raise "Attribute '#{rule.to}' not found in #{self}" unless valid_rule?(rule)
 
             attr = attribute_for_rule(rule)
+            next if attr&.derived?
 
             value = if rule.raw_mapping?
                       doc.root.inner_xml
@@ -705,6 +716,8 @@ module Lutaml
         end
 
         self.class.attributes.each do |name, attr|
+          next if attr.derived?
+
           value = if attrs.key?(name) || attrs.key?(name.to_s)
                     attr_value(attrs, name, attr)
                   else

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.6.3"
+    VERSION = "0.6.5"
   end
 end

data/spec/fixtures/liquid_templates/_ceramic.liquid

@@ -0,0 +1,6 @@
+* Name: "{{ ceramic.name }}"
+** Temperature: {{ ceramic.temperature }}
+{%- if ceramic.glaze %}
+** Glaze (color): {{ ceramic.glaze.color }}
+** Glaze (opacity): {{ ceramic.glaze.opacity }}
+{%- endif %}

data/spec/fixtures/liquid_templates/_ceramics.liquid

@@ -0,0 +1,3 @@
+{% for ceramic in ceramic_collection.ceramics %}
+{% render 'ceramic' ceramic: ceramic %}
+{%- endfor %}

data/spec/fixtures/liquid_templates/_ceramics_in_one.liquid

@@ -0,0 +1,4 @@
+{% for ceramic in ceramic_collection.ceramics %}
+* Name: "{{ ceramic.name }}"
+** Temperature: {{ ceramic.temperature }}
+{%- endfor %}

data/spec/lutaml/model/attribute_spec.rb

@@ -7,6 +7,10 @@ RSpec.describe Lutaml::Model::Attribute do
     described_class.new("name", :string)
   end
 
+  let(:method_attr) do
+    described_class.new("name", nil, method_name: nil)
+  end
+
   let(:test_record_class) do
     Class.new(Lutaml::Model::Serializable) do
       attribute :age, :integer
@@ -33,6 +37,13 @@ RSpec.describe Lutaml::Model::Attribute do
       .to("avatar.png")
   end
 
+  it "raises error if both type and method_name are not given" do
+    expect { method_attr }.to raise_error(
+      ArgumentError,
+      "method or type must be set for an attribute",
+    )
+  end
+
   describe "#validate_options!" do
     let(:validate_options) { name_attr.method(:validate_options!) }
 
@@ -103,7 +114,25 @@ RSpec.describe Lutaml::Model::Attribute do
     end
   end
 
-  describe "#default?" do
+  describe "#derived?" do
+    context "when type is set" do
+      let(:attribute) { described_class.new("name", :string) }
+
+      it "returns false" do
+        expect(attribute.derived?).to be(false)
+      end
+    end
+
+    context "when type is nil and method_name is set" do
+      let(:attribute) { described_class.new("name", nil, method_name: :tmp) }
+
+      it "returns true" do
+        expect(attribute.derived?).to be(true)
+      end
+    end
+  end
+
+  describe "#default" do
     context "when default is not set" do
       let(:attribute) { described_class.new("name", :string) }
 

data/spec/lutaml/model/liquefiable_spec.rb

@@ -1,4 +1,5 @@
 require "spec_helper"
+require "liquid"
 require_relative "../../fixtures/address"
 
 class LiquefiableClass
@@ -16,6 +17,23 @@ class LiquefiableClass
   end
 end
 
+module LiquefiableSpec
+  class Glaze < Lutaml::Model::Serializable
+    attribute :color, :string
+    attribute :opacity, :string
+  end
+
+  class Ceramic < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :temperature, :integer
+    attribute :glaze, Glaze
+  end
+
+  class CeramicCollection < Lutaml::Model::Serializable
+    attribute :ceramics, Ceramic, collection: true
+  end
+end
+
 RSpec.describe Lutaml::Model::Liquefiable do
   before do
     stub_const("DummyModel", Class.new(LiquefiableClass))
@@ -26,14 +44,27 @@ RSpec.describe Lutaml::Model::Liquefiable do
   describe ".register_liquid_drop_class" do
     context "when drop class does not exist" do
       it "creates a new drop class" do
-        expect { dummy.class.register_liquid_drop_class }.to change {
-          dummy.class.const_defined?(:DummyModelDrop)
-        }
+        expect do
+          dummy.class.register_liquid_drop_class
+        end.to change {
+                 dummy.class.const_defined?(:DummyModelDrop)
+               }
           .from(false)
           .to(true)
       end
     end
 
+    context "when 'liquid' is not available" do
+      before { allow(Object).to receive(:const_defined?).with(:Liquid).and_return(false) }
+
+      it "raises an error" do
+        expect { dummy.class.register_liquid_drop_class }.to raise_error(
+          Lutaml::Model::LiquidNotEnabledError,
+          "Liquid functionality is not available by default; please install and require `liquid` gem to use this functionality",
+        )
+      end
+    end
+
     context "when drop class already exists" do
       it "raises an error" do
         dummy.class.register_liquid_drop_class
@@ -69,26 +100,41 @@ RSpec.describe Lutaml::Model::Liquefiable do
     end
 
     it "defines a method on the drop class" do
-      expect { dummy.class.register_drop_method(:display_name) }.to change {
-        dummy.to_liquid.respond_to?(:display_name)
-      }
+      expect do
+        dummy.class.register_drop_method(:display_name)
+      end.to change {
+               dummy.to_liquid.respond_to?(:display_name)
+             }
         .from(false)
         .to(true)
     end
   end
 
   describe ".to_liquid" do
-    before do
-      dummy.class.register_liquid_drop_class
-      dummy.class.register_drop_method(:display_name)
-    end
+    context "when liquid is not enabled" do
+      before { allow(Object).to receive(:const_defined?).with(:Liquid).and_return(false) }
 
-    it "returns an instance of the drop class" do
-      expect(dummy.to_liquid).to be_a(dummy.class.drop_class)
+      it "raises an error" do
+        expect { dummy.to_liquid }.to raise_error(
+          Lutaml::Model::LiquidNotEnabledError,
+          "Liquid functionality is not available by default; please install and require `liquid` gem to use this functionality",
+        )
+      end
     end
 
-    it "allows access to registered methods via the drop class" do
-      expect(dummy.to_liquid.display_name).to eq("TestName (42)")
+    context "when liquid is enabled" do
+      before do
+        dummy.class.register_liquid_drop_class
+        dummy.class.register_drop_method(:display_name)
+      end
+
+      it "returns an instance of the drop class" do
+        expect(dummy.to_liquid).to be_a(dummy.class.drop_class)
+      end
+
+      it "allows access to registered methods via the drop class" do
+        expect(dummy.to_liquid.display_name).to eq("TestName (42)")
+      end
     end
   end
 
@@ -118,4 +164,96 @@ RSpec.describe Lutaml::Model::Liquefiable do
       end
     end
   end
+
+  describe "working with liquid templates" do
+    let(:liquid_template_dir) do
+      File.join(File.dirname(__FILE__), "../../fixtures/liquid_templates")
+    end
+
+    describe "rendering simple models with liquid templates" do
+      let :yaml do
+        <<~YAML
+          ---
+          ceramics:
+          - name: Porcelain Vase
+            temperature: 1200
+          - name: Earthenware Pot
+            temperature: 950
+          - name: Stoneware Jug
+            temperature: 1200
+        YAML
+      end
+      let :template_path do
+        File.join(liquid_template_dir, "_ceramics_in_one.liquid")
+      end
+
+      it "renders" do
+        template = Liquid::Template.parse(File.read(template_path))
+        ceramic_collection = LiquefiableSpec::CeramicCollection.from_yaml(yaml)
+        output = template.render("ceramic_collection" => ceramic_collection)
+
+        expected_output = <<~OUTPUT
+          * Name: "Porcelain Vase"
+          ** Temperature: 1200
+          * Name: "Earthenware Pot"
+          ** Temperature: 950
+          * Name: "Stoneware Jug"
+          ** Temperature: 1200
+        OUTPUT
+
+        expect(output.strip).to eq(expected_output.strip)
+      end
+    end
+
+    describe "rendering nested models with liquid templates from file system" do
+      let :yaml do
+        <<~YAML
+          ---
+          ceramics:
+          - name: Celadon Bowl
+            temperature: 1200
+            glaze:
+              color: Jade Green
+              opacity: Translucent
+          - name: Earthenware Pot
+            temperature: 950
+            glaze:
+              color: Rust Red
+              opacity: Opaque
+          - name: Stoneware Jug
+            temperature: 1200
+            glaze:
+              color: Cobalt Blue
+              opacity: Transparent
+        YAML
+      end
+
+      it "renders" do
+        template = Liquid::Template.new
+        file_system = Liquid::LocalFileSystem.new(liquid_template_dir)
+        template.registers[:file_system] = file_system
+        template.parse(file_system.read_template_file("ceramics"))
+
+        ceramic_collection = LiquefiableSpec::CeramicCollection.from_yaml(yaml)
+        output = template.render("ceramic_collection" => ceramic_collection)
+        # puts output
+
+        expected_output = <<~OUTPUT
+          * Name: "Celadon Bowl"
+          ** Temperature: 1200
+          ** Glaze (color): Jade Green
+          ** Glaze (opacity): Translucent
+          * Name: "Earthenware Pot"
+          ** Temperature: 950
+          ** Glaze (color): Rust Red
+          ** Glaze (opacity): Opaque
+          * Name: "Stoneware Jug"
+          ** Temperature: 1200
+          ** Glaze (color): Cobalt Blue
+          ** Glaze (opacity): Transparent
+        OUTPUT
+        expect(output.strip).to eq(expected_output.strip)
+      end
+    end
+  end
 end

data/spec/lutaml/model/serializable_spec.rb

@@ -112,13 +112,42 @@ RSpec.describe Lutaml::Model::Serializable do
   end
 
   describe ".attribute" do
-    subject(:mapper) { described_class.new }
+    before do
+      stub_const("TestClass", Class.new(described_class))
+    end
+
+    context "when method_name is given" do
+      let(:attribute) do
+        TestClass.attribute("test", method: :foobar)
+      end
 
-    it "adds the attribute and getter setter for that attribute" do
-      expect { described_class.attribute("foo", Lutaml::Model::Type::String) }
-        .to change { described_class.attributes.keys }.from([]).to(["foo"])
-        .and change { mapper.respond_to?(:foo) }.from(false).to(true)
-        .and change { mapper.respond_to?(:foo=) }.from(false).to(true)
+      it "adds derived attribute" do
+        expect { attribute }
+          .to change { TestClass.attributes["test"] }
+          .from(nil)
+          .to(Lutaml::Model::Attribute)
+      end
+
+      it "returns true for derived?" do
+        expect(attribute.derived?).to be(true)
+      end
+    end
+
+    context "when type is given" do
+      let(:attribute) do
+        TestClass.attribute("foo", Lutaml::Model::Type::String)
+      end
+
+      it "adds the attribute and getter setter for that attribute" do
+        expect { attribute }
+          .to change { TestClass.attributes.keys }.from([]).to(["foo"])
+          .and change { TestClass.new.respond_to?(:foo) }.from(false).to(true)
+          .and change { TestClass.new.respond_to?(:foo=) }.from(false).to(true)
+      end
+
+      it "returns false for derived?" do
+        expect(attribute.derived?).to be(false)
+      end
     end
   end
 

data/spec/lutaml/model/xml/derived_attributes_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module DerivedAttributesSpecs
+  class Ceramic < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :value, :float
+  end
+
+  class CeramicCollection < Lutaml::Model::Serializable
+    attribute :items, Ceramic, collection: true
+    attribute :total_value, method: :total_value
+
+    # Derived property
+    def total_value
+      items.sum(&:value)
+    end
+
+    xml do
+      root "ceramic-collection"
+      map_element "total-value", to: :total_value
+      map_element "item", to: :items
+    end
+  end
+end
+
+RSpec.describe "XML::DerivedAttributes" do
+  let(:xml) do
+    <<~XML.strip
+      <ceramic-collection>
+        <total-value>2500.0</total-value>
+        <item>
+          <name>Ancient Vase</name>
+          <value>1500.0</value>
+        </item>
+        <item>
+          <name>Historic Bowl</name>
+          <value>1000.0</value>
+        </item>
+      </ceramic-collection>
+    XML
+  end
+
+  let(:ancient_vase) do
+    DerivedAttributesSpecs::Ceramic.new(name: "Ancient Vase", value: 1500.0)
+  end
+
+  let(:historic_bowl) do
+    DerivedAttributesSpecs::Ceramic.new(name: "Historic Bowl", value: 1000.0)
+  end
+
+  let(:ceramic_collection) do
+    DerivedAttributesSpecs::CeramicCollection.new(
+      items: [ancient_vase, historic_bowl],
+    )
+  end
+
+  describe ".from_xml" do
+    let(:parsed) do
+      DerivedAttributesSpecs::CeramicCollection.from_xml(xml)
+    end
+
+    it "correctly parses items" do
+      expect(parsed).to eq(ceramic_collection)
+    end
+
+    it "correctly calculates total-value" do
+      expect(parsed.total_value).to eq(2500)
+    end
+  end
+
+  describe ".to_xml" do
+    it "convert to correct xml" do
+      expect(ceramic_collection.to_xml).to eq(xml)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "liquid"
 require "rspec/matchers"
 require "equivalent-xml"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.6.3
+  version: 0.6.5
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-02-14 00:00:00.000000000 Z
+date: 2025-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -111,6 +111,7 @@ files:
 - lib/lutaml/model/error/incorrect_sequence_error.rb
 - lib/lutaml/model/error/invalid_choice_range_error.rb
 - lib/lutaml/model/error/invalid_value_error.rb
+- lib/lutaml/model/error/liquid_not_enabled_error.rb
 - lib/lutaml/model/error/multiple_mappings_error.rb
 - lib/lutaml/model/error/no_root_mapping_error.rb
 - lib/lutaml/model/error/no_root_namespace_error.rb
@@ -192,6 +193,9 @@ files:
 - spec/ceramic_spec.rb
 - spec/fixtures/address.rb
 - spec/fixtures/ceramic.rb
+- spec/fixtures/liquid_templates/_ceramic.liquid
+- spec/fixtures/liquid_templates/_ceramics.liquid
+- spec/fixtures/liquid_templates/_ceramics_in_one.liquid
 - spec/fixtures/person.rb
 - spec/fixtures/sample_model.rb
 - spec/fixtures/vase.rb
@@ -253,6 +257,7 @@ files:
 - spec/lutaml/model/utils_spec.rb
 - spec/lutaml/model/validation_spec.rb
 - spec/lutaml/model/with_child_mapping_spec.rb
+- spec/lutaml/model/xml/derived_attributes_spec.rb
 - spec/lutaml/model/xml_adapter/nokogiri_adapter_spec.rb
 - spec/lutaml/model/xml_adapter/oga_adapter_spec.rb
 - spec/lutaml/model/xml_adapter/ox_adapter_spec.rb