mbt-gen 0.0.1

data/lib/progress.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/ruby
+
+class Progress
+    
+    def initialize()
+        @last_line = ""
+    end
+
+    def update_last_line(last_line)
+       @last_line = last_line
+       print "\033[M#{last_line}"
+       $stdout.flush()
+    end
+
+    def print_line(line)
+       print "\033[M#{line}\n#{@last_line}"
+       $stdout.flush()
+    end
+end
+
+class ProgressBar < Progress
+    def initialize(max)
+        @max = max.to_f
+    end
+
+    def render_bar(current, length)
+        bars = (current.to_f * length.to_f).floor
+        "=" * bars + ">" + " " * (length - bars)
+    end
+
+    def report_progress(progress)
+      if progress then
+        current = (progress.to_f / @max)
+        update_last_line("[#{render_bar(current, 40)}] combinations covered: #{progress}/#{@max} (#{format("%.8f", current * 100.0)}%)")
+      else
+        update_last_line("[... ? ... ? ... ? ...] combinations covered: ?/∞ (?%)")
+      end
+    end
+end

data/lib/regexp-to-smtlib.rb

@@ -0,0 +1,120 @@
+#!/usr/bin/ruby
+
+class Regexp_to_SMTLIB
+
+    def self.translate_regexp_to_SMTLIB(regex_str)
+        if regex_str =~ /^\^(.*)\$$/ then
+            return translate_anchored_regexp_to_SMTLIB($1)
+        elsif regex_str =~ /^\^(.*)$/ then
+            return "(re.++ #{translate_anchored_regexp_to_SMTLIB($1)} (re.* re.allchar))"
+        elsif regex_str =~ /^(.*)\$$/ then
+            return "(re.++ (re.* re.allchar) #{translate_anchored_regexp_to_SMTLIB($1)})"
+        else
+            return "(re.++ (re.* re.allchar) #{translate_anchored_regexp_to_SMTLIB($1)} (re.* re.allchar))"
+        end
+    end
+
+    def self.translate_anchored_regexp_to_SMTLIB(regex_str)
+    begin
+        rest = regex_str
+        res = []
+        found = true
+        endindex = nil
+        while found do
+        found = false
+        if rest =~ /^\[([^\]]*)\](\*|\+|\?|\{(\d+),(\d+)\})?/ then
+            inner = $1
+            multiplicator = $2
+            endindex = $~.end(0)
+            range = translate_regexp_range_to_SMTLIB(inner)
+            if multiplicator then
+            res << translate_multiplicator_for_re_to_SMTLIB(multiplicator, range)
+            found = true
+            else
+            res << range
+            found = true
+            end
+        elsif rest =~ /^([^\[]+)(\*|\+|\?|\{(\d+),(\d+)\})?/
+            string = $1
+            multiplicator = $2
+            endindex = $~.end(0)
+
+            inner = "(str.to.re #{string.inspect})"
+            if multiplicator then
+            res << translate_multiplicator_for_re_to_SMTLIB(multiplicator, inner)
+            found = true
+            else
+            res << inner
+            found = true
+            end
+        end
+        rest = rest.slice(endindex, rest.length) if rest
+        end
+        if res.size > 1 then
+            return "(re.++ #{res.join(" ")})"
+        else
+            if res.empty? then
+            return "re.nostr"
+            else
+            return res.first
+            end
+        end
+    rescue RuntimeError => rte
+        raise RuntimeError.new("cannot parse regex: #{regex_str.inspect}: #{rte.message}")
+    end
+
+        # TODO
+        # - . => re.allchar
+        # * abc => re.++
+        # - string => str.to.re
+        # * [A-Z] => re.range
+        # * [abc] => re.union
+        # * * => re.*
+        # * + => re.+
+        # * ? => re.opt
+        # * {a,b} => re.loop
+    end
+
+    def self.translate_multiplicator_for_re_to_SMTLIB(multiplicator, expr)
+        if multiplicator == "*" then
+            return "(re.* #{expr})"
+        elsif multiplicator == "+" then
+            return "(re.+ #{expr})"
+        elsif multiplicator == "?" then
+            return "(re.opt #{expr})"
+        elsif multiplicator =~ /\{(\d+),(\d+)\}/ then
+        begin
+            lower = Integer($1)
+            upper = Integer($2)
+        rescue TypeError => e
+            raise RuntimeError.new("cannot parse regexp (#{$1} or #{$2} is no Integer)")
+        end
+            return "((_ re.loop #{lower} #{upper}) #{expr})"
+        else
+            raise RuntimeError.new("invalid multiplicator: #{multiplicator}")
+        end
+    end
+
+    # TODO: range complement with ^
+    def self.translate_regexp_range_to_SMTLIB(range)
+        rest = range
+        res = []
+        while rest =~ /^(.)\-(.)/ do
+            ch1 = $1
+            ch2 = $2
+            res << "(re.range \"#{ch1}\" \"#{ch2}\")"
+            rest = rest.slice($~.end(0), rest.length)
+        end
+        if res.size > 1 then
+        return "(re.union #{res.join(" ")})"
+        else
+        if res.empty? then
+            return "re.nostr"
+        else
+            return res.first
+        end
+        end
+    end
+
+
+end

data/lib/solver-lib.rb

@@ -0,0 +1,374 @@
+require 'open3'
+
+FTYPE_MANDATORY = 0
+FTYPE_OPTIONAL  = 1
+
+SUBF_AND = 0
+SUBF_OR  = 1
+SUBF_XOR = 2
+
+LOG_DIR = 'logs'
+
+
+
+class SolverSession
+
+  def initialize(z3in, z3outAndErr, logFileName)
+    @z3in = z3in
+    @z3outAndErr = z3outAndErr
+    @protocol_filename = logFileName
+    @protocol = File.open(@protocol_filename, "w")
+    @assertCounter = -1
+    @associations = {}
+    @consts = {}
+  end
+
+  def emptyReadBuffer(progress)
+    empty = false
+    while !empty do
+      begin
+        c = ""
+        @z3outAndErr.read_nonblock(1, c)
+        line = c + @z3outAndErr.gets
+        checkLineForSolverError(line, progress)
+        @protocol.puts("; Solver Response: #{line}")
+      rescue Errno::EWOULDBLOCK
+        # there is nothing to read -> just continue
+        empty = true
+      rescue Errno::EAGAIN
+        # there is nothing to read -> just continue
+        empty = true
+      rescue EOFError
+        # there is nothing to read -> just continue
+        empty = true
+      end
+    end
+  end
+
+  def declare_const(progress, name, type, info)
+    info[:type] = type
+    @consts[name] = info
+    to_solver(progress, "(declare-const #{name} #{type})")
+  end
+
+  def to_solver(progress, line)
+    emptyReadBuffer(progress);
+    @protocol.puts(line)
+    begin
+      @z3in.puts(line)
+    rescue Errno::EINVAL
+      progress.print_line "ERROR: could not write the line #{line.inspect} to the solver."
+      writeProtocolToFile("failure.smt2")
+    rescue Errno::EPIPE
+      writeProtocolToFile("failure.smt2")
+      throw RuntimeError.new("Broken Pipe")
+    end
+  end
+
+  def checkLineForSolverError(line, progress)
+    if line =~ /\(error \"(.*)\"\)/ then
+      progress.print_line("WARN: Solver reported ERROR: #{$1}")
+    end
+  end
+
+
+  def from_solver(progress)
+    result = @z3outAndErr.gets
+    checkLineForSolverError(result, progress)
+    @protocol.puts("; Solver Response: #{result}")
+    return result
+  end
+
+  def replace_strings(line)
+    line.gsub(/"([^"\\]|\\.)*"/, "")
+  end
+
+  def read_multiline_from_solver()
+    result = ""
+    for_counting = ""
+    @protocol.puts
+    @protocol.puts("; BEGIN Multiline Solver Response:")
+    line = @z3outAndErr.gets
+    result += line
+    for_counting += replace_strings(line)
+    @protocol.puts("; #{line}")
+    
+    num_opening = for_counting.count("(")
+    num_closing = for_counting.count(")")
+    while num_opening > num_closing do
+      line = @z3outAndErr.gets
+      result += line
+      for_counting += replace_strings(line)
+      @protocol.puts("; #{line}")
+
+      num_opening = for_counting.count("(")
+      num_closing = for_counting.count(")")
+    end
+    @protocol.puts("; END Multiline Solver Response")
+    return result
+  end
+
+  def writeProtocolToFile(progress, filename)
+    dir = File.dirname(filename)
+    FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+    FileUtils.cp(@protocol_filename, filename) unless @protocol_filename == filename
+    progress.print_line "Solver protocol written to file #{filename}"
+  end
+
+  def generateNextAssertionIDAndAssociateWith(hash)
+    nextAssertionID = "a#{@assertCounter += 1}"
+    @associations[nextAssertionID] = hash
+    return nextAssertionID
+  end
+
+  def getAssociationForAssertionID(assertionID)
+    return @associations[assertionID]
+  end
+
+  def for_each_const(&block)
+    @consts.each do |key, value|
+      block.call(key, value)
+    end
+  end
+
+  def get_const_info(name)
+    @consts[name]
+  end
+end
+
+class Z3Solver
+
+  def initialize(progress, z3path)
+    z3version = `#{z3path} --version`.chomp()
+    if $?.exitstatus == 0 then
+      progress.print_line "INFO: Using #{z3version} found in z3path=#{z3path}"
+      @z3in, @z3outAndErr, @z3thr = Open3.popen2e(z3path, '-in', '-smt2')
+      Process.detach(@z3thr.pid)
+    else
+      progress.print_line "WARN: could not find z3 in z3path=#{z3path.inspect}"
+      `which z3`
+      if $?.exitstatus == 0 then
+        z3version = `z3 --version`.chomp()
+        progress.print_line "However, #{z3version} is availlable on the PATH. Using this one."
+        @z3in, @z3outAndErr, @z3thr = Open3.popen2e('z3', '-in', '-smt2')
+        Process.detach(@z3thr.pid)
+      else
+        raise RuntimeError.new("ERROR: unable to find Z3. Exiting! (Please provide its location in the config file using the key :z3path)")
+      end
+    end
+    @z3in.sync = true
+
+    @sessionIdCounter = 0
+  end
+
+  def close()
+    @z3in.close()
+    @z3outAndErr.close()
+    Thread.kill(@z3thr)
+  end
+
+  def query(&block)
+    solver = SolverSession.new(@z3in, @z3outAndErr)
+
+    block.call(solver)
+
+    solver.toSolver "(check-sat)"
+    result = solver.fromSolver()
+    if result.chomp == "sat"
+        # model is not contradictory -> continue
+    elsif result.chomp == "unsat"
+        # model is contradictory -> add a message
+
+        solver.toSolver("(get-unsat-core)")
+        unsat_core = solver.fromSolver()
+        explanation = build_explanation_based_on_unsat_core(solver, sid, unsat_core)
+        messages << {:type => :issue, :text => "Model is contradictory", :explanation => explanation}
+        solver.writeProtocolToFile("contradictions.smt2")
+    else
+      handleSolverError(solver, result)
+    end
+
+    messages = []
+    solver.toSolver "(reset)"
+    solver.toSolver "(set-logic ALL)"
+    solver.toSolver "(set-option :produce-unsat-cores true)"
+    return messages
+  end
+
+  # main entry point!
+  def query_model(progress, options, &block)
+    unless options[:solverLog]
+      raise RuntimeError.new("No solverLog specified, but the option :solverLog is required!")
+    end
+    progress.print_line("calling solver (solver-log is written to #{options[:solverLog]})")
+    solver = SolverSession.new(@z3in, @z3outAndErr, options[:solverLog])
+
+    block.call(solver)
+    
+    solver.to_solver(progress, "(check-sat)")
+    result = solver.from_solver(progress)
+    if result.chomp == "sat"
+        # model is not contradictory -> extract model
+        const_list = []
+        const_info = {}
+        solver.for_each_const do |name, info|
+          const_list << name
+          const_info[name] = info
+        end
+        solver.to_solver(progress, "(get-value (#{const_list.join(" ")}))")
+        model_str = solver.read_multiline_from_solver()
+        model = {}
+        foreach_field_in_model_str(model_str, solver, const_info) do |varname, value, info|
+          unless info then
+            progress.print_line "WARN: no info availlable for varname=#{varname.inspect}, value=#{value.inspect}"
+          end
+          xpath = info[:xpath]
+          if model.has_key?(xpath) then
+            if varname.end_with?("-filled") then
+              unless model[xpath][:type] == :field then
+                raise RuntimeError.new("inconsistent model: xpath #{xpath} should be a field, not a #{model[xpath][:type]}.")
+              end
+              unless value == "true" or value == "false" then
+                raise RuntimeError.new("inconsistent model value filled-value of #{xpath} should be a Bool, but was #{value.inspect}.")
+              end
+              if value == "true" then
+                model[xpath][:filled] = true
+              else
+                model[xpath][:filled] = false
+              end
+            elsif varname.end_with?("-value") then
+              unless model[xpath][:type] == :field || model[xpath][:type] == :list then
+                raise RuntimeError.new("inconsistent model: xpath #{xpath} should be a field or a list, not a #{model[xpath][:type]}.")
+              end
+              if model[xpath][:type] == :field then
+                model[xpath][:value] = convert_solver_value(info[:type], info[:datatype], value, xpath)
+              elsif model[xpath][:type] == :list then
+                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)
+                model[xpath][:xpath_element] = info[:xpath_element]
+                if model[xpath].has_key?(:value) then
+                  val = convert_solver_value(info[:type], info[:datatype], value, xpath)
+                  model[xpath][:value].insert(index, val)
+                else
+                  val = convert_solver_value(info[:type], info[:datatype], value, xpath)
+                  model[xpath][:value] = [val]
+                end
+              end
+            elsif varname.end_with?("-size") then
+              unless model[xpath][:type] == :list then
+                raise RuntimeError.new("inconsistent model: xpath #{xpath} should be a list, not a #{model[xpath][:type]}.")
+              end
+              model[xpath][:value] = value
+            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]}.")
+              end
+              model[xpath][:exists] = value
+            end
+          else
+            if varname.end_with?("-filled") then
+              unless value == "true" or value == "false" then
+                raise RuntimeError.new("inconsistent model value filled-value of #{xpath} should be a Bool, but was #{value.inspect}.")
+              end
+              if value == "true" then
+                model[xpath] = { :type => :field, :filled => true }
+              else
+                model[xpath] = { :type => :field, :filled => false }
+              end
+            elsif varname.end_with?("-value") then
+              check_type(info[:type], value, xpath)
+              model[xpath] = {  :type => :field, :value => value }
+            elsif varname.start_with?("struct-") && varname.end_with?("-exists") then
+              unless value == "true" or value == "false" then
+                raise RuntimeError.new("inconsistent model value exists-value of struct #{xpath} should be a Bool, but was #{value.inspect}.")
+              end
+              model[xpath] = { :type => :struct, :exists => value }
+            elsif varname.end_with?("-size") then
+              model[xpath] = { :type => :list, :size => value }
+            end
+          end
+        end
+        return model
+    elsif result.chomp == "unsat"
+        # model is contradictory -> add a message
+
+        solver.to_solver(progress, "(get-unsat-core)")
+        unsat_core = solver.from_solver(progress)
+        solver.writeProtocolToFile(progress, options[:solverLog])
+        progress.print_line "Solver reported a contradiction! please see #{options[:solverLog]} for further information."
+        return nil
+    else
+      handleSolverError(progress, solver, options, result)
+    end
+
+    messages = []
+    solver.to_solver "(reset)"
+    solver.to_solver "(set-logic ALL)"
+    solver.to_solver "(set-option :produce-unsat-cores true)"
+
+    return messages
+  end
+
+  def check_type(type, value, xpath)
+    if type == "String" then
+      unless value =~ /\".*\"/ then
+        raise RuntimeError.new("inconsistent model value: model value for #{xpath} should be a String, but was #{value}.")
+      end
+    elsif type == "Bool"
+      unless value == "true" or value == "false" then
+        raise RuntimeError.new("inconsistent model value for #{xpath} should be a Bool, but was #{value.inspect}.")
+      end
+    elsif type == "Int"
+      unless value =~ /\d+/ then
+        raise RuntimeError.new("inconsistent model value: model value for #{xpath} should be a Int, but was #{value}.")
+      end
+    else
+      raise RuntimeError.new("encountered unknown solver type: type of solver-var for #{xpath} is #{info[:type]}.")
+    end
+  end
+
+  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
+    elsif datatype == :timestamp then
+      return Time.at(Integer(value)).to_s
+    else
+      return value
+    end
+  end
+
+  def foreach_field_in_model_str(str, solver, const_info, &block)
+    unless str =~ /^\((.*)\)$/m
+      raise RuntimeError.new("could not parse model: #{str.inspect}")
+    end
+    str = $1
+
+    str.split("\n").each do |line|
+      unless line =~ /\(([^\ ]*)\ (.*)\)/
+        raise RuntimeError.new("could not parse model line: #{line.inspect}")
+      end
+      varname = $1
+      value = $2
+      if value =~ /\(-\ (\d+)\)/ then
+        simplified = "-#{$1}"
+        value = simplified
+      end
+      info = const_info[varname]
+
+      block.call(varname, value, info)
+    end
+
+    return nil
+  end
+
+  def handleSolverError(progress, solver, options, result)
+    solver.writeProtocolToFile(progress, options[:solverLog])
+    raise RuntimeError.new("Solver Error: Solver returned '#{result}', for more information see #{options[:solverLog]}")
+  end
+
+end
+
+

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: mbt-gen
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- FM-enthusiast
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-04-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.18'
+description: |
+  DSL for modelling XML structure along with logic-based validation rules / constraints.
+  Supports SMT-solver based generation of sample valid XML documents.
+email: nf4eai9s@anonaddy.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mbt-gen.rb
+- lib/progress.rb
+- lib/regexp-to-smtlib.rb
+- lib/solver-lib.rb
+homepage: https://github.com/FM-enthusiast/MBT-gen
+licenses:
+- GPL-3.0-only
+metadata:
+  bug_tracker_uri: https://github.com/FM-enthusiast/MBT-gen/issues
+  source_code_uri: https://github.com/FM-enthusiast/MBT-gen
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- an SMT-solver. Z3 is recommended, it can be obtained from https://github.com/Z3Prover/z3
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: test data generator for Model-based testing
+test_files: []