pg-verify 0.1.1 → 0.1.2

data/integration_tests/ruby_dsl/020_vending_machine.rb

@@ -0,0 +1,188 @@
+model :VendingMachine do
+
+  products = {
+      cola:  1.2,
+      chips: 2.5
+  }
+  products = products.map { |c, v| [c, (v * 10).to_i] }.to_h
+
+  coins = {
+      ten_cents: 10,
+      twenty_cents: 20,
+      fifty_cents: 50,
+      one_euro: 100,
+      two_euro: 200
+  }
+  coins = coins.map { |c, v| [c, (v / 10).to_i] }.to_h
+
+
+  max_money = 100
+  start_money = 20
+
+  transient error :CoinReadFails
+
+  graph :User do
+      press_states = products.keys.map { |product| :"press_#{product}" }
+      grab_states  = products.keys.map { |product| :"grab_#{product}" }
+      insert_states = coins.keys.map { |coin| :"insert_#{coin}" }
+
+      var pocket_money: (0..max_money), init: start_money
+      var value_in_products: (0..max_money), init: 0
+
+      states :inserting, *insert_states, \
+             :pressing, *press_states, \
+             :waiting, :grab_product, \
+             :grab_change, \
+             :done, \
+             init: :inserting
+
+      # The user can insert coins until the money runs out
+      coins.each { |coin, value|
+        transition :inserting => :"insert_#{coin}" do
+          guard  "pocket_money - #{value} >= 0"
+          action "pocket_money := pocket_money - #{value}"
+        end
+        transition :"insert_#{coin}" => :inserting
+      }
+
+      # The user can decide at any point to start pressing buttons
+      transition :inserting => :pressing
+
+      # Press one button and wait for the result
+      products.each { |product, value|
+        transition :pressing => :"press_#{product}"
+        transition :"press_#{product}" => :waiting
+      }
+
+      # Grab a product and take note of the value
+      products.each { |product, value|
+        transition :waiting => :grab_product do
+          precon "value_in_products + #{value} < #{max_money}"
+          guard  "LED == green && Dispenser == dispensed_#{product}"
+          action "value_in_products := value_in_products + #{value}"
+        end
+      }
+      transition :grab_product => :grab_change
+
+      # Grab change directly 
+      transition :waiting => :grab_change do
+        guard "LED == red"
+      end
+
+
+      # Grab the change and be done
+      transition :grab_change => :done do
+        precon "pocket_money + change <= #{max_money}"
+        action "pocket_money := pocket_money + change"
+      end
+  end
+
+  graph :CoinReader do
+    states :reading
+
+    var read_value: (0..coins.values.max), init: 0
+
+    coins.each { |coin, value|
+      transition :reading => :reading do
+        guard  "User == insert_#{coin} && CoinReadFails == No"
+        action "read_value := #{value}"
+      end
+    }
+
+    transition :reading => :reading do
+      guard  coins.keys.map { |coin| "User != insert_#{coin}" }.join(" && ")
+      action "read_value := 0"
+    end
+
+  end
+
+  graph :Controller do
+    var budget: (0..max_money), init: 0
+
+    dispense_states = products.keys.map { |product| :"dispense_#{product}" }
+
+    states :accepting, *dispense_states, :rejected, :done, init: :accepting
+
+    transition :accepting => :accepting do
+      precon "budget + read_value <= #{max_money}"
+      guard "read_value > 0"
+      action "budget := budget + read_value"
+    end
+
+    products.each { |product, value|
+      transition :accepting => :"dispense_#{product}" do
+        guard  "User == press_#{product} && budget >= #{value}"
+        action "budget := budget - #{value}"
+      end
+      transition :"dispense_#{product}" => :done
+
+      transition :accepting => :rejected do
+        guard "User == press_#{product} && budget < #{value}"
+      end
+    }
+
+    transition :accepting => :accepting do
+      guard  "CoinDispenser == dispensed_change"
+      action "budget := 0"
+    end
+    transition :done => :accepting do
+      guard  "CoinDispenser == dispensed_change"
+      action "budget := 0"
+    end
+
+
+  end
+
+  graph :LED do
+    states :idle, :red, :green, init: :idle
+
+    transition :idle => :green do
+      guard "Controller == done"
+    end
+    transition :idle => :red do
+      guard "Controller == rejected"
+    end
+
+  end
+
+  graph :Dispenser do
+    dispensed_states = products.keys.map { |product| :"dispensed_#{product}" }
+    states :empty, *dispensed_states, init: :empty
+
+    # Dispense the product the Controller tells us to
+    products.each { |product, value|
+      transition :empty => :"dispensed_#{product}" do
+        guard "Controller == dispense_#{product}"
+      end
+    }
+  end
+
+  graph :CoinDispenser do
+    states :idle, :dispensed_change, init: :idle
+    var change: (0..max_money), init: 0
+
+    # Eject the change money
+    transition :idle => :dispensed_change do
+      guard  "Controller == rejected || Controller == done"
+      action "change := budget"
+    end
+
+  end
+
+  specify "The vending machine" do
+
+    it "allows the user to buy something" => :"EF value_in_products > 0"
+    it "always completes the transaction" => :"F User == done"
+
+    products.each { |product, value|
+      assuming "the product can be bough" => :"pocket_money >= #{value}" do
+        it "allows the user to buy #{product}" => :"EF Dispenser == dispensed_#{product}"
+      end
+    }
+
+  end
+
+  # hazard "The user looses money" => :"User == done && pocket_money + value_in_products < #{start_money}"
+  # hazard "The machine looses money" => :"User == done && pocket_money + value_in_products > #{start_money}"
+
+end

data/lib/pg-verify/cli/cli.rb

@@ -3,6 +3,7 @@ Dir[File.join(__dir__, '*.rb')].sort.each { |file| require file }
 
 require 'thor'
 require 'plantuml_builder'
+require 'json'
 
 module PgVerify
     module Cli
@@ -13,12 +14,24 @@ module PgVerify
             method_option :only, :type => :array, repeatable: true
             method_option :hide, :type => :array, repeatable: true
             method_option :script, :type => :string
+            method_option :"json-file", :type => :string
+            method_option :"yaml-file", :type => :string
+            # Hide labels or parts of labels
+            method_option :"hide-labels", :type => :boolean, default: false
+            method_option :"hide-precons", :type => :boolean, default: false
+            method_option :"hide-guards", :type => :boolean, default: false
+            method_option :"hide-actions", :type => :boolean, default: false
             def puml()
-                script_file = options[:script] || Settings.ruby_dsl.default_script_name
-                models = Interpret::PgScript.new.interpret(script_file)
+                render_options = {
+                    render_labels: !options[:"hide-labels"],
+                    render_precons: !options[:"hide-precons"],
+                    render_guards: !options[:"hide-guards"],
+                    render_actions: !options[:"hide-actions"]
+                }
+                models = CliUtils.load_models(options)
                 models.each { |model|
                     components = self.class.select_components(options[:only], options[:hide], model)
-                    puml = Transform::PumlTransformation.new.transform_graph(model, only: components)
+                    puml = Transform::PumlTransformation.new(render_options).transform_graph(model, only: components)
                     puts puml
                 }
             end
@@ -27,16 +40,28 @@ module PgVerify
             method_option :only, :type => :array, repeatable: true
             method_option :hide, :type => :array, repeatable: true
             method_option :script, :type => :string
+            method_option :"json-file", :type => :string
+            method_option :"yaml-file", :type => :string
+            # Hide labels or parts of labels
+            method_option :"hide-labels", :type => :boolean, default: false
+            method_option :"hide-precons", :type => :boolean, default: false
+            method_option :"hide-guards", :type => :boolean, default: false
+            method_option :"hide-actions", :type => :boolean, default: false
             def png()
-                script_file = options[:script] || Settings.ruby_dsl.default_script_name
-                models = Interpret::PgScript.new.interpret(script_file)
+                render_options = {
+                    render_labels: !options[:"hide-labels"],
+                    render_precons: !options[:"hide-precons"],
+                    render_guards: !options[:"hide-guards"],
+                    render_actions: !options[:"hide-actions"]
+                }
+
+                models = CliUtils.load_models(options)
 
                 models.each { |model|
                     components = self.class.select_components(options[:only], options[:hide], model)
-                    puml = Transform::PumlTransformation.new.transform_graph(model, only: components)
+                    puml = Transform::PumlTransformation.new(render_options).transform_graph(model, only: components)
                     png = PlantumlBuilder::Formats::PNG.new(puml).load
-                    out_name = File.basename(script_file, '.*')
-                    out_name += "-" + model.name.to_s.gsub(/\W+/, '_').downcase + ".png"
+                    out_name = model.name.to_s.gsub(/\W+/, '_').downcase + ".png"
                     out_path = File.expand_path(out_name, Settings.outdir)
                     FileUtils.mkdir_p(Settings.outdir)
                     File.binwrite(out_path, png)
@@ -46,9 +71,10 @@ module PgVerify
 
             desc "yaml", "Shows the model in YAML format"
             method_option :script, :type => :string
+            method_option :"json-file", :type => :string
+            method_option :"yaml-file", :type => :string
             def yaml()
-                script_file = options[:script] || Settings.ruby_dsl.default_script_name
-                models = Interpret::PgScript.new.interpret(script_file)
+                models = CliUtils.load_models(options)
 
                 models.each { |model| 
                     hash = Transform::HashTransformation.new.transform_graph(model)
@@ -58,9 +84,10 @@ module PgVerify
 
             desc "json", "Shows the model in Json format"
             method_option :script, :type => :string
+            method_option :"json-file", :type => :string
+            method_option :"yaml-file", :type => :string
             def json()
-                script_file = options[:script] || Settings.ruby_dsl.default_script_name
-                models = Interpret::PgScript.new.interpret(script_file)
+                models = CliUtils.load_models(options)
 
                 models.each { |model| 
                     hash = Transform::HashTransformation.new.transform_graph(model)
@@ -70,9 +97,10 @@ module PgVerify
 
             desc "nusmv", "Shows the model in NuSMV format"
             method_option :script, :type => :string
+            method_option :"json-file", :type => :string
+            method_option :"yaml-file", :type => :string
             def nusmv()
-                script_file = options[:script] || Settings.ruby_dsl.default_script_name
-                models = Interpret::PgScript.new.interpret(script_file)
+                models = CliUtils.load_models(options)
 
                 models.each { |model|
                     nusmv = Transform::NuSmvTransformation.new.transform_graph(model)
@@ -107,11 +135,16 @@ module PgVerify
 
             desc "test", "Test the model specifications"
             method_option :script, :type => :string
+            method_option :"json-file", :type => :string
+            method_option :"yaml-file", :type => :string
             def test()
-                script_file = options[:script] || Settings.ruby_dsl.default_script_name
-                models = Interpret::PgScript.new.interpret(script_file)
+                models = CliUtils.load_models(options)
 
                 models.each { |model|
+                    Shell::LoadingPrompt.while_loading("Checking for deadlocks") {
+                        NuSMV::Runner.new().run_check!(model); "ok"
+                    }
+
                     results = Shell::LoadingPrompt.while_loading("Running specifications") {
                         NuSMV::Runner.new().run_specs(model)
                     }
@@ -121,8 +154,8 @@ module PgVerify
                         puts "[ #{stat_string} ] #{result.spec.text}"
                         puts "           #{result.spec.expression.to_s.c_blue}"
                         unless result.success
-                            puts "Here is the trace:".c_red
-                            trace_s = result.trace.to_s.indented(str: " >> ".c_red)
+                            puts "           Here is a counter example:".c_red
+                            trace_s = result.trace.to_s.indented(str: "           >>  ".c_red)
                             puts trace_s + "\n"
                         end
                     }
@@ -131,11 +164,16 @@ module PgVerify
 
             desc "dcca", "Run the automatic DCCA for hazards of the model"
             method_option :script, :type => :string
+            method_option :"json-file", :type => :string
+            method_option :"yaml-file", :type => :string
             def dcca()
-                script_file = options[:script] || Settings.ruby_dsl.default_script_name
-                models = Interpret::PgScript.new.interpret(script_file)
+                models = CliUtils.load_models(options)
 
                 models.each { |model|
+                    Shell::LoadingPrompt.while_loading("Checking for deadlocks") {
+                        NuSMV::Runner.new().run_check!(model); "ok"
+                    }
+
                     dcca = Model::DCCA.new(model, NuSMV::Runner.new)
                     result = Shell::LoadingPrompt.while_loading("Calculating DCCA for #{model.name.to_s.c_string}") {
                         dcca.perform()
@@ -143,7 +181,8 @@ module PgVerify
                     result.each { |hazard, crit_sets|
                         s = crit_sets.length == 1 ? "" : "s"
                         message = "Hazard #{hazard.text.to_s.c_string} (#{hazard.expression.to_s.c_blue}) "
-                        message += "has #{crit_sets.length.to_s.c_num} minimal critical cut set#{s}:"
+                        message += "has #{crit_sets.length.to_s.c_num} minimal critical fault set#{s}:" if crit_sets.length > 0
+                        message += "has no minimal critical fault sets, meaning it is safe!".c_success if crit_sets.length == 0
                         puts message
                         crit_sets.each { |set|
                             puts "\t{ #{set.map(&:to_s).map(&:c_blue).join(', ')} }"
@@ -154,16 +193,33 @@ module PgVerify
 
             desc "simulate", "Simulate the model and save each step as an image"
             method_option :script, :type => :string
+            method_option :"json-file", :type => :string
+            method_option :"yaml-file", :type => :string
             method_option :steps, :type => :numeric, default: 10
             method_option :force, :type => :numeric, default: 10
             method_option :random, :type => :boolean, default: false
             method_option :png, :type => :boolean, default: false
+            # Hide labels or parts of labels
+            method_option :"hide-labels", :type => :boolean, default: false
+            method_option :"hide-precons", :type => :boolean, default: false
+            method_option :"hide-guards", :type => :boolean, default: false
+            method_option :"hide-actions", :type => :boolean, default: false
             def simulate()
-                script_file = options[:script] || Settings.ruby_dsl.default_script_name
-                models = Interpret::PgScript.new.interpret(script_file)
+                render_options = {
+                    render_labels: !options[:"hide-labels"],
+                    render_precons: !options[:"hide-precons"],
+                    render_guards: !options[:"hide-guards"],
+                    render_actions: !options[:"hide-actions"]
+                }
+
+                models = CliUtils.load_models(options)
                 runner = NuSMV::Runner.new
 
                 models.each { |model|
+                    Shell::LoadingPrompt.while_loading("Checking for deadlocks") {
+                        NuSMV::Runner.new().run_check!(model); "ok"
+                    }
+
                     trace = Shell::LoadingPrompt.while_loading("Simulating model #{model.name.to_s.c_string}") {
                         runner.run_simulation(model, options[:steps], random: options[:random])
                     }
@@ -181,7 +237,7 @@ module PgVerify
                     Shell::LoadingPrompt.while_loading("Rendering states") { |printer|
                         trace.states.each_with_index { |variable_state, index|
                             printer.printl("Step #{index + 1}/#{trace.states.length}")
-                            puml = Transform::PumlTransformation.new.transform_graph(model, variable_state: variable_state)
+                            puml = Transform::PumlTransformation.new(render_options).transform_graph(model, variable_state: variable_state)
                             png = PlantumlBuilder::Formats::PNG.new(puml).load
                             out_path = File.expand_path("step-#{index}.png", out_dir)
                             File.binwrite(out_path, png)

data/lib/pg-verify/cli/cli_utils.rb

@@ -0,0 +1,61 @@
+module PgVerify
+    class CliUtils
+        def self.load_models(options)
+            dsl_script_file = options[:script]
+            json_file       = options[:"json-file"]
+            yaml_file       = options[:"yaml-file"]
+            default_script_file = Settings.ruby_dsl.default_script_name
+
+            unless dsl_script_file.nil?
+                raise NoSuchFileError.new(dsl_script_file) unless File.file?(dsl_script_file)
+                return Interpret::PgScript.new.interpret(dsl_script_file)
+            end
+
+            unless json_file.nil?
+                raise NoSuchFileError.new(json_file) unless File.file?(json_file)
+                json_string = File.read(json_file)
+                array = JSON.load(json_string)
+                array = [ array ] unless array.is_a?(Array)
+                return array.map { |hash| Transform::HashTransformation.new.parse_graph(hash) }
+            end
+
+            unless yaml_file.nil?
+                raise NoSuchFileError.new(yaml_file) unless File.file?(yaml_file)
+                array = YAML.load_file(yaml_file)
+                array = [ array ] unless array.is_a?(Array)
+                return array.map { |hash| Transform::HashTransformation.new.parse_graph(hash) }
+            end
+
+            raise NoDefaultFileError.new(default_script_file) unless File.file?(default_script_file)
+            return Interpret::PgScript.new.interpret(default_script_file)
+        end
+
+    end
+
+    class NoSuchFileError < PgVerify::Core::Error
+        def initialize(path)
+            @path = path
+        end
+
+        def formatted()
+            title = "No such file!"
+            body = "There is no file at #{@path.c_file}!"
+            hint = "Make sure to specify another file or specify another path"
+            return title, body, hint
+        end
+    end
+
+    class NoDefaultFileError < PgVerify::Core::Error
+        def initialize(default_path)
+            @default_path = default_path
+        end
+        def formatted()
+            title = "Nothing to interpret!"
+            body  = "You didn't specify a file to interpret and there is no DSL script\n"
+            body += "at the default location: #{@default_path.c_file} (#{File.expand_path(@default_path).c_sidenote})"
+            hint = "Make sure to specify another file or specify another path"
+            return title, body, hint
+        end
+    end
+
+end

data/lib/pg-verify/interpret/component_context.rb

@@ -44,7 +44,7 @@ module PgVerify
                 range = hash[name]
                 raise "Variable name must be different to the component that owns it" if name.to_sym == @name
                 raise InvalidDSL_var.new("Name '#{name}' is not a symbol") unless name.is_a?(Symbol)
-                raise InvalidDSL_var.new("Range '#{range}' is not a range or array") unless range.is_a?(Range) && range.first.is_a?(Integer)
+                raise InvalidDSL_var.new("Range '#{range}' is not a range or array") unless (range.is_a?(Range) || range.is_a?(Array)) && range.first.is_a?(Integer)
                 sloc = @parent_graph.parent_script.find_source_location()
                 variable = Model::Variable.new(name, range, @name, sloc)
 

data/lib/pg-verify/interpret/interpret.rb

@@ -117,7 +117,7 @@ module PgVerify
             def formatted()
                 title = "No such state #{@state} in component #{@component.name}"
                 body = "The component #{@component.name.to_s.c_cmp} does not contain a state called #{@state.to_s.c_state}.\n"
-                body += "Available states are: #{@component.states.map(&:to_s).map(&:c_state).join(', ')}"
+                body += "Available states are: #{@component.states&.map(&:to_s)&.map(&:c_state)&.join(', ')}"
                 hint = "Make sure to define states before defining transitions."
                 return title, body, hint
             end

data/lib/pg-verify/interpret/pg_script.rb

@@ -15,6 +15,7 @@ module PgVerify
             end
         
             def interpret(file, validate: true)
+                raise "Not a file path string: '#{file}'::#{file.class}" unless file.is_a?(String)
                 file = File.expand_path(file)
                 raise NoSuchScriptError.new(file) unless File.file?(file)
                 @script_file ||= file

data/lib/pg-verify/model/parsed_expression.rb

@@ -20,6 +20,8 @@ module PgVerify
             TYPE_CTL = :ctl
 
             TYPES = [ TYPE_GUARD, TYPE_ACTION, TYPE_TERM, TYPE_PL, TYPE_TL, TYPE_LTL, TYPE_CTL ]
+            LTL_KEYWORDS = "GFXRU".chars
+            CTL_KEYWORDS = [ "A", "E" ].product([ "G", "F", "X", "U" ]).map { |a, e| "#{a}#{e}" }
 
             attr_accessor :expression_string
             attr_accessor :source_location
@@ -36,11 +38,18 @@ module PgVerify
 
             def word_tokens()
                 words = expression_string.scan(/[a-zA-Z_][a-zA-Z0-9_]*/).flatten.compact
-                words = words.reject { |w| w.match(/\A[GFXRU]+\z/) }
+                words = words.reject { |w| LTL_KEYWORDS.include?(w) }
+                words = words.reject { |w| CTL_KEYWORDS.include?(w) }
                 words = words.reject { |w| w == "TRUE" || w == "FALSE" }
                 return words.map(&:to_sym)
             end
 
+            def predict_type()
+                return @type unless @type == :tl
+                tokens = self.tokenize()
+                return CTL_KEYWORDS.any? { |kw| tokens.include?(kw) } ? :ctl : :ltl
+            end
+
             # Splits the expression string into an array of tokens. e.g:
             # "(a == b) && 3 >= 2" becomes [ "(", "a", "==", "b", ")", "&&", "3", ">=", "2" ]
             # Note that this split method very much a hack at the moment
@@ -56,10 +65,6 @@ module PgVerify
                 }.flatten.reject(&:blank?)
             end
 
-            def used_variables()
-                return expression_string.scan(/[a-zA-Z_][a-zA-Z0-9_]*/).flatten.compact.map(&:to_sym)
-            end
-
             def to_s()
                 @expression_string
             end

data/lib/pg-verify/model/simulation/trace.rb

@@ -5,12 +5,14 @@ module PgVerify
 
             attr_accessor :model
             attr_accessor :states
+            attr_accessor :loop_index
 
-            def initialize(model, states)
+            def initialize(model, states, loop_index: -1)
                 @model, @states = model, states
+                @loop_index = loop_index
             end
 
-            def to_s()
+            def to_s(include_steps: true)
                 return "No states in trace" if @states.empty?
                 # Get all variables (TODO: Bring into sensible order)
                 vars = @states.first.keys
@@ -18,10 +20,17 @@ module PgVerify
 
                 parts = vars.map { |var| 
                     var_string = state_vars.varname?(var) ? var.to_s.c_state.c_bold : var.to_s.c_string
-                    var_string + "\n" + @states.each_with_index.map{ |state, index| value_str(var, state[var], index) }.join("\n") 
+                    var_string + "\n" + @states.each_with_index.map{ |state, index| value_str(var, state[var], index) }.join("\n")
                 }
                 str = "Step".c_num.c_bold + "\n" + (0...@states.length).map { |i| "#{i + 1}" } .join("\n")
+                str = "" unless include_steps
                 parts.each { |part| str = str.line_combine(part, separator: "  ") }
+
+                unless @loop_index.nil? || @loop_index < 0
+                    loop_str = (0...@states.length).map { |i| i == @loop_index + 1 ? "<- loop".c_blue : "" } .join("\n")
+                    str = str.line_combine(loop_str, separator: "  ")
+                    str += "\n" + "Loop starts at #{@loop_index + 1}".c_sidenote
+                end
                 
                 return str
             end
@@ -30,7 +39,9 @@ module PgVerify
                 return value.c_green if [ "On", "Yes", "Active" ].include?(value)
                 return value.c_red if [ "Off", "No", "Idle" ].include?(value)
 
-                settings_color = Settings.trace.colors[value.to_s]
+
+                settings_color = Settings.trace.colors.find { |key, val| File.fnmatch?(key.to_s, value) }
+                settings_color = settings_color[1] unless settings_color.blank?
                 return value.send(:"c_#{settings_color}") unless settings_color.blank?
 
                 return "#{value}" 

data/lib/pg-verify/model/validation/errors.rb

@@ -27,8 +27,8 @@ module PgVerify
                     title = "Unknown token"
                     
                     body = []
-                    body << @expression.source_location.to_s.c_sidenote  unless @expression.source_location.blank?
-                    body << @expression.source_location.render_code_block() unless @expression.source_location.blank?
+                    body << @expression.source_location.to_s.c_sidenote  unless @expression.source_location.nil?
+                    body << @expression.source_location.render_code_block() unless @expression.source_location.nil?
                     body << ""
                     body << "The expression '#{@expression.to_s.c_expression}' uses token #{@token.to_s.c_string}."
                     body << "This is neither a known variable, nor literal."
@@ -114,6 +114,25 @@ module PgVerify
                 end
             end
 
+            class DeadlockInFSMError < PgVerify::Core::Error
+                def initialize(program_graph, deadlock_state)
+                    @program_graph, @deadlock_state = program_graph, deadlock_state
+                end
+                def formatted()
+                    trace = Model::Trace.new(@program_graph, [@deadlock_state])
+
+                    title = "Deadlock in program graph #{@program_graph.name}"
+                    body = "The following state has no successor:\n\n"
+                    body += trace.to_s(include_steps: false).indented(str: ">>  ".c_error)
+
+                    hint = []
+                    hint << "This indicates a range violation:"
+                    hint << "Once your graph is in the mentioned state (which is reachable),"
+                    hint << "all outgoing transitions are blocked due to variable range violations."
+                    return title, body, hint.join("\n")
+                end
+            end
+
         end
     end
 end