pg-verify 0.1.0

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

@@ -0,0 +1,18 @@
+module PgVerify
+    module Model
+        module Validation
+
+            module EmptyStateSetValidation
+
+                def self.validate(model)
+                    errors = model.components.map { |cmp|
+                        next if cmp.states.length > 0
+                        EmptyStateSetError.new(cmp)
+                    }.compact
+                    return errors
+                end
+                
+            end
+        end
+    end
+end

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

@@ -0,0 +1,119 @@
+module PgVerify
+    module Model
+        module Validation
+
+            class ValidationError < PgVerify::Core::Error
+                def initialize(model, errors)
+                    @model, @errors = model, errors
+                end
+
+                def formatted()
+                    title = "There are #{@errors.length} errors for model #{@model.name}"
+
+                    summary = @errors.map{ |e| e.formatted.first }
+                    summary = summary.each_with_index.map { |e, i| "#{i + 1}: #{e}" }.join("\n")
+
+                    body = @errors.map(&:to_formatted).join("\n")
+                    return title, "#{summary}\n\n#{body}"
+                end
+
+            end
+
+            class UnknownTokenError < PgVerify::Core::Error
+                def initialize(token, expression, varset)
+                    @token, @expression, @varset = token, expression, varset
+                end
+                def formatted()
+                    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 << ""
+                    body << "The expression '#{@expression.to_s.c_expression}' uses token #{@token.to_s.c_string}."
+                    body << "This is neither a known variable, nor literal."
+                    body << "Known variables: #{@varset.names.map(&:to_s).map(&:c_var).join(", ")}"
+                    body << "Known literals: #{@varset.values.reject{ |v| v.is_a?(Numeric) }.map(&:to_s).map(&:c_literal).join(", ")}"
+                    
+                    return title, body.join("\n")
+                end
+            end
+
+            class UnknownVariableError <  PgVerify::Core::Error
+                def initialize(assigned_variable, assignment_expression, var_set)
+                    @assigned_variable, @assignment_expression, @var_set = assigned_variable, assignment_expression, var_set
+                end
+                def formatted()
+                    title = "Unknown variable '#{@assigned_variable}'"
+                    
+                    body = []
+                    body << @assignment_expression.source_location.to_s.c_sidenote
+                    body << @assignment_expression.source_location.render_code_block()
+                    body << ""
+                    body << "The expression '#{@assignment_expression.to_s.c_expression}' uses variable #{@assigned_variable.to_s.c_var}."
+                    body << "However there is no such variable in the context of this model."
+                    body << "Known variables: #{@var_set.names.map(&:to_s).map(&:c_var).join(', ')}."
+    
+                    hint = "Declare variables before using them in expressions"
+    
+                    return title, body.join("\n"), hint
+                end
+            end
+
+            class ForeignVariableAssignmentError <  PgVerify::Core::Error
+                def initialize(variable, expression, varset, component)
+                    @variable, @expression, @varset = variable, expression, varset
+                    @component = component
+                end
+                def formatted()
+                    title = "Foreign variable assignment"
+                    
+                    body = []
+                    body << @expression.source_location.to_s.c_sidenote
+                    body << @expression.source_location.render_code_block()
+                    body << ""
+                    body << "Component #{@component.name.to_s.c_cmp} assigns a value to variable #{@variable.to_s.c_var},"
+                    body << "using this expression '#{@expression.to_s.c_expression}'."
+                    body << "However #{@variable.to_s.c_var} is owned by component #{@varset[@variable].owner_name.to_s.c_cmp}"
+    
+                    hint = "A variable can only be written to by the component which declared it"
+    
+                    return title, body.join("\n"), hint
+                end
+            end
+
+            class AssignmentToStateVariableError < PgVerify::Core::Error
+                def initialize(variable, expression, varset)
+                    @variable, @expression, @varset = variable, expression, varset
+                end
+                def formatted()
+                    title = "Assignment to state variable"
+                    
+                    body = []
+                    body << @expression.source_location.to_s.c_sidenote
+                    body << @expression.source_location.render_code_block()
+                    body << ""
+                    body << "The expression '#{@expression.to_s.c_expression}' assigns a value to variable #{@variable.to_s.c_var}."
+                    body << "However this variable is a state variable and can not be written to."
+    
+                    hint = "State variables are read only"
+    
+                    return title, body.join("\n"), hint
+                end
+            end
+
+            class EmptyStateSetError < PgVerify::Core::Error
+                def initialize(component)
+                    @component = component
+                end
+                def formatted()
+                    title = "Empty state set"
+                    body = "The graph component '#{@component.name.to_s.c_cmp}' does not define any states."
+                    hint = "Each graph component needs at least one state"
+                    return title, body, hint
+                end
+            end
+
+        end
+    end
+end

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

@@ -0,0 +1,30 @@
+module PgVerify
+    module Model
+        module Validation
+
+            module ForeignAssignmentValidation
+
+                def self.validate(model)
+                    errors = []
+                    varset = model.all_variables()
+
+                    model.components.each { |component|
+                        actions = component.transitions.map(&:action).compact
+                        actions.each { |a|
+                            var_strings = a.assigned_variables()
+                            # Null values (variable not known is not an error for this validation)
+                            vars = var_strings.map { |vs| varset[vs] }.compact
+                            vars.map { |var|
+                                next if var.owner_name == component.name
+                                errors << ForeignVariableAssignmentError.new(var.name, a, varset, component)
+                            }
+                        }
+                    }
+                    return errors
+                end
+
+            end
+
+        end
+    end
+end

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

@@ -0,0 +1,35 @@
+module PgVerify
+    module Model
+        module Validation
+
+            module UnknownTokenValidation
+
+                def self.validate(model)
+                    errors = []
+                    varset = model.all_variables()
+                    transitions = model.components.map(&:transitions).flatten
+                    transitions.each { |tx|
+                        errors += validate_expression(varset, tx.precon)
+                        errors += validate_expression(varset, tx.guard)
+                        errors += validate_expression(varset, tx.action)
+
+                    }
+                    return errors
+                end
+
+                def self.validate_expression(varset, expression)
+                    return [] if expression.nil?
+                    tokens = expression.word_tokens()
+                    tokens = tokens.reject { |token|
+                        varset.varname?(token) || varset.constname?(token)
+                    }
+                    return tokens.map { |token|
+                        UnknownTokenError.new(token, expression, varset)
+                    }
+                end
+
+            end
+
+        end
+    end
+end

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

@@ -0,0 +1,23 @@
+module PgVerify
+    module Model
+        module Validation
+
+            def self.validate(model)
+                errors = []
+                errors += EmptyStateSetValidation.validate(model)
+                errors += UnknownTokenValidation.validate(model)
+                errors += ForeignAssignmentValidation.validate(model)
+                errors += AssignmentToStateVariableValidation.validate(model)
+                return errors
+            end
+
+            def self.validate!(model)
+                errors = validate(model)
+                return if errors.empty?
+                raise ValidationError.new(model, errors)
+            end
+
+        end
+
+    end
+end

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

@@ -0,0 +1,47 @@
+module PgVerify
+    module Model
+
+        class Variable
+
+            # Name of this variable as a symbol
+            attr_accessor :name
+
+            # The name of the component which owns this variable as a symbol
+            attr_accessor :owner_name
+
+            # Range of this variable. This can either be a range like (0..2)
+            # an array of numbers like [0, 1, 2] or an array of symbols representing
+            # states of components like [:Idle, :Breaking]
+            attr_accessor :range
+
+            # An expression to be used to initialize this variable
+            # While this can be something simple like "my_var = 10", it can
+            # also be something more involved like "my_var > 10 && my_var < 15".
+            attr_accessor :init_expression
+
+            # The location in source, where this variable was defined
+            attr_accessor :source_location
+
+            def initialize(name, range, owner_name, source_location, init: nil)
+                init = Model::ParsedExpression.new(init, Model::ParsedExpression::TYPE_PL) if init.is_a?(String)
+                @name, @range, @owner_name, @init_expression = name, range, owner_name, init
+                @source_location = source_location
+            end
+
+            # Returns all possible values of this variable as an array
+            def values()
+                return @range if @range.is_a?(Array)
+                return @range.to_a
+            end
+
+            # A state variable represents the states of a component.
+            # e.g: Switch with range [:on, :off] for component switch.
+            def state_variable?()
+                return @name == @owner_name
+            end
+
+        end
+
+    end
+
+end

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

@@ -0,0 +1,84 @@
+
+module PgVerify
+    module Model
+
+        class VariableSet
+
+            attr_accessor :map
+
+            def initialize(*variables)
+                @map = {}
+                self << variables
+            end
+
+            def <<(var)
+                return @map[var.name] = var if var.is_a?(Variable)
+                return var.map { |v| self << v } if var.is_a?(Array)
+                raise "Not a variable '#{var}'"
+            end
+
+            def get(*names)
+                return names.map { |n| self[n] }
+            end
+
+            def +(varset)
+                varset = VariableSet.new(*varset) if varset.is_a?(Array)
+                raise "Not a variable set '#{varset}'" unless varset.is_a?(VariableSet)
+                return VariableSet.new(*(self.to_a() + varset.to_a()))
+            end
+
+            def to_a()
+                return @map.values()
+            end
+
+            def names()
+                return @map.keys()
+            end
+
+            def [](name)
+                name = name.to_sym
+                raise "No such variable #{name}!" unless @map.key?(name)
+                return @map[name]
+            end
+
+            def include?(name_or_var)
+                return varname?(name_or_var) || constname?(name_or_var)
+            end
+
+            def empty?()
+                return @map.empty?
+            end
+
+            def map(&blk)
+                return @map.values.map(&blk)
+            end
+
+            def varname?(name)
+                return @map.key?(name.to_sym)
+            end
+
+            def constname?(name)
+                values().map(&:to_s).include?(name.to_s)
+            end
+
+            def to_s()
+                return "{#{@map.map { |name, var| "#{name}:#{var.range}(#{var.owner_name})" }.join(", ")}}"
+            end
+
+            def select_by_owner(owner)
+                owner = owner.name if owner.is_a?(Model::Component)
+                owner = owner.to_sym if owner.is_a?(String)
+                found = self.to_a().select { |var| var.owner_name == owner }
+                return VariableSet.new(*found)
+            end
+
+            # Returns all possible values of variables in this set as an array
+            def values()
+                return self.to_a().map(&:values).flatten
+            end
+
+        end
+
+    end
+end
+        

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

@@ -0,0 +1,23 @@
+# Require all module files
+Dir[File.join(__dir__, "**", '*.rb')].sort.each { |file| require file }
+
+module PgVerify
+    module NuSMV
+
+        class RawNuSMVError < PgVerify::Core::Error
+            def initialize(cmd, out, err, status, file)
+                @cmd, @out, @err, @status, @file = cmd, out, err, status, file
+            end
+
+            def formatted()
+                title = "Execution of NuSMV exited with #{@status}"
+
+                body  = "The exact command was\n#{@cmd.c_string}\n\n"
+                body += "#{@out}\n#{@err}"
+                
+                return title, body
+            end
+        end
+
+    end
+end

data/lib/pg-verify/nusmv/runner.rb

@@ -0,0 +1,124 @@
+
+module PgVerify
+    module NuSMV
+
+        class Runner
+
+            def run_specs(program_graph)
+                nusmv_s = Transform::NuSmvTransformation.new.transform_graph(program_graph)
+                output = eval_nusmv(nusmv_s)
+                specs = program_graph.specification.flatten()
+                return parse_spec_results(program_graph, specs, output)
+            end
+
+            def parse_spec_results(program_graph, specs, nusmv_output)
+                block = Struct.new(:success, :lines)
+
+                # Split the output into blocks which describe the 
+                # specifications
+                blocks, current_block = [], nil
+                nusmv_output.split("\n").each { |line|
+                    result = line[/-- specification .* is (true|false)/, 1]
+                    if !result.nil?
+                        blocks << current_block unless current_block.nil?
+                        current_block = block.new(result == "true", [])
+                        next
+                    end
+                    current_block.lines << line unless current_block.nil?
+                }
+                blocks << current_block unless current_block.nil?
+
+                return blocks.each_with_index.map { |block, index|
+                    trace = block.success ? nil : block.lines.select { |l| l.start_with?(/\s+/) }
+                    trace = parse_trace(program_graph, trace.join("\n")) unless trace.nil?
+
+                    Model::SpecResult.new(specs[index], block.success, trace)
+                }
+            end
+
+            # Calls NuSMV to calculate a possible state trace.
+            # Returns an array of states, where each state is a hash from
+            # variable to the value of that variable in that state
+            def run_simulation(program_graph, steps, random: false)
+                commands = []
+                commands << "read_model"
+                commands << "flatten_hierarchy"
+                commands << "encode_variables"
+                commands << "build_model"
+                commands << "pick_state #{random ? '-r' : ''}"
+                commands << "simulate -k #{steps.to_s.to_i} -v #{random ? '-r' : ''}"
+                commands << "quit"
+                nusmv_s = Transform::NuSmvTransformation.new.transform_graph(program_graph)
+                output = eval_nusmv(nusmv_s, commands: commands)
+                return parse_trace(program_graph, output)
+            end
+
+            def parse_trace(program_graph, nusmv_output)
+                var_states, current_var_state = [], nil
+
+                loop_index = -1
+
+                nusmv_output.split("\n").each { |line|
+                    # Wait for heading of new state
+                    if line.match(/\s*-> State: .+ <-/)
+                        # Complete and store the old state if any
+                        unless current_var_state.nil?
+                            missing_keys = var_states.empty? ? [] :  var_states[-1].keys - current_var_state.keys
+                            missing_keys.each { |key|
+                                current_var_state[key] = var_states[-1][key]
+                            }  
+                            var_states << current_var_state
+                        end
+                        # Create a new state
+                        current_var_state = {}
+                        next
+                    end
+                    # Skip lines before the first state
+                    next if current_var_state.nil?
+
+                    if line.include?("Loop starts here")
+                        loop_index == var_states.length - 1
+                        next
+                    end
+
+                    key_val = line.split("=").map(&:strip)
+                    key = key_val[0].gsub("v.V_", "").to_sym
+                    val = key_val[1].gsub("L_", "")
+                    current_var_state[key] = val
+                }
+                return Model::Trace.new(program_graph, var_states)
+            end
+
+            def eval_nusmv(nusmv_string, commands: [])
+                tmp_file = PgVerify.tmp_file("pg.smv")
+                File.write(tmp_file, nusmv_string)
+                return eval_file(tmp_file, commands: commands)
+            end
+
+            def eval_file(file, commands: [])
+                nusmv_path = find_nusmv_path()
+                raise "NuSMV not integrated! (TODO: Make a better error message)" if nusmv_path.blank?
+                if commands.blank?
+                    nusmv_cmd = "#{nusmv_path} #{file}"
+                else
+                    tmp_cmd_file = PgVerify.tmp_file("nusmv_commands")
+                    File.write(tmp_cmd_file, commands.join("\n"))
+                    nusmv_cmd = "#{nusmv_path} -source '#{tmp_cmd_file}' #{file}"
+                end
+                output, err, status = Open3.capture3({}, nusmv_cmd)
+                raise RawNuSMVError.new(nusmv_cmd, output, err, status, file) unless status.success?
+                return output
+            end
+
+            def find_nusmv_path
+                # Return by settings path if that exists
+                return Settings.nusmv.path if !Settings.nusmv.path.blank? && File.file?(Settings.nusmv.path)
+
+                # Fall back to looking in the addon directory
+                candidates = Dir[File.join(PgVerify.addon_dir, "*", "bin", "NuSMV*")]
+                return candidates.sort.first unless candidates.empty?
+            end
+
+        end
+    end
+end

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

@@ -0,0 +1,23 @@
+# Require all module files
+Dir[File.join(__dir__, "**", '*.rb')].sort.each { |file| require file }
+
+
+module PgVerify
+    module Puml
+
+        def self.find_path
+            # Return by settings path if that exists
+            return Settings.puml.path if !Settings.puml.path.blank? && File.file?(Settings.puml.path)
+
+            # Fall back to looking in the addon directory
+            candidates = Dir[File.join(PgVerify.addon_dir, "plantuml-*.jar")]
+            return candidates.sort.first unless candidates.empty?
+        end
+
+        def self.convert_file(in_path, out_path)
+            # TODO: The PlantUML jar switches focus to the desktop is if it would
+            # attempt to open a window each time it is invoked.
+        end
+
+    end
+end

data/lib/pg-verify/shell/loading/line_animation.rb

@@ -0,0 +1,36 @@
+require_relative 'loading_animation.rb'
+
+module PgVerify
+    module Shell
+
+        class LineAnimation < LoadingAnimation
+
+            def initialize(loading_message)
+                super(loading_message)
+                @last_line = nil
+            end
+
+            def on_anim(passed_time)
+                color  = (passed_time * 2).to_i % 2 == 0 ? :loading : :white
+                circle = (passed_time * 2).to_i % 2 == 0 ? "▶" : "-" 
+                circle = circle.color(color)
+                " #{circle}  #{string = format_line(@last_line)}  "
+            end
+
+            def printl(string)
+                return unless started?()
+                string = string.to_s
+                string = (string ||= "").gsub("\n", '')
+                string = string.c_sidenote unless Colorizer.color?(string)
+                @last_line = string
+                # print_anim(string)
+            end
+
+            def format_line(string)
+                return loading_message() if string.blank?
+                "#{loading_message()} [ #{string} ]"
+            end
+
+        end
+    end
+end

data/lib/pg-verify/shell/loading/loading_animation.rb

@@ -0,0 +1,80 @@
+module PgVerify
+    module Shell
+
+        class LoadingAnimation
+
+            attr_reader :loading_message, :last_output_length, :start_time
+
+            def initialize(loading_message)
+                @loading_message = loading_message
+                @last_output_length = 0
+                @animation_thread = nil
+                @start_time = nil
+            end
+
+            def start
+                return unless @animation_thread.nil?
+                @start_time = Time.now
+                on_start()
+                @animation_thread = Thread.new {
+                    begin
+                        while true do
+                            passed_time = Time.now - @start_time
+                            string = on_anim(passed_time)
+                            print_anim(string) unless string.nil?
+                            sleep(1.0 / 10)
+                        end
+                    rescue => e
+                        puts e
+                        puts e.backtrace 
+                        raise e
+                    end
+                }
+                self
+            end
+
+            def stop(status, finish_message)
+                return if @animation_thread.nil?
+                @animation_thread.exit
+                prompt = Shell.gen_prompt(status)
+                string = on_stop(prompt, finish_message)
+                @animation_thread = nil
+                print_anim(string)
+                puts
+            end
+
+            def print_anim(string)
+                return if string.blank?
+                string = string.to_s
+                # Fill the string with spaces to overwrite the last printed string
+                print_string = string + ( " " * [0, @last_output_length - string.length].max )
+                # Set the length of the last print to the string length without spaces, 
+                # since they do not need to be overwritten.
+                @last_output_length = string.length
+                # Print the string with spaces.
+                print("\r#{print_string}")
+            end
+
+            def on_anim(passed_time); end
+            def on_start(); end
+            def printl(string); end
+
+            def on_stop(prompt, finish_message)
+                message = "#{prompt} #{@loading_message}"
+                message += " | #{finish_message}".c_sidenote unless finish_message.nil? || finish_message.empty?
+                if Settings.print_loading_times
+                    duration = TimeUtil.duration_string((Time.now - @start_time).to_i)
+                    duration_string = duration.nil? ? "" : "Took #{duration}".c_sidenote
+                    return Shell.expand_to_console(message, duration_string)
+                else
+                    return message
+                end
+            end
+
+            def started?()
+                !@animation_thread.nil?
+            end
+
+        end
+    end
+end