mbt-gen 0.0.13 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 112610c6e247d3de6fc7c69afc0a668659dbcffc9ee1786967bf4a69d9586520
-  data.tar.gz: d0eea35ebf9689ca1bead1e9efe8e8f2a96b75d45b644484875e383927dd2b91
+  metadata.gz: 4dab888f896a820078b818a69beb6c96832509be151437332a64efe493c99c43
+  data.tar.gz: 7bb0d5281265df6171e316c4c5cf5b2f6ef909bee7549cb6213c3d61e79c46fe
 SHA512:
-  metadata.gz: 137856eff73bfde902b67a9bdc97426253b036a79be6d1b6e912ceaa6012a27bb27715d3de26fb75210602985b8e8bdbe6e43cf15db8edb4f931db69f9b16c5d
-  data.tar.gz: 37e9195a691a211aca006aef7ba57cfc5a91d46f61327acd0297385911f8d29fe4b60dcd77a3514a3b5565aff7d5517d92413e3a80005eff1b24c204bd83c87e
+  metadata.gz: e14470e1741ccc1dfede14112f045bb952f42afbb4c8d55af8ac42bcf4517ae4de9fe0fedd6b3296c3a51651665c8d2d3a996e51fa7be892e7a9dea6890d28c7
+  data.tar.gz: 6e723168766e1dc4414e9e25344e9a3f2abc4b6704e5d25bb85e19c20b9f933b37deea1fa904f2954689151a4db3b41a6c427856ce5534e10473540a43ed6fd4

data/lib/mbt-gen.rb

@@ -182,6 +182,10 @@ def maxLength_contraint_for_expr(expr, maxLength)
   "(<= (str.len #{expr}) #{maxLength})"
 end
 
+def minLength_contraint_for_expr(expr, minLength)
+  "(>= (str.len #{expr}) #{minLength})"
+end
+
 def oneOf_contraint_for_expr(expr, values)
   list = values.map do |val|
     "(= #{expr} \"#{val}\")"
@@ -246,7 +250,6 @@ def translate_field_def_to_SMTLIB_constraints(progress, solver, fielddef, xpath,
         solver.associateAssertionIDWith(assertionID, info)
         solver.to_solver(progress, "(assert (! (=> #{varname}-filled #{regex_constraint_for_expr("#{varname}-value", fielddef[:regex])}) :named #{assertionID}))") 
     end 
-    # TODO: minLength?
     if fielddef[:maxLength] then
       assertionID = "maxLength-#{varname}"
         info = {
@@ -259,6 +262,18 @@ def translate_field_def_to_SMTLIB_constraints(progress, solver, fielddef, xpath,
       solver.associateAssertionIDWith(assertionID, info)
       solver.to_solver(progress, "(assert (! (=> #{varname}-filled #{maxLength_contraint_for_expr("#{varname}-value", fielddef[:maxLength])}) :named #{assertionID}))") 
     end
+    if fielddef[:minLength] then
+      assertionID = "minLength-#{varname}"
+        info = {
+          :assertion_type => :constraint,
+          :xpath => xpath,
+          :datatype => :string,
+          :value => fielddef[:minLength],
+          :constraint_type => :minLength
+        }
+      solver.associateAssertionIDWith(assertionID, info)
+      solver.to_solver(progress, "(assert (! (=> #{varname}-filled #{minLength_contraint_for_expr("#{varname}-value", fielddef[:minLength])}) :named #{assertionID}))") 
+    end
     if fielddef[:from_list] then
       assertionID = "oneOf-#{varname}"
       list_filename = "#{LISTS_DIR}/#{fielddef[:from_list]}"
@@ -310,12 +325,16 @@ def translate_list_def_to_SMTLIB_constraints(progress, solver, fielddef, varname
           solver.to_solver(progress, "(assert (! (=> (< #{i} #{varname}-size) #{regex_constraint_for_expr("#{varname}-index-#{i}-value", fielddef[:regex])}) :named list-regex-#{varname}-index-#{i}))") 
         end
     end 
-    # TODO: minLength?
     if fielddef[:maxLength] then
         fielddef[:model_maxLength].times do |i|
           solver.to_solver(progress, "(assert (! (=> (< #{i} #{varname}-size) #{maxLength_contraint_for_expr("#{varname}-index-#{i}-value", fielddef[:maxLength])}) :named list-maxLength-#{varname}-index-#{i}))") 
         end
     end 
+    if fielddef[:minLength] then
+        fielddef[:model_maxLength].times do |i|
+          solver.to_solver(progress, "(assert (! (=> (< #{i} #{varname}-size) #{minLength_contraint_for_expr("#{varname}-index-#{i}-value", fielddef[:minLength])}) :named list-minLength-#{varname}-index-#{i}))") 
+        end
+    end 
   when :enum
     fielddef[:model_maxLength].times do |i|
       solver.to_solver(progress, "(assert (! (=> (< #{i} #{varname}-size) #{enum_constraint_for_expr("#{varname}-index-#{i}-value", fielddef[:values])}) :named list-enum-#{varname}-index-#{i}))") 
@@ -412,7 +431,7 @@ def translate_substructure_to_SMTLIB(progress, solver, struct, hash = {})
         solver.to_solver(progress, "(assert (! (=> (not #{filled_var_for_field(xpath)}) (= #{size_var_for_list(xpath)} 0)) :named empty-objlist-has-zero-size-#{raw_field(xpath)}))")
         solver.to_solver(progress, "(assert (! (=> (= #{size_var_for_list(xpath)} 0) (not #{filled_var_for_field(xpath)})) :named objlist-has-zero-size-implies-empty-objlist-#{raw_field(xpath)}))")
         minSize = 0
-        solver.to_solver(progress, "(assert (! (=> #{filled_var_for_field(xpath)} (and (> #{size_var_for_list(xpath)} #{minSize}) (< #{size_var_for_list(xpath)} #{definition[:model_maxLength]}))) :named filled-objlist-has-positive-size-#{raw_field(xpath)}))")
+        solver.to_solver(progress, "(assert (! (=> #{filled_var_for_field(xpath)} (and (> #{size_var_for_list(xpath)} #{minSize}) (<= #{size_var_for_list(xpath)} #{definition[:model_maxLength]}))) :named filled-objlist-has-positive-size-#{raw_field(xpath)}))")
         solver.to_solver(progress, "(assert (! (=> (> #{size_var_for_list(xpath)} 0) #{filled_var_for_field(xpath)}) :named objlist-has-positive-size-implies-filled-objlist-#{raw_field(xpath)}))")
         definition[:model_maxLength].times do |i|
           ext_xpath = "#{xpath}/#{i}"
@@ -628,7 +647,7 @@ def translate_validation_rule_to_SMTLIB(rule, context_struct, prefix, config, op
                       raise RuntimeError.new("could not parse LIST_VALUE_FIRST_ELEMENT[...]: #{m.inspect} in validation rule #{rule_name}")
                     end
                     xpath = $1
-                    index = Integer($2)
+                    index = Integer($2, 10)
                     l = resolve_field_path(xpath, context_struct, prefix)
                     value_var_for_list(l, index)
                   end
@@ -724,7 +743,7 @@ def translate_validation_rule_to_SMTLIB(rule, context_struct, prefix, config, op
                       end
                     elsif fdef[:datatype] == :int then
                       terms = values.filter{|l| !l.start_with?("#")}.map do |val|
-                        "(= #{value_var_for_field(fpath)} #{Integer(val)})"
+                        "(= #{value_var_for_field(fpath)} #{Integer(val, 10)})"
                       end
                     else
                       raise RuntimeError.new("FIELD_IN_QUERY[] was applied to a field of datatype #{fdef[:datatype].inspect}. However, it can only be applied to fields of datatype string or int.")
@@ -793,7 +812,7 @@ def parse_field_value(fielddef, value)
   datatype = fielddef[:datatype]
   case datatype
   when :int
-    return Integer(value)
+    return Integer(value, 10)
   when :string
     return solver_value_to_string(value)
   when :enum
@@ -847,7 +866,11 @@ def pick_solver_value_for_field(field_desc)
     if field_desc[:maxLength] then
       "a" * field_desc[:maxLength]
     else
-      "default"
+      if field_desc[:minLength] then
+        "a" * field_desc[:minLength]
+      else
+        "default"
+      end
     end
   elsif field_desc[:datatype] == :enum then
     field_desc[:values].first.to_s
@@ -878,8 +901,8 @@ def add_max_struct_to_doc(progress, struct, doc, prefix = nil)
         node = node.first 
       end
       xpath_element = value[:xpath_element]
-      if Integer(value[:model_maxLength]) > 0 then
-        Integer(value[:model_maxLength]).times do |i|
+      if Integer(value[:model_maxLength], 10) > 0 then
+        Integer(value[:model_maxLength], 10).times do |i|
           node.add_child("<#{xpath_element}>#{format_solver_value(value, pick_solver_value_for_field(value))}</#{xpath_element}>")
         end
       end
@@ -941,8 +964,8 @@ def add_model_struct_to_doc(progress, struct, doc, model, prefix = nil)
         node = node.first 
       end
       xpath_element = value[:xpath_element]
-      if Integer(model_value[:size]) > 0 then
-        model_value[:value].slice(0, Integer(model_value[:size])).each do |mvalue|
+      if Integer(model_value[:size], 10) > 0 then
+        model_value[:value].slice(0, Integer(model_value[:size], 10)).each do |mvalue|
           node.add_child("<#{xpath_element}>#{solver_value_to_string(mvalue)}</#{xpath_element}>")
         end
       end
@@ -952,7 +975,7 @@ def add_model_struct_to_doc(progress, struct, doc, model, prefix = nil)
         node = node.first 
       end
       xpath_element = value[:xpath_element]
-      if Integer(model_value[:size]) > 0 then
+      if Integer(model_value[:size], 10) > 0 then
         model_value[:size].times do |index|
           cnode = node.add_child("<#{xpath_element}></#{xpath_element}>")
           if cnode.is_a?(Nokogiri::XML::NodeSet) then
@@ -1328,7 +1351,7 @@ def z3ValueToRubyValue(value)
   if value =~ /\"(.*)\"/ then # string
     return $1
   elsif value =~ /\d+/ then # int
-    return Integer(value)
+    return Integer(value, 10)
   elsif value == "true"
     return true
   elsif value == "false" then
@@ -1596,7 +1619,7 @@ def default_parser_for_type(value_str, datatype)
   if datatype == :string or datatype == :enum then
     value_str
   elsif datatype == :int then
-    Integer(value_str)
+    Integer(value_str, 10)
   elsif datatype == :date then
     Date.parse(value_str)
   elsif datatype == :timestamp then
@@ -1819,12 +1842,12 @@ class CoreEnumerationAlgo
 
   def self.parse_continuation_point(line)
     split = line.split(";")
-    doc_number = Integer(split[0])
-    num_docs = Integer(split[1])
+    doc_number = Integer(split[0], 10)
+    num_docs = Integer(split[1], 10)
     state = CoreEnumerationAlgo.parse_state(split[2])
     assignment = CoreEnumerationAlgo.parse_assignment(split[3])
     new_assignment = CoreEnumerationAlgo.parse_assignment(split[4])
-    processessing_time = Integer(split[5])
+    processessing_time = Integer(split[5], 10)
     return [doc_number, num_docs, state, assignment, new_assignment, processessing_time]
   end
 
@@ -2523,7 +2546,7 @@ def generate(message, argv, message_config_filename = nil)
     elsif opt == "-generate-docs-from" then
       options[:combination_source] = argv.shift
     elsif opt == "-skip" then
-      options[:skip] = Integer(argv.shift)
+      options[:skip] = Integer(argv.shift, 10)
     elsif opt == "-generate-docs-for-key" then
       options[:docs_for_key] = argv.shift
     elsif opt == "-count-docs-for-key" then
@@ -2531,7 +2554,7 @@ def generate(message, argv, message_config_filename = nil)
     elsif opt == "-continue" then
       options[:continue] = true
     elsif opt == "-max-num-docs" then
-      options[:max_num_docs] = Integer(argv.shift)
+      options[:max_num_docs] = Integer(argv.shift, 10)
       puts "flag -max-num-docs used. Will stop after generating #{options[:max_num_docs]} documents."
     elsif opt == "-validate" then
       if options.has_key?(:validate_files) then

data/lib/regexp-to-smtlib.rb

@@ -84,8 +84,8 @@ class Regexp_to_SMTLIB
             return "(re.opt #{expr})"
         elsif multiplicator =~ /\{(\d+),(\d+)\}/ then
         begin
-            lower = Integer($1)
-            upper = Integer($2)
+            lower = Integer($1, 10)
+            upper = Integer($2, 10)
         rescue TypeError => e
             raise RuntimeError.new("cannot parse regexp (#{$1} or #{$2} is no Integer)")
         end
@@ -117,4 +117,4 @@ class Regexp_to_SMTLIB
     end
 
 
-end
+end

data/lib/solver-lib.rb

@@ -337,7 +337,7 @@ class SolverFactory
                 unless varname =~ /-index-(\d+)-value$/
                   raise RuntimeError.new("inconsistent model: xpath #{xpath} is a list value and hence its varname should end like -index-X-value, not #{varname.inspect}.")
                 end
-                index = Integer($1)
+                index = Integer($1, 10)
                 model[xpath][:xpath_element] = info[:xpath_element]
                 if model[xpath].has_key?(:value) then
                   val = convert_solver_value(info[:type], info[:datatype], value, xpath)
@@ -354,7 +354,7 @@ class SolverFactory
               if model[xpath][:type] == :field then
                 model[xpath][:type] = :list
               end
-              model[xpath][:size] = Integer(value)
+              model[xpath][:size] = Integer(value, 10)
             elsif varname.start_with?("struct-") && varname.end_with?("-exists") then
               unless model[xpath][:type] == :struct then
                 raise RuntimeError.new("inconsistent model: xpath #{xpath} should be a struct, not a #{model[xpath][:type]}.")
@@ -403,9 +403,9 @@ class SolverFactory
   def convert_solver_value(type, datatype, value, xpath)
     check_type(type, value, xpath)
     if datatype == :date then
-      return (Time.at(0).to_date + Integer(value)).to_s
+      return (Time.at(0).to_date + Integer(value, 10)).to_s
     elsif datatype == :timestamp then
-      return Time.at(Integer(value)).to_s
+      return Time.at(Integer(value, 10)).to_s
     else
       return value
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mbt-gen
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.14
 platform: ruby
 authors:
 - FM-enthusiast
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-11-01 00:00:00.000000000 Z
+date: 2026-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri