mbt-gen 0.0.6 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d73853b99bf4d38c5c621765537531713eca02dcf357d2b2c004514c66fa78f7
-  data.tar.gz: 99b8a8490a1a33662b5a044cb466fdb95875dfe2e1ba8f031065d6a58dc170c7
+  metadata.gz: 763d26c653134a8a5432753091e286e1df8aecf8c603a5eba5bc6980ed5c3e6f
+  data.tar.gz: e5e86c5368af05ff682fbd2f7bf7fed6a9e7909d7d92523728956ee3fee71946
 SHA512:
-  metadata.gz: 11787320c7d53d3f0d14686f0d1224daee62522e6298175a02c3c1ad11f30f8ed564526fa773599125b2ea9c5cffd647298ac50449495661ef5d5f3d078ba5ce
-  data.tar.gz: 45aef9d1c6c316aa145c1cc50a88319ae50390d676df64bb5abf7b86a5baf0612f19b27c347e44efeba1bf5c1f15c3f76e1e5fae0779f84df4145b13561ee92b
+  metadata.gz: 5c32f100cae06aa9f7e97d7e1b214f27a9d0747948feafddd01530392f45df0a9966e4f6ad3ef5be9a719b87f9e0bd91f966523415231b539026503aa1659064
+  data.tar.gz: 485bd1dfe0f01f7e553087603c90e73c582b7dd29de72cd79032f63f1b35df32af15c66369c540507ae4ed8427244159710076221dcf033696e7ce8732191ff7

data/lib/mbt-gen.rb

@@ -596,6 +596,15 @@ def translate_validation_rule_to_SMTLIB(rule, context_struct, prefix, config, op
                     field = resolve_field_path($1, context_struct, prefix)
                     filled_var_for_field(field)
                   end
+                  .gsub(/LIST_VALUE\[[^\]]*,[^\]]*\]/) do |m|
+                    unless m =~ /LIST_VALUE\[([^\]]*),([^\]]*)\]/ then
+                      raise RuntimeError.new("could not parse LIST_VALUE_FIRST_ELEMENT[...]: #{m.inspect} in validation rule #{rule_name}")
+                    end
+                    xpath = $1
+                    index = Integer($2)
+                    l = resolve_field_path(xpath, context_struct, prefix)
+                    value_var_for_list(l, index)
+                  end
                   .gsub(/VALUE\[[^\]]*\]/) do |m|
                     unless m =~ /VALUE\[([^\]]*)\]/ then
                       raise RuntimeError.new("could not parse VALUE[...]: #{m.inspect} in validation rule #{rule_name}")
@@ -630,15 +639,6 @@ def translate_validation_rule_to_SMTLIB(rule, context_struct, prefix, config, op
                     end
                     "(or #{terms.join(" ")})"
                   end
-                  .gsub(/LIST_VALUE\[[^\]]*,[^\]]*\]/) do |m|
-                    unless m =~ /LIST_VALUE\[([^\]]*),([^\]]*)\]/ then
-                      raise RuntimeError.new("could not parse LIST_VALUE_FIRST_ELEMENT[...]: #{m.inspect} in validation rule #{rule_name}")
-                    end
-                    xpath = $1
-                    index = Integer($2)
-                    l = resolve_field_path(xpath, context_struct, prefix)
-                    value_var_for_list(l, index)
-                  end
                   .gsub(/LIST_VALUE_FIRST_ELEMENT\[[^\]]*\]/) do |m|  # DEPRECATED! Please use LIST_VALUE[...] instead.
                     unless m =~ /LIST_VALUE_FIRST_ELEMENT\[([^\]]*)\]/ then
                       raise RuntimeError.new("could not parse LIST_VALUE_FIRST_ELEMENT[...]: #{m.inspect} in validation rule #{rule_name}")
@@ -768,9 +768,9 @@ def parse_field_value(fielddef, value)
   when :int
     return Integer(value)
   when :string
-    return value
+    return solver_value_to_string(value)
   when :enum
-    return value
+    return solver_value_to_string(value)
   when :date
     return Date.parse(value)
   when :timestamp
@@ -778,6 +778,10 @@ def parse_field_value(fielddef, value)
   end
 end
 
+def solver_value_to_ruby_value(fielddef, solver_value)
+  parse_field_value(fielddef, solver_value)
+end
+
 def solver_value_to_string(solver_value)
   if solver_value =~ /\"(.*)\"/ then
     return $1
@@ -786,6 +790,15 @@ def solver_value_to_string(solver_value)
   end
 end
 
+def format_solver_value(fielddef, solver_value)
+  if fielddef[:formatter] then
+    fvalue_ruby = solver_value_to_ruby_value(fielddef, solver_value)
+    fvalue_str = fielddef[:formatter].call(fvalue_ruby)
+  else
+    fvalue_str = solver_value_to_string(solver_value)
+  end
+end
+
 def build_document_from_model(progress, struct, model)
   doc = Nokogiri::XML(XML_TEMPLATE)
   add_model_struct_to_doc(progress, struct, doc, model)
@@ -806,7 +819,8 @@ def add_model_struct_to_doc(progress, struct, doc, model, prefix = nil)
         raise RuntimeError.new("xpath '#{xpath}' not contained in model.")
       end
       if model_value[:filled] == true || model_value[:filled] == "true" then
-        doc.add_child("<#{key}>#{solver_value_to_string(model_value[:value])}</#{key}>")
+        fvalue_str = format_solver_value(value, model_value[:value])
+        doc.add_child("<#{key}>#{fvalue_str}</#{key}>")
       end
     elsif value[:type] == :list then
       node = doc.add_child("<#{key}></#{key}>")
@@ -1171,17 +1185,43 @@ def list_validation_rules(message)
   rules.each { |r| puts "  #{r}" }
 end
   
-def value_of_type(value, type)
-  if type == :string or type == :enum then
+def default_parser_for_type(value_str, datatype)
+  if datatype == :string or datatype == :enum then
+    value_str
+  elsif datatype == :int then
+    Integer(value_str)
+  elsif datatype == :date then
+    Date.parse(value_str)
+  elsif datatype == :timestamp then
+    Time.new(value_str)
+  else
+    raise RuntimeError.new("encountered unknown :datatype #{datatype.inspect}")
+  end
+end
+
+def value_of_type_to_solver(value, datatype)
+  if datatype == :string || datatype == :enum then
     "\"#{value}\""
-  elsif type == :int then
+  elsif datatype == :int then
     value.to_s
-  elsif type == :date then
-    (Date.parse(value) -  Time.at(0).to_date).to_i.to_s
-  elsif type == :timestamp then
-    (Time.new(value) - Time.at(0)).to_i.to_s
+  elsif datatype == :date then
+    (value -  Time.at(0).to_date).to_i.to_s
+  elsif datatype == :timestamp then
+    (value - Time.at(0)).to_i.to_s
   else
-    raise RuntimeError.new("encountered unknown :datatype #{type.inspect}")
+    raise RuntimeError.new("encountered value of unknown type: #{datatype.inspect}")
+  end
+end
+
+def value_of_type(value, type)  
+  value_of_type_to_solver(default_parser_for_type(value, type), type)
+end
+
+def parse_field_value_to_ruby(fielddef, fieldvalue)
+  if fielddef[:parser] then
+    fielddef[:parser].call(fieldvalue)
+  else
+    default_parser_for_type(fieldvalue, fielddef[:datatype])
   end
 end
 
@@ -1716,6 +1756,16 @@ def validate_model(message, prefix=nil)
         unless value[:datatype] then
           raise RuntimeError.new("Model Problem: encountered field without a :datatype (key=#{key.inspect}, value=#{value.inspect})")
         end
+        if value[:parser] then
+          unless value[:formatter] then
+            raise RuntimeError.new("Model Problem: encountered field has a :parser, but no :formatter (key=#{key.inspect}, value=#{value.inspect})")
+          end
+        end
+        if value[:formatter] then
+          unless value[:parser] then
+            raise RuntimeError.new("Model Problem: encountered field has a :formatter, but no :parser (key=#{key.inspect}, value=#{value.inspect})")
+          end
+        end
         if value[:datatype] == :enum then
           unless value[:values] then
             raise RuntimeError.new("Model Problem: encountered enum field without a :values (key=#{key.inspect}, value=#{value.inspect})")
@@ -1723,7 +1773,13 @@ def validate_model(message, prefix=nil)
         end
       elsif value[:type] == :list then
         unless value[:datatype] then
-          raise RuntimeError.new("Model Problem: encountered list without a :datatype (key=#{key.inspect}, value=#{value.inspect})")
+          raise RuntimeError.new("Model Problem: encountered list without :datatype property (key=#{key.inspect}, value=#{value.inspect})")
+        end
+        unless value[:model_maxLength] then
+          raise RuntimeError.new("Model Problem: encountered list without :model_maxLength property (key=#{key.inspect}, value=#{value.inspect})")
+        end
+        unless value[:xpath_element] then
+          raise RuntimeError.new("Model Problem: encountered list without :xpath_element property (key=#{key.inspect}, value=#{value.inspect})")
         end
         if value[:datatype] == :enum then
           unless value[:values] then
@@ -1797,11 +1853,11 @@ end
 def validate_schema_against_doc_struct(struct, doc, prefix = nil)
   struct.each do |key, value|
     next if key == :additional_smtlib || key == :validation_rules || key == :predicates || key == :parent_link || key == :struct_xpath_prefix
-      if prefix then
-        xpath = "#{prefix}/#{key}"
-      else
-        xpath = key
-      end
+    if prefix then
+      xpath = "#{prefix}/#{key}"
+    else
+      xpath = key
+    end
     if value[:type] == :structure then
       node = doc.at_xpath(key.to_s)
       if node then
@@ -1832,6 +1888,26 @@ def validate_schema_against_doc_struct(struct, doc, prefix = nil)
           end
         end
       end
+    elsif value[:type] == :objlist then
+      if value[:optional] == false then
+        unless doc.at_xpath(key.to_s) then
+          raise FatalError.new("ERROR: schema validation failed: non-optional objlist #{xpath} not found in doc.")
+        end
+      end
+      list = doc.at_xpath(key.to_s)
+      if list then
+        index = 0
+        list.children.to_a.each_with_index do |c|
+          next unless c.is_a?(Nokogiri::XML::Element)
+          index += 1
+          unless c.name == value[:xpath_element] then
+            raise FatalError.new("ERROR: schema validation failed: encountered element #{c.name} in objlist #{xpath}, which should only contain #{value[:xpath_element]} elements.")
+          end
+          if c then
+            validate_schema_against_doc_struct(value[:ref], c, "#{xpath}/#{value[:xpath_element]}[#{index}]" )
+          end
+        end
+      end
     else
       raise RuntimeError.new("Model error: encountered element #{xpath} of unknown type: #{value[:type]}.")
     end
@@ -1843,10 +1919,10 @@ def translate_doc_to_SMTLIB(progress, solver, struct, doc, hash = {})
   config = hash[:config]
 
   solver.to_solver(progress, "; --- Document: ---")
-  translate_struct_in_doc_to_SMTLIB(progress, solver, struct, doc, nil, hash)
+  translate_struct_in_doc_to_SMTLIB(progress, solver, struct, doc, nil, nil, hash)
 end
 
-def translate_struct_in_doc_to_SMTLIB(progress, solver, struct, doc, prefix, hash = {})
+def translate_struct_in_doc_to_SMTLIB(progress, solver, struct, doc, prefix, var_prefix, hash = {})
   options = hash[:options]
   config = hash[:config]
 
@@ -1857,6 +1933,11 @@ def translate_struct_in_doc_to_SMTLIB(progress, solver, struct, doc, prefix, has
     else
       xpath = key.to_s
     end
+    if var_prefix then
+      var_xpath = "#{var_prefix}/#{key.to_s}"
+    else
+      var_xpath = key.to_s
+    end
     if value[:type] == :structure then
       node = doc.at_xpath(xpath)
       if node then
@@ -1866,9 +1947,9 @@ def translate_struct_in_doc_to_SMTLIB(progress, solver, struct, doc, prefix, has
         }
         assertionID = "doc-#{xpath.gsub('/', '-')}"
         solver.associateAssertionIDWith(assertionID, info)
-        solver.to_solver(progress, "(assert (! (= #{exists_var_for_structure(xpath)} true) :named #{assertionID}))")
+        solver.to_solver(progress, "(assert (! (= #{exists_var_for_structure(var_xpath)} true) :named #{assertionID}))")
 
-        translate_struct_in_doc_to_SMTLIB(progress, solver, value[:ref], doc, xpath, hash)
+        translate_struct_in_doc_to_SMTLIB(progress, solver, value[:ref], doc, xpath, var_xpath, hash)
       else
         info = {
           :assertion_type => :doc_structure_not_exists,
@@ -1876,7 +1957,7 @@ def translate_struct_in_doc_to_SMTLIB(progress, solver, struct, doc, prefix, has
         }
         assertionID = "doc-#{xpath.gsub('/', '-')}"
         solver.associateAssertionIDWith(assertionID, info)
-        solver.to_solver(progress, "(assert (! (= #{exists_var_for_structure(xpath)} false) :named #{assertionID}))")
+        solver.to_solver(progress, "(assert (! (= #{exists_var_for_structure(var_xpath)} false) :named #{assertionID}))")
       end
     elsif value[:type] == :field then
       node = doc.at_xpath(xpath)
@@ -1887,10 +1968,11 @@ def translate_struct_in_doc_to_SMTLIB(progress, solver, struct, doc, prefix, has
           :xpath => xpath,
           :value => fvalue
         }
-        fvalue_str = value_of_type(fvalue, value[:datatype])
-        assertionID = "doc-#{xpath.gsub('/', '-')}"
+        fvalue_ruby = parse_field_value_to_ruby(value, fvalue)
+        fvalue_str = value_of_type_to_solver(fvalue_ruby, value[:datatype])
+        assertionID = "doc-#{var_xpath.gsub('/', '-')}"
         solver.associateAssertionIDWith(assertionID, info)
-        solver.to_solver(progress, "(assert (! (and (= #{filled_var_for_field(xpath)} true) (= #{value_var_for_field(xpath)} #{fvalue_str})) :named #{assertionID}))")
+        solver.to_solver(progress, "(assert (! (and (= #{filled_var_for_field(var_xpath)} true) (= #{value_var_for_field(var_xpath)} #{fvalue_str})) :named #{assertionID}))")
       else
         info = {
           :assertion_type => :doc_field_empty,
@@ -1898,7 +1980,7 @@ def translate_struct_in_doc_to_SMTLIB(progress, solver, struct, doc, prefix, has
         }
         assertionID = "doc-#{xpath.gsub('/', '-')}"
         solver.associateAssertionIDWith(assertionID, info)
-        solver.to_solver(progress, "(assert (! (= #{filled_var_for_field(xpath)} false) :named #{assertionID}))")
+        solver.to_solver(progress, "(assert (! (= #{filled_var_for_field(var_xpath)} false) :named #{assertionID}))")
       end
     elsif value[:type] == :list then
       node = doc.at_xpath(xpath)
@@ -1913,14 +1995,62 @@ def translate_struct_in_doc_to_SMTLIB(progress, solver, struct, doc, prefix, has
           :xpath => xpath,
           :values => fvalues
         }
-        fvalue_str = value_of_type(fvalues, value[:datatype])
         assertionID = "doc-#{xpath.gsub('/', '-')}"
         solver.associateAssertionIDWith(assertionID, info)
         clauses = []
         fvalues.each_with_index do |fvalue, index|
           clauses << "(= #{value_var_for_list(xpath,index)} #{value_of_type(fvalue, value[:datatype])})"
         end
-        solver.to_solver(progress, "(assert (! (and (= #{filled_var_for_field(xpath)} true) (= #{size_var_for_list(xpath)} #{fvalues.size}) #{clauses.join(' ')}) :named #{assertionID}))")
+        solver.to_solver(progress, "(assert (! (and (= #{filled_var_for_field(var_xpath)} true) (= #{size_var_for_list(xpath)} #{fvalues.size}) #{clauses.join(' ')}) :named #{assertionID}))")
+      else
+        info = {
+          :assertion_type => :doc_field_empty,
+          :xpath => xpath,
+        }
+        assertionID = "doc-#{xpath.gsub('/', '-')}"
+        solver.associateAssertionIDWith(assertionID, info)
+        solver.to_solver(progress, "(assert (! (= #{filled_var_for_field(var_xpath)} false) :named #{assertionID}))")
+      end
+    elsif value[:type] == :objlist then
+      node = doc.at_xpath(xpath)
+      if node then
+        fvalues = []
+        index = 0
+        num_elements = 0
+        value[:model_maxLength].times do |index|
+          element_node = node.at_xpath("#{value[:xpath_element]}[#{index+1}]")
+          element_xpath = "#{xpath}/#{value[:xpath_element]}[#{index+1}]"
+          element_var_xpath = "#{xpath}/#{index}"
+          if element_node then
+            num_elements += 1
+            info = {
+              :assertion_type => :doc_structure_exists,
+              :xpath => element_xpath,
+            }
+            assertionID = "doc-#{element_var_xpath.gsub('/', '-')}"
+            solver.associateAssertionIDWith(assertionID, info)
+            solver.to_solver(progress, "(assert (! (= #{exists_var_for_structure(element_var_xpath)} true) :named #{assertionID}))")
+
+            translate_struct_in_doc_to_SMTLIB(progress, solver, value[:ref], doc, element_xpath, element_var_xpath, hash)
+          else
+            info = {
+              :assertion_type => :doc_structure_not_exists,
+              :xpath => element_xpath,
+            }
+            assertionID = "doc-#{element_var_xpath.gsub('/', '-')}"
+            solver.associateAssertionIDWith(assertionID, info)
+            solver.to_solver(progress, "(assert (! (= #{exists_var_for_structure(element_var_xpath)} false) :named #{assertionID}))")      
+          end
+        end
+        info = {
+          :assertion_type => :doc_objlist_filled,
+          :size => num_elements,
+          :xpath => xpath
+        }
+        assertionID = "doc-#{xpath.gsub('/', '-')}"
+        solver.associateAssertionIDWith(assertionID, info)
+        clauses = []
+        solver.to_solver(progress, "(assert (! (and (= #{filled_var_for_field(var_xpath)} true) (= #{size_var_for_list(var_xpath)} #{num_elements})) :named #{assertionID}))")
       else
         info = {
           :assertion_type => :doc_field_empty,
@@ -1928,7 +2058,7 @@ def translate_struct_in_doc_to_SMTLIB(progress, solver, struct, doc, prefix, has
         }
         assertionID = "doc-#{xpath.gsub('/', '-')}"
         solver.associateAssertionIDWith(assertionID, info)
-        solver.to_solver(progress, "(assert (! (= #{filled_var_for_field(xpath)} false) :named #{assertionID}))")
+        solver.to_solver(progress, "(assert (! (= #{filled_var_for_field(var_xpath)} false) :named #{assertionID}))")
       end
     else
       raise RuntimeError.new("Model Error: encountered unknown type #{value[:type].inspect}")

data/lib/solver-lib.rb

@@ -225,7 +225,7 @@ class SolverFactory
         unsat_core = session.from_solver(@progress)
         explanation = session.parse_unsat_core(unsat_core)
     else
-      ModelUtils.handleSolverError(@progress, options, result)
+      ModelUtils.handleSolverError(@progress, session, options, result)
     end
 
     return explanation
@@ -469,6 +469,10 @@ class Z3Solver
           return "Structure #{info[:xpath]} exists in document"
         elsif info[:assertion_type] == :doc_structure_not_exists then
           return "Structure #{info[:xpath]} does not exist in document"
+        elsif info[:assertion_type] == :doc_list_filled then
+          return "List #{info[:xpath]} is filled in document and contains the values #{info[:values].inspect}"
+        elsif info[:assertion_type] == :doc_objlist_filled then
+          return "ObjList #{info[:xpath]} is filled in document and contains #{info[:size]} elements"
         elsif info[:assertion_type] == :constraint then
           if info[:constraint_type] == :min then
             return "Field #{info[:xpath]} has a minimum value of #{info[:value]}."

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mbt-gen
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.8
 platform: ruby
 authors:
 - FM-enthusiast
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-31 00:00:00.000000000 Z
+date: 2026-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri