pg-verify 0.1.0

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

@@ -0,0 +1,67 @@
+module PgVerify
+    module Model
+
+        class DCCA
+
+            def initialize(graph, runner)
+                @graph, @runner = graph, runner
+            end
+
+            def perform()
+                @graph.hazards.map { |hazard|
+                    fault_set = @graph.fault_components.map(&:name)
+                    powerset = fault_set.powerset
+                    sets = calc_minimal_critical_sets(powerset, fault_set, hazard)
+                    [hazard, sets]
+                }.to_h
+            end
+
+            def calc_minimal_critical_sets(powerset, fault_set, hazard, level: 0, minimal_critical_sets: [])
+                to_check = powerset.select { |set| set.length == level }
+                return minimal_critical_sets if to_check.empty?
+
+                # Determine which of the sets to check can result in the hazard.
+                critical = select_critical(to_check, fault_set, hazard)
+
+                # Remove all super sets of the critical ones, as those must be critical as well,
+                # but cannot be minimal.
+                powerset = powerset.reject { |set|
+                    critical.any? { |crit_set| set.subset?(crit_set) }
+                }
+                # Keep track of the new critical sets
+                minimal_critical_sets += critical
+
+                # Continue with the next level.
+                calc_minimal_critical_sets(powerset, fault_set, hazard, 
+                        level: level+1, minimal_critical_sets: minimal_critical_sets)
+            end
+
+            def select_critical(sets, fault_set, hazard)
+                specs = sets.map { |set|
+                    other_errors = fault_set.reject { |err| set.include?(err) }
+                    only_errors = other_errors.empty? \
+                        ? "TRUE" \
+                        : other_errors.map { |err| "#{err} == No" }.join(" && ")
+                    formula = "!( (#{only_errors}) U (#{hazard.expression}) )"
+                    formula = ParsedExpression.new(formula, ParsedExpression::TYPE_TL)
+                    Spec.new("Fault set {#{set.join(', ')}} is safe", formula, nil)
+                }
+
+                spec_set = SpecSet.wrap(specs)
+                @graph.specification = Specification.new([spec_set])
+                
+                results = @runner.run_specs(@graph)
+
+                critical_sets = []
+                results.each_with_index { |result, index|
+                    critical_sets << sets[index] if result.failure?
+                }
+
+                return critical_sets
+            end
+
+
+        end
+
+    end
+end

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

@@ -0,0 +1,106 @@
+module PgVerify
+    module Model
+
+        # Class used to represent a mathematical expression
+        class Expression
+
+            ASSIGNMENT_OP = ':='
+            MAX_ALLOCS_FOR_CHECK = 1000000
+
+            # 3 * Position + x
+            # >= 4
+
+            # The entire expression as a string
+            attr_accessor :expression_string
+
+            def initialize(expression_string)
+                @expression_string = expression_string
+            end
+
+            # Finds all variables in the specified this expression
+            # and returns them as an unique array of symbols ordered by their occource
+            def used_variables(expression=@expression_string)
+                expression.scan(/[a-zA-Z_][a-zA-Z0-9_]*/).uniq.map(&:to_sym)
+            end
+
+            def assigned_variable()
+                var, expression = isolate_assigned_variable()
+                return var
+            end
+
+            def term_variables()
+                var, expression = isolate_assigned_variable()
+                return used_variables(expression)
+            end
+
+            def assignment?()
+                return !assigned_variable().nil?
+            end
+
+            # Calcuates an AllocationSet which is populated with all variable allocations
+            # which lead to an illegal output value for this expressions variable assignment
+            def calc_illegal_allocations(resolved_variables)
+
+                assigned_var, term = isolate_assigned_variable()
+                raise("Term '#{self}' is not a variable assignment!") if assigned_var.nil?
+                term_vars = used_variables(term)
+
+                # Resolve the variables used in this expression to actual variable objects
+                assigned_var = resolved_variables.detect {|var| var.name == assigned_var }
+                term_vars = term_vars.map { |varname| resolved_variables.detect { |var| varname == var.name } }
+
+                # Calculate the number of possible allocations, which is the product of the variable range length
+                num_combinations = term_vars.map(&:range).map(&:count).reduce(&:*)
+
+                # Set an upper limit to not calculate some huge range forever
+                raise "Search space too large on validation of term '#{self}': #{num_combinations} > #{MAX_ALLOCS_FOR_CHECK}" \
+                    if num_combinations > MAX_ALLOCS_FOR_CHECK
+
+                # Calculate all combinations of possible variable assignments based on their range
+                allocations = term_vars.map(&:range).map(&:to_a).reduce(&:product).map(&:flatten)
+
+                # For each combination of variable allocations create an expression by replacing the variable
+                # with its value in that allocation
+                illegal_allocations = allocations.reject { |alloc|
+                   values = term_vars.map(&:name).map(&:to_s).zip(alloc).to_h
+                   expression = term.gsub(/#{term_vars.map(&:name).join("|")}/, values)
+
+                   resolved_value = eval(expression)
+                   assigned_var.range.include?(resolved_value)
+                }
+
+                puts "#{illegal_allocations}"
+
+                return AllocationSet.new(term_vars, illegal_allocations)
+            end
+
+            # Only keeps allocations in the specified allocation set which are possible
+            # based on this condition
+            def filter_allocation_set(allocation_set)
+                # Only keep allocations for which this condition evaluates to true
+                allocation_set.allocations.select { |alloc|
+                    values = allocation_set.variables.map(&:name).map(&:to_s).zip(alloc).to_h
+                    term = @expression_string.gsub(/#{allocation_set.variables.map(&:name).join("|")}/, values)
+                    result = eval(term)
+                    raise "Expression #{self} for allocation #{alloc} (#{term}) evaluated to #{result} which is not a boolean" \
+                        unless result == true || result == false
+                    result == true
+                }
+            end
+
+            # This method splits off a potential assigned variable and returns the variable
+            # which is assigned as a symbol and the remaining expression as a string.
+            def isolate_assigned_variable()
+                var = used_variables().first
+                match = @expression_string[/(#{var}\s*#{ASSIGNMENT_OP})/, 1]
+                return nil, @expression_string if match.nil?
+                return var, @expression_string.gsub(match, '').strip
+            end
+
+            def to_s()
+                @expression_string
+            end
+
+        end
+    end
+end

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

@@ -0,0 +1,58 @@
+
+module PgVerify
+    module Model
+
+        class Graph
+
+            # The name of this graph
+            attr_accessor :name
+
+            # All Model::Component's which are part of this graph
+            attr_accessor :components
+
+            # A Model::VariableSet of all non-state variables declared by
+            # components in this graph
+            attr_accessor :variables
+
+            # The Model::Specification of this graph
+            attr_accessor :specification
+
+            # An array of Model::Hazards for this graph
+            attr_accessor :hazards
+
+            def initialize(name, components: [], variables: VariableSet.new(), specification: Specification.empty(), hazards: [])
+                raise "Not a variable set #{variables}" unless variables.is_a?(VariableSet)
+                raise "Not a specification #{specification}" unless specification.is_a?(Specification)
+                @name = name
+                @components, @variables, @specification, @hazards = components, variables, specification, hazards
+            end
+
+            # Returns a list of state variables for each component in this graph
+            # Each state variable is named according to the component it represents
+            # and has a range consisting of the states of that component 
+            def state_variables()
+                vars = @components.map { |cmp|
+                    Variable.new(cmp.name, cmp.states, cmp.name, cmp.source_location)
+                }
+                return VariableSet.new(*vars)
+            end
+
+            # Returns all variables used in this graph including state variables
+            def all_variables()
+                return state_variables() + @variables
+            end
+
+            def fault_components()
+                return @components.select(&:represents_fault?)
+            end
+
+            def validate()
+                errors = []
+                errors += UnkownVariableValidation.validate(self)
+                return errors
+            end
+    
+        end
+        
+    end
+end

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

@@ -0,0 +1,10 @@
+# Require all module files
+Dir[File.join(__dir__, "**", '*.rb')].sort.each { |file| require file }
+
+module PgVerify
+    module Model
+        
+        # class ValidationError < PgVerify::Core::Error; end
+
+    end
+end

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

@@ -0,0 +1,77 @@
+
+module PgVerify
+    module Model
+
+        class ParsedExpression
+
+            # Guards and preconditions
+            TYPE_GUARD = :guard
+            # Actions
+            TYPE_ACTION = :action
+            # Term for the right part of an action
+            TYPE_TERM = :term
+            # Propositional logic
+            TYPE_PL = :pl
+            # Temporal logic (LTL or CTL)
+            TYPE_TL = :tl
+            # Linear temporal logic
+            TYPE_LTL = :ltl
+            # Computation tree logic
+            TYPE_CTL = :ctl
+
+            TYPES = [ TYPE_GUARD, TYPE_ACTION, TYPE_TERM, TYPE_PL, TYPE_TL, TYPE_LTL, TYPE_CTL ]
+
+            attr_accessor :expression_string
+            attr_accessor :source_location
+            attr_accessor :type
+
+            def initialize(expression_string, type, source_location: nil)
+                expression_string = expression_string.to_s if expression_string.is_a?(Symbol)
+                raise "Unknown expression type '#{type}'" unless TYPES.include?(type)
+                raise "Not a string '#{expression_string}'::#{expression_string.class}" unless expression_string.is_a?(String)
+                @expression_string = expression_string
+                @source_location = source_location
+                @type = type
+            end
+
+            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| w == "TRUE" || w == "FALSE" }
+                return words.map(&:to_sym)
+            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
+            def tokenize()
+                return expression_string.split(/\s+/).map { |t|
+                    t.end_with?(")") ? [ t.chop, ")" ] : t
+                }.flatten.map { |t|
+                    t.end_with?("(") ? [ t.chop, "(" ] : t
+                }.flatten.map { |t|
+                    t.start_with?(")") ? [ ")" , t.slice(1..-1)] : t
+                }.flatten.map { |t|
+                    t.start_with?("(") ? [ "(" , t.slice(1..-1)] : t
+                }.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
+
+            def assigned_variables()
+                raise "Not an action" unless @type == TYPE_ACTION
+                return expression_string.split("|").map { |sub_action|
+                    sub_action.split(":=")[0].strip
+                }
+            end
+
+        end
+
+    end
+end

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

@@ -0,0 +1,43 @@
+module PgVerify
+    module Model
+
+        class Trace
+
+            attr_accessor :model
+            attr_accessor :states
+
+            def initialize(model, states)
+                @model, @states = model, states
+            end
+
+            def to_s()
+                return "No states in trace" if @states.empty?
+                # Get all variables (TODO: Bring into sensible order)
+                vars = @states.first.keys
+                state_vars = @model.state_variables()
+
+                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") 
+                }
+                str = "Step".c_num.c_bold + "\n" + (0...@states.length).map { |i| "#{i + 1}" } .join("\n")
+                parts.each { |part| str = str.line_combine(part, separator: "  ") }
+                
+                return str
+            end
+
+            def value_str(key, value, index)
+                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]
+                return value.send(:"c_#{settings_color}") unless settings_color.blank?
+
+                return "#{value}" 
+
+            end
+
+        end
+
+    end
+end

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

@@ -0,0 +1,23 @@
+module PgVerify
+    module Model
+
+        class VariableState
+
+            attr_accessor :value_map
+
+            def initialize(spec, success, trace)
+                
+            end
+
+            def success?
+                return @success
+            end
+            
+            def failure?()
+                return !@success
+            end
+
+        end
+
+    end
+end

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

@@ -0,0 +1,45 @@
+module PgVerify
+    module Model
+        
+        class SourceLocation
+
+            attr_accessor :file
+            attr_accessor :line_number
+
+            def initialize(file, line_number)
+                @file, @line_number = file, line_number
+            end
+
+            def render_code_block(num_lines = 2)
+                index = @line_number - 1
+                # Read lines and add line numbers
+                lines = File.read(@file).split("\n").each_with_index.map { |l, i| "#{i.to_s.c_blue}: #{l}" }
+
+                # Get the line surrounding the error
+                start_index = [0, index - num_lines].max
+                end_index = [lines.length - 1, index + num_lines].min
+                surrounding_lines = lines[start_index..end_index]
+                error_line = lines[index]
+
+                surrounding_lines = [ "...".c_sidenote ] + surrounding_lines + [ "...".c_sidenote ]
+
+                surrounding_lines = surrounding_lines.map { |l|
+                    if l == error_line
+                        l.ljust(surrounding_lines.map(&:length).max) + " < Error".c_error
+                    else
+                        l
+                    end
+                }
+
+                return surrounding_lines.join("\n")
+            end
+
+            def to_s()
+                "#{@file}:#{@line_number}"
+            end
+            
+
+        end
+
+    end
+end

data/lib/pg-verify/model/specs/spec.rb

@@ -0,0 +1,44 @@
+module PgVerify
+    module Model
+
+        # A single specification and a leave in the tree
+        class Spec
+
+            # The text of this spec as a string.
+            attr_accessor :text
+
+            # The LTL/CTL expression of this spec
+            attr_accessor :expression
+
+            # The parent specification set for this node
+            attr_accessor :parent
+
+            attr_accessor :source_location
+
+            def initialize(text, expression, parent)
+                raise "Not a #{Model::ParsedExpression}: #{expression}" unless expression.is_a?(Model::ParsedExpression)
+                @text, @expression, @parent = text, expression, parent
+            end
+
+            def parent?
+                return !@parent.nil?
+            end
+
+            def linage()
+                return parents() + [ self ]
+            end
+
+            def parents()
+                array = []
+                current = self
+                while(current.parent?)
+                    current = current.parent
+                    array << current
+                end
+                return array.reverse()
+            end
+
+        end
+
+    end
+end

data/lib/pg-verify/model/specs/spec_result.rb

@@ -0,0 +1,25 @@
+module PgVerify
+    module Model
+
+        class SpecResult
+
+            attr_reader :spec
+            attr_accessor :success
+            attr_accessor :trace
+
+            def initialize(spec, success, trace)
+                @spec, @success, @trace = spec, success, trace
+            end
+
+            def success?
+                return @success
+            end
+            
+            def failure?()
+                return !@success
+            end
+
+        end
+
+    end
+end

data/lib/pg-verify/model/specs/spec_set.rb

@@ -0,0 +1,43 @@
+module PgVerify
+    module Model
+
+        class SpecSet
+
+            # The text of this spec set as a string.
+            attr_accessor :text
+
+            attr_accessor :assumption
+
+            # The sub-spec sets contained in this spec set
+            attr_accessor :children
+
+            attr_accessor :parent
+
+            def self.wrap(specs)
+                spec_set = self.new("", nil, nil, nil)
+                specs.each { |spec| spec.parent = spec_set }
+                spec_set.children = specs
+                return spec_set
+            end
+
+            def initialize(text, assumption, parent, children)
+                @text, @assumption, @parent, @children = text, assumption, parent, children
+            end
+
+            def parent?
+                return !@parent.nil?
+            end
+
+            def get_specs()
+                ret = []
+                children.each { |child|
+                    ret << child             if child.is_a?(Spec)
+                    ret += child.get_specs() if child.is_a?(SpecSet)
+                }
+                return ret
+            end
+
+        end
+
+    end
+end

data/lib/pg-verify/model/specs/specification.rb

@@ -0,0 +1,50 @@
+module PgVerify
+    module Model
+
+        class Specification
+
+            attr_accessor :spec_sets
+
+            def self.empty()
+                return self.new([])
+            end
+
+            def initialize(spec_sets)
+                @spec_sets = spec_sets
+            end
+
+            def get_specs()
+                spec_sets.map(&:get_specs).flatten
+            end
+
+            def flatten()
+                return get_specs().map { |spec|
+                    parents = spec.parents
+                    prefix = parents.map { |spec_set|
+                        spec_set.assumption.nil? \
+                            ? spec_set.text \
+                            : "(assuming #{spec_set.assumption[:text]})" #.c_sidenote
+                    }.join(" ")
+                    text = "#{prefix} #{spec.text}"
+
+                    assumption_expression = parents.map { |spec_set|
+                        next if spec_set.assumption.nil?
+                        spec_set.assumption[:expression]
+                    }.compact.join(" && ")
+
+                    expression = spec.expression
+                    unless assumption_expression.empty?
+                        expression_string = "( #{assumption_expression} ) => #{spec.expression}"
+                        expression = Model::ParsedExpression.new(expression_string, Model::ParsedExpression::TYPE_TL)
+                        expression.source_location = spec.expression.source_location
+                    end
+
+                    result = Spec.new(text, expression, nil)
+                    result.source_location = spec.source_location
+                    result
+                }
+            end
+
+        end
+    end
+end

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

@@ -0,0 +1,41 @@
+module PgVerify
+    module Model
+
+        class Transition
+
+            # The source and target state of this transition as symbols
+            attr_accessor :src_state, :tgt_state
+
+            attr_accessor :guard, :precon, :action
+
+            def initialize(src_state, tgt_state, guard: nil, action: nil, precon: nil)
+                @src_state, @tgt_state = src_state, tgt_state
+                @guard, @precon, @action = guard, precon, action
+            end
+
+             def validate!()
+                # @actions.each { |action|
+                #     # Calculate all illegal allocations
+                #     # An allocation is illegal if it evaluates to a number outside of the range
+                #     # of the assigned variable
+                #     illegal_allocations = action.calc_illegal_allocations()
+                #     # Only keep allocations as illegal if guards do not prevent them 
+                #     illegal_allocations = precon.filter_allocation_set(illegal_allocations)
+
+                #     raise("ValidationError") if illegal_allocations.length != 0
+                # }
+             end
+
+             
+             def to_s()     
+                label = [ @precon, @guard ].map(&:to_s).reject(&:empty?).join(" && ")
+                label += "/ " + @action.to_s unless @action.nil?
+
+                label = ": #{label}" unless label.strip.empty?
+                return "#{@src_state} -> #{@tgt_state} #{label}"
+             end
+
+        end
+
+    end
+end

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

@@ -0,0 +1,26 @@
+module PgVerify
+    module Model
+        module Validation
+
+            module AssignmentToStateVariableValidation
+
+                def self.validate(model)
+                    errors = []
+                    varset = model.all_variables()
+                    actions = model.components.map(&:transitions).flatten.map(&:action).compact
+                    actions.each { |action|
+                        action.assigned_variables().each { |var_string|
+                            var = varset[var_string]
+                            # Do not handle: Assignment to unknown variable
+                            next if var.nil?
+                            next unless var.state_variable?
+                            errors << AssignmentToStateVariableError.new(var.name, action, varset)
+                        }
+                    }
+                    return errors
+                end
+                
+            end
+        end
+    end
+end