pg-verify 0.1.0

data/integration_tests/ruby_dsl/006_state_variables.rb

@@ -0,0 +1,26 @@
+model :TestAction do
+    graph :Engine do
+        states :running, :stopped
+    end
+    graph :Car do
+        states :accelerating, :decelerating
+
+        transition :accelerating => :decelerating do
+            guard "Engine == stopped"
+        end
+        transition :decelerating => :decelerating do
+            guard "Engine == stopped"
+        end
+        transition :accelerating => :accelerating do
+            guard "Engine == running"
+        end
+        transition :decelerating => :accelerating do
+            guard "Engine == running"
+        end
+
+    end
+    specify "The car" do
+        it "accelerates when the engine is running" => :"G (Engine == running => X Car == accelerating)"
+        it "decelerates when the engine isn't running" => :"G (Engine != running => X Car == decelerating)"
+    end
+end

data/integration_tests/ruby_dsl/007_variable_initialization.rb

@@ -0,0 +1,28 @@
+model :TestAction do
+    graph :Test do
+        state :idle
+        var a: (0..1), init: 0
+        var b: (0..1), init: "b == 0"
+        var c: (-1..2), init: "c > 0 && c < 2"
+        var d: (0..10), init: "d == c + c + c"
+
+        var u: (0..10)
+        init "u == 2" 
+
+        var x: (0..10), init: "x >= 5 && x <= 7"
+        var y: (0..10), init: "y = x + 1"
+        var z: (0..1)
+    end
+    specify "The variable" do
+        it "a is initialized to 0" => :"a == 0"
+        it "b is initialized to 0" => :"b == 0"
+        it "c is initialized to 1" => :"c == 1"
+        it "d is initialized to 3" => :"d == 3"
+
+        it "u is initialized to 2" => :"u == 2"
+
+        it "x is initialized to either 5, 6 or 7" => :"x == 5 || x == 6 || x == 7"
+        it "y is initialized to either 6, 7 or 8" => :"y == 6 || y == 7 || y == 8"
+        it "z is either 0 or 1" => :"z == 0 || z == 1"
+    end
+end

data/integration_tests/ruby_dsl/008_state_initialization.rb

@@ -0,0 +1,19 @@
+model :TestAction do
+
+    graph :GraphZero do
+        states :a, :b, :c
+    end
+    graph :GraphOne do
+        states :a, :b, :c
+        init "GraphOne == a || GraphOne == b"
+    end
+    graph :GraphTwo do
+        states :a, :b, :c, init: :a
+    end
+
+    specify "The graph" do
+        it "GraphZero starts in a or b or c" => :"GraphOne == a || GraphOne == b || GraphOne == c"
+        it "GraphOne starts in a or b"       => :"GraphOne == a || GraphOne == b"
+        it "GraphTwo starts in a"            => :"GraphTwo == a"
+    end
+end

data/integration_tests/ruby_dsl/009_shared_variables.rb

@@ -0,0 +1,26 @@
+model :TestAction do
+
+    graph :Car do
+        var distance_to_wall: (0..10), init: 0
+
+        states :DrivingRelentlessly
+
+        transition :DrivingRelentlessly => :DrivingRelentlessly do
+            precon "distance_to_wall > 0"
+            action "distance_to_wall := distance_to_wall - 1"
+        end
+    end
+    graph :CrashDetector do
+        states :no_crash, :crash, init: :no_crash
+
+        transition :no_crash => :crash do
+            guard "distance_to_wall == 0"
+        end
+
+    end
+
+    specify "The car" do
+        it "starts out driving" => :"CrashDetector == no_crash && Car == DrivingRelentlessly"
+        it "crashes horribly" => :"F CrashDetector == crash"
+    end
+end

data/integration_tests/ruby_dsl/010_complex_guards.rb

@@ -0,0 +1,18 @@
+model :TestAction do
+    graph :Test do
+        var a: (0..10), init: 0
+        var b: (0..10), init: 10
+
+        states :initial, :second ,init: :initial
+        transition :initial => :second do
+            guard "b > 5 && a + 1 == 1 && a != b && Other == second"
+        end
+    end
+    graph :Other do
+        states :initial, :second, init: :initial
+        transition :initial => :second
+    end
+    specify "The Test" do
+        it "does reach the second state" => :"X X Test == second"
+    end
+end

data/integration_tests/ruby_dsl/011_complex_actions.rb

@@ -0,0 +1,16 @@
+model :TestAction do
+    graph :Test do
+        var a: (0..11), init: 0
+        var b: (0..100), init: 0
+
+        states :go
+        transition :go => :go do
+            guard "a < 11"
+            action "a := a + 1 | b := a * a"
+        end
+    end
+    specify "The variable" do
+        it "a reaches 10" => :"F a == 10"
+        it "b reaches 100" => :"F b == 100"
+    end
+end

data/integration_tests/ruby_dsl/012_error_components.rb

@@ -0,0 +1,9 @@
+model :Test do
+
+    transient  error :TransientError
+    persistent error :PersistentError
+    
+    specify "The persistent error" do
+        it "Stays persistent" => :"G ( PersistentError == Yes => ( ! F PersistentError == No ) )"
+    end
+end

data/integration_tests/ruby_dsl/013_hazards.rb

@@ -0,0 +1,25 @@
+model :Test do
+
+    persistent error :BreakFailure
+
+    graph :Car do
+        states :driving
+        var distance_to_wall: (0..10), init: 9
+
+        transition :driving => :driving do
+            precon "distance_to_wall > 0"
+            guard  "distance_to_wall > 5 || BreakFailure == Yes"
+            action "distance_to_wall := distance_to_wall - 1"
+        end
+
+    end
+
+    # Expected Cut Sets: { BreakFailure }
+    hazard "The car crashes" => :"distance_to_wall == 0"
+
+    specify "The car" do
+        assuming "the breaks don't fail" => :"G BreakFailure = No" do
+            it "does not crash" => :"G distance_to_wall > 0"
+        end
+    end
+end

data/integration_tests/ruby_dsl/014_tau_transitions.rb

@@ -0,0 +1,26 @@
+model :Test do
+
+    graph :Graph1 do
+        var counter: (0..5), init: 0
+        states :counting
+        transition :counting => :counting do
+            precon "counter < 5"
+            action "counter := counter + 1"
+        end
+    end
+
+    graph :Graph2 do
+        states :idle
+    end
+
+    specify "The counter" do
+        it "Goes to 0" => :"counter == 0"
+        it "Goes to 1" => :"X counter == 1"
+        it "Goes to 2" => :"X X counter == 2"
+        it "Goes to 3" => :"X X X counter == 3"
+        it "Goes to 4" => :"X X X X counter == 4"
+        it "Goes to 5" => :"X X X X X counter == 5"
+        it "Stays at 5" => :"X X X X X X X X counter == 5"
+        it "reaches 5" => :"F counter == 5"
+    end
+end

data/integration_tests/ruby_dsl/015_basic_dcca.rb

@@ -0,0 +1,19 @@
+model :TestTransitions do
+
+    transient error :Err1
+    transient error :Err2
+    transient error :Err3
+    transient error :Err4
+    transient error :Err5
+    
+    graph :OhNo do
+        states :Ok, :Bad, init: :Ok
+        transition :Ok => :Bad do
+            guard "(Err1 == Yes && Err2 == Yes && Err3 == Yes ) || (Err4 == Yes && Err5 == Yes)"
+        end
+    end
+
+    # Expected Cut Sets: { Err1, Err2, Err3 } { Err4, Err5 }
+    hazard "Bad" => :"OhNo == Bad"
+
+end

data/integration_tests/ruby_dsl/016_pressure_tank.rb

@@ -0,0 +1,146 @@
+model :PressureTank do
+
+    transient  error :SwitchOperatedBadly
+    persistent error :SensorDead
+    # Relay is jammed if it does not open when wanted
+    persistent error :Relay1Jammed
+    persistent error :Relay2Jammed
+
+    # S1
+    graph :Switch do
+        states :Start, :Closed, :Open, init: :Start
+    
+        # Randomly close at some point
+        transition :Start => :Start
+        transition :Start => :Closed
+
+        # Open right after closing (unless error)
+        transition :Closed => :Open do
+            guard "SwitchOperatedBadly == No"
+        end
+
+        # Close again if error
+        transition :Open => :Closed do
+            guard "SwitchOperatedBadly == Yes"
+        end
+    end
+
+    # T
+    graph :Timer do
+        states :Closed, :Open, :Countdown, init: :Closed
+
+        var time: (0..60), init: 0
+
+        countdown_requirement = "Sensor == Closed && ( Switch == Closed || Relay2 == Closed )"
+
+        transition :Closed => :Countdown do
+            guard countdown_requirement
+        end
+        transition :Countdown => :Countdown do
+            guard "#{countdown_requirement} && time < 60"
+            action "time := time + 1"
+        end 
+
+        transition :Countdown => :Open do
+            guard "#{countdown_requirement} && time = 60"
+            action "time := 0"
+        end
+
+        transition :Open => :Closed
+
+    end
+
+    # D
+    graph :Tank do
+        states :Functional, :Raptured, init: :Functional
+        var pressure: (0..70), init: 0
+
+        transition :Functional => :Functional do
+            guard "Motor == On"
+            action "pressure := pressure + 1"
+        end
+        transition :Functional => :Functional do
+            guard "Motor == Off"
+            action "pressure := 0"
+        end
+        transition :Functional => :Raptured do
+            guard "Motor == On && pressure > 65"
+            action "pressure := 0"
+        end
+    end
+
+    # M
+    graph :Motor do
+        states :Off, :On, init: :Off
+
+        # Motor turns on/off if relay 2 delivers power or doesn't
+        transition :Off => :On do
+            guard "Relay2 == Closed"
+        end
+        transition :On => :Off do
+            guard "Relay2 == Open"
+        end
+    end
+
+    # S
+    graph :Sensor do
+        states :Closed, :Open, init: :Closed
+
+        # Trigger when tank is full (unless dead)
+        transition :Closed => :Open do
+            guard "pressure >= 60 && SensorDead == No"
+        end
+        # Stop triggering when tank is empty
+        transition :Open => :Closed do
+            guard "pressure < 60"
+        end
+    end
+
+    # K1
+    graph :Relay1 do
+        states :Closed, :Open, init: :Open
+
+        transition :Closed => :Open do
+            guard "Timer == Open && Relay1Jammed == No"
+        end
+        transition :Open => :Closed do
+            guard "Timer != Open && Switch == Closed"
+        end
+    end
+
+    # K2
+    graph :Relay2 do
+        states :Closed, :Open, init: :Open
+
+        close_requirement = "Switch == Closed || ( Relay1 == Closed && Sensor == Closed )"
+
+        transition :Open => :Closed do
+            guard close_requirement
+        end
+
+        transition :Closed => :Open do
+            guard "! ( #{close_requirement} ) && Relay2Jammed == No"
+        end
+        
+    end
+
+    specify "The tank" do
+        assuming no_errors do
+            assuming "the switch is pressed" => :"F Switch == Closed" do
+                it "will be pressured" => :"F pressure == 60"
+                it "will be depressured again" => :"F (pressure == 60 && F pressure == 0)"
+            end
+            it "does not rapture" => :"! F Tank == Raptured"
+        end
+    end
+
+    specify "The switch" do
+        assuming "no fault" => :"G ( SwitchOperatedBadly == No )" do
+            it "is only pressed once" => :"G ( Switch == Closed => X (! F Switch == Closed ))"
+        end
+    end
+
+    # Expected Cut Sets: { SwitchOperatedBadly } { Relay2Jammed } { SensorDead, Relay1Jammed }
+    hazard "The tank raptures" => :"Tank == Raptured"
+
+end

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

@@ -0,0 +1,235 @@
+# Require all module files
+Dir[File.join(__dir__, '*.rb')].sort.each { |file| require file }
+
+require 'thor'
+require 'plantuml_builder'
+
+module PgVerify
+    module Cli
+
+        class ShowCommand < Thor
+
+            desc "puml", "Shows the model in PlantUML format"
+            method_option :only, :type => :array, repeatable: true
+            method_option :hide, :type => :array, repeatable: true
+            method_option :script, :type => :string
+            def puml()
+                script_file = options[:script] || Settings.ruby_dsl.default_script_name
+                models = Interpret::PgScript.new.interpret(script_file)
+                models.each { |model|
+                    components = self.class.select_components(options[:only], options[:hide], model)
+                    puml = Transform::PumlTransformation.new.transform_graph(model, only: components)
+                    puts puml
+                }
+            end
+
+            desc "png", "Shows the model as a PNG image"
+            method_option :only, :type => :array, repeatable: true
+            method_option :hide, :type => :array, repeatable: true
+            method_option :script, :type => :string
+            def png()
+                script_file = options[:script] || Settings.ruby_dsl.default_script_name
+                models = Interpret::PgScript.new.interpret(script_file)
+
+                models.each { |model|
+                    components = self.class.select_components(options[:only], options[:hide], model)
+                    puml = Transform::PumlTransformation.new.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_path = File.expand_path(out_name, Settings.outdir)
+                    FileUtils.mkdir_p(Settings.outdir)
+                    File.binwrite(out_path, png)
+                    puts "Wrote #{out_path.c_file}"
+                }
+            end
+
+            desc "yaml", "Shows the model in YAML format"
+            method_option :script, :type => :string
+            def yaml()
+                script_file = options[:script] || Settings.ruby_dsl.default_script_name
+                models = Interpret::PgScript.new.interpret(script_file)
+
+                models.each { |model| 
+                    hash = Transform::HashTransformation.new.transform_graph(model)
+                    puts hash.to_yaml
+                }
+            end
+
+            desc "json", "Shows the model in Json format"
+            method_option :script, :type => :string
+            def json()
+                script_file = options[:script] || Settings.ruby_dsl.default_script_name
+                models = Interpret::PgScript.new.interpret(script_file)
+
+                models.each { |model| 
+                    hash = Transform::HashTransformation.new.transform_graph(model)
+                    puts JSON.pretty_generate(hash)
+                }
+            end
+
+            desc "nusmv", "Shows the model in NuSMV format"
+            method_option :script, :type => :string
+            def nusmv()
+                script_file = options[:script] || Settings.ruby_dsl.default_script_name
+                models = Interpret::PgScript.new.interpret(script_file)
+
+                models.each { |model|
+                    nusmv = Transform::NuSmvTransformation.new.transform_graph(model)
+                    puts nusmv
+                }
+            end
+
+            def self.select_components(only_arg, hide_arg, model)
+                only = (only_arg || []).flatten.map(&:to_s).map(&:downcase)
+                hide = (hide_arg || []).flatten.map(&:to_s).map(&:downcase)
+                components = model.components.map(&:name)
+                components = components.select { |c| only.include?(c.to_s.downcase) } unless only.empty?
+                components = components.reject { |c| hide.include?(c.to_s.downcase) } unless hide.empty?
+                return components
+            end
+
+        end
+
+        class BaseCommand < Thor
+
+            desc "test", "Test the model specifications"
+            method_option :script, :type => :string
+            def test()
+                script_file = options[:script] || Settings.ruby_dsl.default_script_name
+                models = Interpret::PgScript.new.interpret(script_file)
+
+                models.each { |model|
+                    results = Shell::LoadingPrompt.while_loading("Running specifications") {
+                        NuSMV::Runner.new().run_specs(model)
+                    }
+
+                    results.each { |result|
+                        stat_string = result.success ? "PASSED".c_success : "FAILED".c_error
+                        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 trace_s + "\n"
+                        end
+                    }
+                }
+            end
+
+            desc "dcca", "Run the automatic DCCA for hazards of the model"
+            method_option :script, :type => :string
+            def dcca()
+                script_file = options[:script] || Settings.ruby_dsl.default_script_name
+                models = Interpret::PgScript.new.interpret(script_file)
+
+                models.each { |model|
+                    dcca = Model::DCCA.new(model, NuSMV::Runner.new)
+                    result = Shell::LoadingPrompt.while_loading("Calculating DCCA for #{model.name.to_s.c_string}") {
+                        dcca.perform()
+                    }
+                    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}:"
+                        puts message
+                        crit_sets.each { |set|
+                            puts "\t{ #{set.map(&:to_s).map(&:c_blue).join(', ')} }"
+                        }
+                    }
+                }
+            end
+
+            desc "simulate", "Simulate the model and save each step as an image"
+            method_option :script, :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
+            def simulate()
+                script_file = options[:script] || Settings.ruby_dsl.default_script_name
+                models = Interpret::PgScript.new.interpret(script_file)
+                runner = NuSMV::Runner.new
+
+                models.each { |model|
+                    trace = Shell::LoadingPrompt.while_loading("Simulating model #{model.name.to_s.c_string}") {
+                        runner.run_simulation(model, options[:steps], random: options[:random])
+                    }
+
+                    # Print the trace
+                    puts trace.to_s
+
+                    next unless options[:png]
+
+                    # Prepare output dir
+                    out_dir = File.expand_path("simulate-" + model.name.to_s.gsub(/\W+/, '_').downcase, Settings.outdir)
+                    FileUtils.mkdir_p(out_dir)
+
+                    # Generate images
+                    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)
+                            png = PlantumlBuilder::Formats::PNG.new(puml).load
+                            out_path = File.expand_path("step-#{index}.png", out_dir)
+                            File.binwrite(out_path, png)
+                        }
+                    }
+                    puts "Wrote #{trace.states.length.to_s.c_num} files to #{out_dir.c_file}"
+                }
+
+            end
+
+            desc "init", "Initialize a new pg-verify project"
+            method_option :directory, :type => :string
+            def init()
+
+                target = options[:directory].blank? ? Dir.pwd() : File.expand_path(options[:directory])
+                if Dir.exist?(target) && Dir.entries(target).size > 2
+                    puts "The target directory #{target.c_file} isn't empty!"
+                    exit 1
+                end
+
+                # Create target dir
+                FileUtils.mkdir_p(target)
+
+                # Copy files to target
+                template_dir = File.join(PgVerify.root, "data", "project-template")
+                files = Dir.glob(File.join(template_dir, '**', '*'), File::FNM_DOTMATCH).select { |f| File.file?(f) }
+                files.each { |f| 
+                    target_file = File.join(target, f.sub(template_dir, ""))
+                    target_file = target_file.gsub(".resource", "")
+                    FileUtils.mkdir_p(File.dirname(target_file))
+                    FileUtils.cp(f, target_file) unless File.basename(f) == ".keep"
+                }
+                # Copy the actual default config into the project as that
+                # will contain all keys and should be commented
+                FileUtils.cp(File.join(PgVerify.root, "data", "config", "pg-verify.yml"), File.join(target, ".pg-verify.yml"))
+
+                # Initialize git project
+                Dir.chdir(target) { 
+                    Core::CMDRunner.run_cmd("git init")
+                    Core::CMDRunner.run_cmd("git add .")
+                    Core::CMDRunner.run_cmd("git commit -m \"Initial Commit\"")
+                }
+
+                puts "Successfully initialized project at #{target.c_file}!"
+                puts "You can read the #{'README.md'.c_file} to get started."
+                puts "Run #{'pg-verify doctor'.c_blue} and follow the instructions to set up your environment!"
+            end
+
+            desc "doctor", "Check for common problems"
+            def doctor()
+                Doctor.check()
+            end
+
+            desc "show", "Show the program graph multiple different ways"
+            subcommand 'show', ShowCommand
+
+            # Make Thor exit with non-0 in case of errors
+            def self.exit_on_failure?(); true end
+
+        end
+
+    end
+end