mbt-gen 0.0.2 → 0.0.4

data/lib/progress.rb

@@ -1,9 +1,14 @@
 #!/usr/bin/ruby
 
+require 'fileutils'
+
 class Progress
     
-    def initialize()
+    def initialize(logfilename)
         @last_line = ""
+        dir = File.dirname(logfilename)
+        FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+        @logfile = File.open(logfilename, "w")
     end
 
     def update_last_line(last_line)
@@ -13,27 +18,64 @@ class Progress
     end
 
     def print_line(line)
+       @logfile.puts(line)
+       @logfile.flush()
        print "\033[M#{line}\n#{@last_line}"
        $stdout.flush()
     end
 end
 
 class ProgressBar < Progress
-    def initialize(max)
+    def initialize(max, logfilename)
+        super(logfilename)
         @max = max.to_f
     end
 
+    def set_max(value)
+      @max = value.to_f
+    end
+
     def render_bar(current, length)
         bars = (current.to_f * length.to_f).floor
         "=" * bars + ">" + " " * (length - bars)
     end
 
-    def report_progress(progress)
+    def processing_time(start_time, prior_processessing_time)
+      total_sec = prior_processessing_time + (Time.now().to_i - start_time)
+      sec = total_sec
+      days = sec / (3600*24)
+      sec -= days * (3600*24)
+      hours = sec / 3600
+      sec -= hours * 3600
+      min = sec / 60
+      sec -= min * 60
+      if days > 0 then
+        return format("%d:%02d:%02d:%02d", days, hours, min, sec)
+      else
+        if hours > 0 then
+          return format("%02d:%02d:%02d", hours, min, sec)
+        else
+          return format("%02d:%02d", min, sec)
+        end
+      end
+    end
+
+    def report_progress(progress, start_time, prior_processessing_time, num_docs)
+      time_str = processing_time(start_time, prior_processessing_time)
       if progress then
         current = (progress.to_f / @max)
-        update_last_line("[#{render_bar(current, 40)}] combinations covered: #{progress}/#{@max} (#{format("%.8f", current * 100.0)}%)")
+        update_last_line("#{time_str} [#{render_bar(current, 40)}] combinations covered: #{progress}/#{@max} (#{format("%.8f", current * 100.0)}%), docs generated: #{num_docs}")
       else
-        update_last_line("[... ? ... ? ... ? ...] combinations covered: ?/∞ (?%)")
+        update_last_line("#{time_str} [... ? ... ? ... ? ...] combinations covered: ?/∞ (?%), docs generated: #{num_docs}")
+      end
+    end
+
+    def self.logging(max, logfile, &block)
+      progress = ProgressBar.new(max, logfile)
+      begin
+        block.call(progress)
+      ensure
+        progress.print_line("Output written to #{logfile}")
       end
     end
 end

data/lib/solver-lib.rb

@@ -5,9 +5,9 @@ require 'open3'
 
 class SolverSession
 
-  def initialize(z3in, z3outAndErr, logFileName)
-    @z3in = z3in
-    @z3outAndErr = z3outAndErr
+  def initialize(solverFactory, logFileName)
+    @solverFactory = solverFactory
+    @solver = @solverFactory.new_solver()
     @protocol_filename = logFileName
     @protocol = File.open(@protocol_filename, "w")
     @assertCounter = -1
@@ -15,13 +15,26 @@ class SolverSession
     @consts = {}
   end
 
+  def switch_solver(progress)
+    @solver.close()
+    @solver = @solverFactory.new_solver()
+    # re-feed the session protocol into the new solver to get it up-to-date
+    @protocol.close()
+    File.open(@protocol_filename, "r") do |protocol|
+      protocol.each_line do |line|
+        to_solver(progress, line)
+      end
+    end
+    @protocol = File.open(@protocol_filename, "a")
+  end
+
   def emptyReadBuffer(progress)
     empty = false
     while !empty do
       begin
         c = ""
-        @z3outAndErr.read_nonblock(1, c)
-        line = c + @z3outAndErr.gets
+        @solver.z3outAndErr.read_nonblock(1, c)
+        line = c + @solver.z3outAndErr.gets
         checkLineForSolverError(line, progress)
         @protocol.puts("; Solver Response: #{line}")
       rescue Errno::EWOULDBLOCK
@@ -45,16 +58,27 @@ class SolverSession
 
   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")
+    success = false
+    while (!success) do
+      begin
+        @solver.z3in.puts(line)
+        success = true
+      rescue Errno::EINVAL => e
+        progress.print_line("DEBUG: Invalid argument to puts(): #{line.inspect}")
+        progress.print_line("An Error occured: #{e.message}")
+        e.backtrace.each { |stline| progress.print_line(stline) }
+        progress.print_line("=> Switching Solver")
+        switch_solver(progress)
+        progress.print_line("=> Switch successful. Trying again.")
+      rescue Errno::EPIPE => e
+        progress.print_line("An Error occured: #{e.message}")
+        e.backtrace.each { |stline| progress.print_line(stline) }
+        progress.print_line("=> Switching Solver")
+        switch_solver(progress)
+        progress.print_line("=> Switch successful. Trying again.")
+      end
     end
+    @protocol.puts(line)
   end
 
   def checkLineForSolverError(line, progress)
@@ -65,14 +89,14 @@ class SolverSession
 
 
   def from_solver(progress)
-    result = @z3outAndErr.gets
+    result = @solver.z3outAndErr.gets(chomp: true)
     checkLineForSolverError(result, progress)
     @protocol.puts("; Solver Response: #{result}")
     return result
   end
 
   def replace_strings(line)
-    line.gsub(/"([^"\\]|\\.)*"/, "")
+    line.gsub(/"[^"]*"/, "")
   end
 
   def read_multiline_from_solver()
@@ -80,21 +104,23 @@ class SolverSession
     for_counting = ""
     @protocol.puts
     @protocol.puts("; BEGIN Multiline Solver Response:")
-    line = @z3outAndErr.gets
+    line = @solver.z3outAndErr.gets(chomp: true)
     result += line
-    for_counting += replace_strings(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(")")
+    while num_opening > num_closing && line != nil do
+      line = @solver.z3outAndErr.gets(chomp: true)
+      if line
+        result += line
+        for_counting = replace_strings(line)
+        @protocol.puts("; #{line}")
+        
+        num_opening += for_counting.count("(")
+        num_closing += for_counting.count(")")
+      end
     end
     @protocol.puts("; END Multiline Solver Response")
     return result
@@ -113,6 +139,13 @@ class SolverSession
     return nextAssertionID
   end
 
+  def associateAssertionIDWith(assertionID, hash)
+    if @associations.has_key?(assertionID) then
+      raise RuntimeError.new("AssertionID #{assertionID.inspect} already has info associated with it!")
+    end
+    @associations[assertionID] = hash
+  end
+
   def getAssociationForAssertionID(assertionID)
     return @associations[assertionID]
   end
@@ -126,93 +159,103 @@ class SolverSession
   def get_const_info(name)
     @consts[name]
   end
+
+  def parse_unsat_core(unsat_core)
+    @solver.parse_unsat_core(unsat_core, self)
+  end
+
+  def handleSolverError(progress, options, result)
+    @solver.handleSolverError(progress, self, options, result)
+  end
 end
 
-class Z3Solver
+class SolverFactory
+
+  attr_reader :z3path, :z3version
 
   def initialize(progress, z3path)
-    z3version = `#{z3path} --version`.chomp()
-    if $?.exitstatus == 0 then
+    @progress = progress
+    z3version = nil
+    exitstatus = nil
+    begin
+      z3version = `#{z3path} --version`.chomp()
+      exitstatus = $?.exitstatus
+    rescue Errno::ENOENT
+    end
+    if exitstatus == 0 && z3version != nil then
       progress.print_line "INFO: Using #{z3version} found in z3path=#{z3path}"
-      @z3in, @z3outAndErr, @z3thr = Open3.popen2e(z3path, '-in', '-smt2')
-      Process.detach(@z3thr.pid)
+      @z3path = z3path
+      @z3version = z3version
     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)
+        @z3path = 'z3'
+        @z3version = z3version
       else
-        raise RuntimeError.new("ERROR: unable to find Z3. Exiting! (Please provide its location in the config file using the key :z3path)")
+        raise RuntimeError.new("ERROR: unable to find Z3 solver. 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)
+  def new_solver()
+    Z3Solver.new(@progress, @z3path)
   end
 
-  def query(&block)
-    solver = SolverSession.new(@z3in, @z3outAndErr)
+  def query(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]})")
 
-    block.call(solver)
+    session = SolverSession.new(self, options[:solverLog])
+    block.call(session)
 
-    solver.toSolver "(check-sat)"
-    result = solver.fromSolver()
-    if result.chomp == "sat"
+    session.to_solver(@progress, "(check-sat)")
+    result = session.from_solver(@progress)
+    explanation = true
+    if result == "sat"
         # model is not contradictory -> continue
-    elsif result.chomp == "unsat"
+    elsif result == "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")
+        session.to_solver(@progress, "(get-unsat-core)")
+        unsat_core = session.from_solver(@progress)
+        explanation = session.parse_unsat_core(unsat_core)
     else
-      handleSolverError(solver, result)
+      session.handleSolverError(@progress, options, result)
     end
 
-    messages = []
-    solver.toSolver "(reset)"
-    solver.toSolver "(set-logic ALL)"
-    solver.toSolver "(set-option :produce-unsat-cores true)"
-    return messages
+    return explanation
   end
 
   # main entry point!
-  def query_model(progress, options, &block)
+  def query_model(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])
+    @progress.print_line("calling solver (solver-log is written to #{options[:solverLog]})")
+    session = SolverSession.new(self, options[:solverLog])
 
-    block.call(solver)
-    
-    solver.to_solver(progress, "(check-sat)")
-    result = solver.from_solver(progress)
+    block.call(session)
+    session.to_solver(@progress, "(check-sat)")
+    result = session.from_solver(@progress)
     if result.chomp == "sat"
         # model is not contradictory -> extract model
         const_list = []
         const_info = {}
-        solver.for_each_const do |name, info|
+        session.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()
+        session.to_solver(@progress, "(get-value (#{const_list.join(" ")}))")
+        model_str = session.read_multiline_from_solver()
         model = {}
-        foreach_field_in_model_str(model_str, solver, const_info) do |varname, value, info|
+        Z3Solver.foreach_field_in_model_str(model_str, const_info) do |varname, value, info|
           unless info then
-            progress.print_line "WARN: no info availlable for varname=#{varname.inspect}, value=#{value.inspect}"
+            @progress.print_line "WARN: no info availlable for varname=#{varname.inspect}, value=#{value.inspect}"
           end
           xpath = info[:xpath]
           if model.has_key?(xpath) then
@@ -221,7 +264,7 @@ class Z3Solver
                 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}.")
+                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
@@ -249,10 +292,13 @@ class Z3Solver
                 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]}.")
+              unless model[xpath][:type] == :list || model[xpath][:type] == :field then
+                raise RuntimeError.new("inconsistent model: xpath #{xpath} should be a list or a field, not a #{model[xpath][:type].inspect}.")
+              end
+              if model[xpath][:type] == :field then
+                model[xpath][:type] = :list
               end
-              model[xpath][:value] = value
+              model[xpath][:size] = Integer(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]}.")
@@ -262,7 +308,7 @@ class Z3Solver
           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}.")
+                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 }
@@ -274,7 +320,7 @@ class Z3Solver
               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}.")
+                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
@@ -286,21 +332,27 @@ class Z3Solver
     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."
+        session.to_solver(@progress, "(get-unsat-core)")
+        unsat_core = session.from_solver(@progress)
+        session.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)
+      session.handleSolverError(@progress, options, result)
     end
 
-    messages = []
-    solver.to_solver "(reset)"
-    solver.to_solver "(set-logic ALL)"
-    solver.to_solver "(set-option :produce-unsat-cores true)"
+    return nil
+  end
 
-    return messages
+  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 check_type(type, value, xpath)
@@ -321,24 +373,119 @@ class Z3Solver
     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
+end
+
+class Z3Solver
+
+  attr_reader :z3in, :z3outAndErr
+
+  def initialize(progress, z3path)
+      @progress = progress
+      @z3in, @z3outAndErr, @z3thr = Open3.popen2e(z3path, '-in', '-smt2')
+      Process.detach(@z3thr.pid)
+      @z3in.sync = true
+      @sessionIdCounter = 0
+  end
+
+  def close()
+    begin
+      @z3in.close() unless @z3in.closed?
+    rescue Errno::EINVAL
+    end
+    begin
+      @z3outAndErr.close() unless @z3outAndErr.closed?
+    rescue Errno::EINVAL
+    end
+    Thread.kill(@z3thr)
+  end
+
+  def display_assertion(assertion, session)
+    if assertion =~ /validation_rule_(.*)_instance_(.*)/ then
+      return "Validation rule #{$1} of structure #{$2.gsub("_", "/")}"
     else
-      return value
+      info = session.getAssociationForAssertionID(assertion)
+      if info then
+        if info[:assertion_type] == :doc_field_filled then
+          return "Field #{info[:xpath]} contains value #{info[:value].inspect} in document"
+        elsif info[:assertion_type] == :doc_field_empty then
+          return "Field #{info[:xpath]} is empty in document"
+        elsif info[:assertion_type] == :doc_structure_exists then
+          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] == :constraint then
+          if info[:constraint_type] == :min then
+            return "Field #{info[:xpath]} has a minimum value of #{info[:value]}."
+          elsif info[:constraint_type] == :max then
+            return "Field #{info[:xpath]} has a maximum value of #{info[:value]}."
+          elsif info[:constraint_type] == :required then
+            return "Field #{info[:xpath]} is required."
+          else
+            p info
+            raise RuntimeError.new("encountered unknown :constraint_type #{info[:constraint_type].inspect} for assertionID #{assertion.inspect}")
+          end
+        else
+          raise RuntimeError.new("encountered unknown :assertion_type #{info[:assertion_type].inspect} for assertionID #{assertion.inspect}")
+        end
+      else
+        return assertion
+      end
+    end
+  end
+
+  def parse_unsat_core(unsat_core, session)
+    unless unsat_core =~ /\((.*)\)/ then
+      raise RuntimeError.new("could not parse unsat core: #{unsat_core.inspect}")
+    end
+    list = $1.split(" ")
+
+    result = "EXPLANATION:\n"
+    result += "The following values\n"
+
+    list.filter{|a| a.start_with?("doc-")}.each do |assertion|
+      result += "- #{display_assertion(assertion, session)} (#{assertion})\n"
+    end
+    result += "\nviolate the following constraints\n"
+    list.filter{|a| !a.start_with?("doc-")}.each do |assertion|
+      result += "- #{display_assertion(assertion, session)} (#{assertion})\n"
+    end
+    return result
+  end
+
+  def self.find_matching_bracket(str)
+    i = 0
+    open = 0
+    in_str = false
+    while open <= 0 do
+      if str[i] == '(' and !in_str then
+        open += 1
+      elsif str[i] == '"' then
+        in_str = !in_str
+      end
+      i += 1    
+    end
+    while open > 0 do
+      if str[i] == '(' && !in_str then
+        open += 1
+      elsif str[i] == ')' && !in_str then
+        open -= 1
+      elsif str[i] == '"' then
+        in_str = !in_str
+      end
+      i += 1
     end
+    str[0,i]
   end
 
-  def foreach_field_in_model_str(str, solver, const_info, &block)
+  def self.foreach_field_in_model_str(str, const_info, &block)
     unless str =~ /^\((.*)\)$/m
       raise RuntimeError.new("could not parse model: #{str.inspect}")
     end
     str = $1
 
-    str.split("\n").each do |line|
+    while str.size() > 0 do
+      line = Z3Solver.find_matching_bracket(str)
+      str = str[line.size()..]
       unless line =~ /\(([^\ ]*)\ (.*)\)/
         raise RuntimeError.new("could not parse model line: #{line.inspect}")
       end
@@ -356,8 +503,8 @@ class Z3Solver
     return nil
   end
 
-  def handleSolverError(progress, solver, options, result)
-    solver.writeProtocolToFile(progress, options[:solverLog])
+  def handleSolverError(progress, session, options, result)
+    session.writeProtocolToFile(progress, options[:solverLog])
     raise RuntimeError.new("Solver Error: Solver returned '#{result}', for more information see #{options[:solverLog]}")
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mbt-gen
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - FM-enthusiast
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-26 00:00:00.000000000 Z
+date: 2026-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri