lutaml-model 0.3.30 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cca2f0b92a3e71807ed2201909e02ea5877dc1468c34c62d887d523962e63968
-  data.tar.gz: 56fe25dc8f9229d2bcabe1315c88f0f7d8fb3a3ca5f01b78b0e6494fb65ebc75
+  metadata.gz: fa60d5495804e6bfc0203ba1a237f38b89b9626d036beeb2be8ca7aebb22426f
+  data.tar.gz: 63d8d18127bee85cfaa73973f57554bc56385805dfeea1dad343c552277089d6
 SHA512:
-  metadata.gz: a6d19950a00e397146f8a8cfc8eeeb0e3c965f9fb7f5cb3bb5518cf636505f31ec72750552385b533d410eec51c6e325d0d57070fca52189ff00a48c8380c156
-  data.tar.gz: b7d55249da057ffe7f222c997ae4f628c7dd5acdeee9d7a1a5919f7f6d034ac5342b961696797029233dcd931a7db82be67f00f89a5b78463c3a7c101fbc3e4f
+  metadata.gz: 322a29941e7685a6e118d083f1b6e11ce6b8abc1cacb5508dd501f874c5ea3f2dc6f0e6719ce4895deb31c877319a3afe0e20d0820a81b8fd60d9fe59c408472
+  data.tar.gz: ce087acefc221ed41180658b8c40d4cff5c0196c208647b9d1c5d0d39799849860abf80b981fe753b30a1176ca8633ed696440beeddef5a4493c1e829340f250

data/README.adoc

@@ -569,6 +569,12 @@ The values set inside the `values:` option can be of any type, but they must
 match the type of the attribute. The values are compared using the `==` operator,
 so the type must implement the `==` method.
 
+Also, If all the elements in `values` directive are strings then `lutaml-model` add some enum convenience methods, for each of the value the following three methods are added
+
+* `value1`: will return value if set
+* `value1?`: will return true if value is set, false otherwise
+* `value1=`: will set the value of `name_of_attribute` equal to `value1` if truthy value is given, and remove it otherwise.
+
 .Using the `values` directive to define acceptable values for an attribute (basic types)
 [example]
 ====

data/lib/lutaml/model/attribute.rb

@@ -76,6 +76,10 @@ module Lutaml
         @raw
       end
 
+      def enum?
+        !enum_values.empty?
+      end
+
       def default
         value = if delegate
                   type.attributes[to].default
@@ -98,7 +102,7 @@ module Lutaml
 
       def valid_value!(value)
         return true if value.nil? && !collection?
-        return true if enum_values.empty?
+        return true unless enum?
 
         unless valid_value?(value)
           raise Lutaml::Model::InvalidValueError.new(name, value, enum_values)
@@ -208,7 +212,7 @@ module Lutaml
             serialize(v, format, options)
           end
         elsif type <= Serialize
-          type.hash_representation(value, format, options)
+          type.public_send(:"as_#{format}", value, options)
         else
           # Convert to Value instance if not already
           value = type.new(value) unless value.is_a?(Type::Value)

data/lib/lutaml/model/serialize.rb

@@ -81,16 +81,104 @@ module Lutaml
           attr = Attribute.new(name, type, options)
           attributes[name] = attr
 
-          define_method(name) do
-            instance_variable_get(:"@#{name}")
+          if attr.enum?
+            add_enum_methods_to_model(
+              model,
+              name,
+              options[:values],
+              collection: options[:collection],
+            )
+          else
+            define_method(name) do
+              instance_variable_get(:"@#{name}")
+            end
+
+            define_method(:"#{name}=") do |value|
+              value_set_for(name)
+              instance_variable_set(:"@#{name}", attr.cast_value(value))
+            end
+          end
+        end
+
+        def add_enum_methods_to_model(klass, enum_name, values, collection: false)
+          add_enum_getter_if_not_defined(klass, enum_name, collection)
+          add_enum_setter_if_not_defined(klass, enum_name, values, collection)
+
+          return unless values.all?(::String)
+
+          values.each do |value|
+            Utils.add_method_if_not_defined(klass, "#{value}?") do
+              curr_value = public_send(:"#{enum_name}")
+
+              if collection
+                curr_value.include?(value)
+              else
+                curr_value == value
+              end
+            end
+
+            Utils.add_method_if_not_defined(klass, value.to_s) do
+              public_send(:"#{value}?")
+            end
+
+            Utils.add_method_if_not_defined(klass, "#{value}=") do |val|
+              value_set_for(enum_name)
+              enum_vals = public_send(:"#{enum_name}")
+
+              enum_vals = if !!val
+                            if collection
+                              enum_vals << value
+                            else
+                              [value]
+                            end
+                          elsif collection
+                            enum_vals.delete(value)
+                            enum_vals
+                          else
+                            []
+                          end
+
+              instance_variable_set(:"@#{enum_name}", enum_vals)
+            end
+
+            Utils.add_method_if_not_defined(klass, "#{value}!") do
+              public_send(:"#{value}=", true)
+            end
           end
+        end
+
+        def add_enum_getter_if_not_defined(klass, enum_name, collection)
+          Utils.add_method_if_not_defined(klass, enum_name) do
+            i = instance_variable_get(:"@#{enum_name}") || []
 
-          define_method(:"#{name}=") do |value|
-            value_set_for(name)
-            instance_variable_set(:"@#{name}", attr.cast_value(value))
+            if !collection && i.is_a?(Array)
+              i.first
+            else
+              i.uniq
+            end
           end
         end
 
+        def add_enum_setter_if_not_defined(klass, enum_name, _values, collection)
+          Utils.add_method_if_not_defined(klass, "#{enum_name}=") do |value|
+            value = [value] unless value.is_a?(Array)
+
+            value_set_for(enum_name)
+
+            if collection
+              curr_value = public_send(:"#{enum_name}")
+
+              instance_variable_set(:"@#{enum_name}", curr_value + value)
+            else
+              instance_variable_set(:"@#{enum_name}", value)
+            end
+          end
+        end
+
+        def enums
+          attributes.select { |_, attr| attr.enum? }
+        end
+
         Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
           define_method(format) do |&block|
             klass = format == :xml ? XmlMapping : KeyValueMapping
@@ -135,7 +223,7 @@ module Lutaml
             end
           end
 
-          define_method(:"as_#{format}") do |instance|
+          define_method(:"as_#{format}") do |instance, options = {}|
             if instance.is_a?(Array)
               return instance.map { |item| public_send(:"as_#{format}", item) }
             end
@@ -147,7 +235,7 @@ module Lutaml
 
             return instance if format == :xml
 
-            hash_representation(instance, format)
+            hash_representation(instance, format, options)
           end
         end
 
@@ -166,7 +254,7 @@ module Lutaml
           mappings.each_with_object({}) do |rule, hash|
             name = rule.to
             next if except&.include?(name) || (only && !only.include?(name))
-            next if !rule.render_default? && instance.using_default?(rule.to)
+            next if !rule.custom_methods[:to] && (!rule.render_default? && instance.using_default?(rule.to))
 
             next handle_delegate(instance, rule, hash, format) if rule.delegate
 
@@ -176,15 +264,15 @@ module Lutaml
 
             value = instance.send(name)
 
-            next if value.nil? && !rule.render_nil
+            next if Utils.blank?(value) && !rule.render_nil
 
             attribute = attributes[name]
 
-            hash[rule.from] = if rule.child_mappings
-                                generate_hash_from_child_mappings(value, rule.child_mappings)
-                              else
-                                attribute.serialize(value, format, options)
-                              end
+            hash[rule.from.to_s] = if rule.child_mappings
+                                     generate_hash_from_child_mappings(value, rule.child_mappings)
+                                   else
+                                     attribute.serialize(value, format, options)
+                                   end
           end
         end
 
@@ -194,7 +282,7 @@ module Lutaml
           return if value.nil? && !rule.render_nil
 
           attribute = instance.send(rule.delegate).class.attributes[name]
-          hash[rule.from] = attribute.serialize(value, format)
+          hash[rule.from.to_s] = attribute.serialize(value, format)
         end
 
         def mappings_for(format)
@@ -379,10 +467,10 @@ module Lutaml
 
             attr = attribute_for_rule(rule)
 
-            value = if doc.key?(rule.name) || doc.key?(rule.name.to_sym)
-                      doc[rule.name] || doc[rule.name.to_sym]
+            value = if doc.key?(rule.name.to_s) || doc.key?(rule.name.to_sym)
+                      doc[rule.name.to_s] || doc[rule.name.to_sym]
                     else
-                      attr.default
+                      attr&.default
                     end
 
             if rule.custom_methods[:from]
@@ -490,7 +578,9 @@ module Lutaml
             value = []
           end
 
-          instance_variable_set(:"@#{name}", self.class.ensure_utf8(value))
+          default = using_default?(name)
+          public_send(:"#{name}=", self.class.ensure_utf8(value))
+          using_default_for(name) if default
         end
       end
 
@@ -539,6 +629,14 @@ module Lutaml
         hash[key.to_sym] || hash[key.to_s]
       end
 
+      def pretty_print_instance_variables
+        (instance_variables - %i[@using_default]).sort
+      end
+
+      def to_yaml_hash
+        self.class.as_yaml(self)
+      end
+
       Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
         define_method(:"to_#{format}") do |options = {}|
           adapter = Lutaml::Model::Config.public_send(:"#{format}_adapter")

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

@@ -34,10 +34,10 @@ module Lutaml
         #   value&.iso8601
         # end
 
-        # # YAML timestamp format (native)
-        # def to_yaml
-        #   value
-        # end
+        # YAML timestamp format (native)
+        def to_yaml
+          value&.iso8601
+        end
 
         # # TOML time format (HH:MM:SS.mmm)
         # def to_toml

data/lib/lutaml/model/utils.rb

@@ -39,7 +39,7 @@ module Lutaml
         end
 
         def blank?(value)
-          value.respond_to?(:empty?) ? value.empty? : !value
+          value.respond_to?(:empty?) ? value.empty? : value.nil?
         end
 
         def add_method_if_not_defined(klass, method_name, &block)

data/lib/lutaml/model/validation.rb

@@ -4,9 +4,13 @@ module Lutaml
       def validate
         errors = []
         self.class.attributes.each do |name, attr|
-          value = instance_variable_get(:"@#{name}")
+          value = public_send(:"#{name}")
           begin
-            attr.validate_value!(value)
+            if value.respond_to?(:validate!)
+              value.validate!
+            else
+              attr.validate_value!(value)
+            end
           rescue Lutaml::Model::InvalidValueError,
                  Lutaml::Model::CollectionCountOutOfRangeError,
                  PatternNotMatchedError => e

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.3.30"
+    VERSION = "0.4.0"
   end
 end

data/spec/lutaml/model/custom_serialization_spec.rb

@@ -138,6 +138,22 @@ RSpec.describe CustomSerialization do
     end
   end
 
+  context "with partial JSON input" do
+    it "deserializes from JSON with missing attributes" do
+      json = {
+        name: "JSON Masterpiece: Vase",
+        color: "BLUE",
+      }.to_json
+
+      ceramic = described_class.from_json(json)
+
+      expect(ceramic.full_name).to eq("Vase")
+      expect(ceramic.color).to eq("blue")
+      expect(ceramic.size).to be_nil
+      expect(ceramic.description).to be_nil
+    end
+  end
+
   context "with XML serialization" do
     it "serializes to XML with custom methods" do
       expected_xml = <<~XML

data/spec/lutaml/model/enum_spec.rb

@@ -0,0 +1,131 @@
+require "spec_helper"
+require "lutaml/model"
+
+module EnumSpec
+  class WithEnum < Lutaml::Model::Serializable
+    attribute :without_enum, :string
+    attribute :single_value, :string, values: %w[user admin super_admin]
+    attribute :multi_value, :string, values: %w[singular dual plural], collection: true
+  end
+end
+
+RSpec.describe "Enum" do
+  let(:single_value_attr) do
+    EnumSpec::WithEnum.attributes[:single_value]
+  end
+
+  let(:multi_value_attr) do
+    EnumSpec::WithEnum.attributes[:multi_value]
+  end
+
+  let(:without_enum_attr) do
+    EnumSpec::WithEnum.attributes[:without_enum]
+  end
+
+  let(:object) do
+    EnumSpec::WithEnum.new
+  end
+
+  context "when values are provided for an attribute" do
+    it "is marked as enum for single_value" do
+      expect(single_value_attr.enum?).to be(true)
+    end
+
+    it "is marked as enum for multi_value" do
+      expect(multi_value_attr.enum?).to be(true)
+    end
+
+    context "with enum convinience methods" do
+      describe "#single_value" do
+        it "returns single value" do
+          expect { object.single_value = "user" }
+            .to change(object, :single_value)
+            .from(nil)
+            .to("user")
+        end
+      end
+
+      describe "#multi_value" do
+        it "returns single value in array" do
+          expect { object.multi_value = "dual" }
+            .to change(object, :multi_value)
+            .from([])
+            .to(["dual"])
+        end
+
+        it "returns multiple value in array" do
+          expect { object.multi_value = %w[dual plural] }
+            .to change(object, :multi_value)
+            .from([])
+            .to(%w[dual plural])
+        end
+      end
+
+      EnumSpec::WithEnum.enums.each_value do |enum_attr|
+        enum_attr.enum_values.each do |value|
+          describe "##{value}=" do
+            it "sets the #{value} if true" do
+              expect { object.public_send(:"#{value}=", true) }
+                .to change { object.public_send(:"#{value}?") }
+                .from(false)
+                .to(true)
+            end
+
+            it "unsets the #{value} if false" do
+              object.public_send(:"#{value}=", true)
+
+              expect { object.public_send(:"#{value}=", false) }
+                .to change(object, "#{value}?")
+                .from(true)
+                .to(false)
+            end
+          end
+
+          describe "##{value}!" do
+            it "method #{value}? should be present" do
+              expect(object.respond_to?(:"#{value}!")).to be(true)
+            end
+
+            it "sets #{value} to true for enum" do
+              expect { object.public_send(:"#{value}!") }
+                .to change(object, "#{value}?")
+                .from(false)
+                .to(true)
+            end
+          end
+
+          describe "##{value}?" do
+            it "method #{value}? should be present" do
+              expect(object.respond_to?(:"#{value}?")).to be(true)
+            end
+
+            it "is false if role is not #{value}" do
+              expect(object.public_send(:"#{value}?")).to be(false)
+            end
+
+            it "is true if role is set to #{value}" do
+              expect { object.public_send(:"#{value}=", value) }
+                .to change(object, "#{value}?")
+                .from(false)
+                .to(true)
+            end
+          end
+
+          it "adds a method named #{value}=" do
+            expect(object.respond_to?(:"#{value}?")).to be(true)
+          end
+
+          it "adds a method named #{value}!" do
+            expect(object.respond_to?(:"#{value}!")).to be(true)
+          end
+        end
+      end
+    end
+  end
+
+  context "when values are not provided for an attribute" do
+    it "is not marked as enum" do
+      expect(without_enum_attr.enum?).to be(false)
+    end
+  end
+end

data/spec/lutaml/model/render_nil_spec.rb

@@ -68,7 +68,6 @@ RSpec.describe RenderNil do
       name: nil,
       clay_type: nil,
       glaze: nil,
-      dimensions: [],
     }.to_json
 
     expect(model.to_json).to eq(expected_json)
@@ -113,7 +112,6 @@ RSpec.describe RenderNil do
       ---
       name:
       glaze:
-      dimensions: []
     YAML
 
     generated_yaml = model.to_yaml.strip

data/spec/lutaml/model/serializable_spec.rb

@@ -131,8 +131,8 @@ RSpec.describe Lutaml::Model::Serializable do
 
       let(:expected_hash) do
         {
-          na: "John",
-          ag: "18",
+          "na" => "John",
+          "ag" => "18",
         }
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.3.30
+  version: 0.4.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-12-05 00:00:00.000000000 Z
+date: 2024-12-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -139,6 +139,7 @@ files:
 - spec/lutaml/model/custom_serialization_spec.rb
 - spec/lutaml/model/defaults_spec.rb
 - spec/lutaml/model/delegation_spec.rb
+- spec/lutaml/model/enum_spec.rb
 - spec/lutaml/model/inheritance_spec.rb
 - spec/lutaml/model/json_adapter_spec.rb
 - spec/lutaml/model/key_value_mapping_spec.rb