pg-verify 0.1.0

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

@@ -0,0 +1,85 @@
+
+module PgVerify
+    module Interpret
+
+        class GraphContext
+
+            attr_accessor :parent_script
+            # The list of currently declared components
+            attr_accessor :components
+            attr_accessor :specs
+            attr_accessor :hazards
+            # The name of this graph
+            attr_accessor :name
+    
+            def initialize(name, parent_script)
+                @parent_script = parent_script
+                @name = name
+                @components, @specs, @hazards = [], [], []
+            end
+    
+            # DSL method for declaring a new component in this graph
+            def graph(name, &blk)
+                raise InvalidDSL_graph.new("Name '#{name}' is neither a symbol nor string") unless name.is_a?(Symbol) || name.is_a?(String)
+                cmp = ComponentContext.new(name, self)
+                cmp.instance_eval(&blk)
+                @components << cmp
+                return cmp
+            end
+
+            def transient(name)
+                cmp = graph(name) do
+                    all_states = [ :No, :Yes ]
+                    states(*all_states)
+                    all_states.product(all_states).each { |s1, s2| transition({ s1 => s2}) }
+                end
+                cmp.represents_fault = true
+                return cmp
+            end
+
+            def persistent(name)
+                cmp = graph(name) do
+                    states(:No, :Yes)
+                    transition :No => :No
+                    transition :No => :Yes
+                end
+                cmp.represents_fault = true
+                return cmp
+            end
+
+            def disable_error(name)
+                cmp = @components.find { |c| c.name == name.to_sym }
+                raise "No such component: #{name}" if cmp.nil?
+                raise "Not an error component: #{name}" unless cmp.represents_fault
+                cmp.transition_list = [ ]
+                cmp.init_expressions = [ "#{name} == No" ]
+            end
+
+            def error(name)
+                return name
+            end
+
+            # DSL method for declaring a new specification in this graph
+            def specify(text, &blk)
+                specset = SpecSetContext.new(text, self, nil)
+                specset.instance_eval(&blk)
+                @specs << specset
+            end
+
+            def hazard(hash)
+                text = hash.keys.first
+                expression = hash[text]
+                @hazards << Model::Hazard.new(text, expression)
+            end
+
+            def to_model()
+                components = @components.map(&:to_model)
+                variables = Model::VariableSet.new(*@components.map(&:owned_variables).flatten())
+                specification = Model::Specification.new(@specs.map { |s| s.to_model(nil) })
+                Model::Graph.new(@name, components: components, variables: variables, specification: specification, hazards: @hazards)
+            end
+    
+        end
+
+    end
+end

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

@@ -0,0 +1,142 @@
+# Require all module files
+Dir[File.join(__dir__, "**", '*.rb')].sort.each { |file| require file }
+
+module PgVerify
+
+    module Interpret
+
+        class InterpretError < PgVerify::Core::Error
+            attr_accessor :script_file
+            attr_accessor :line_number
+            attr_accessor :cause
+
+            def initialize(script_file, line_number, cause)
+                @script_file, @line_number, @cause = script_file, line_number, cause
+            end
+
+            def formatted()
+                title = "Error while interpreting script at #{@script_file}:#{@line_number}"
+                cause_str = format_cause()
+
+                sloc = Model::SourceLocation.new(@script_file, @line_number)
+                code_block = sloc.render_code_block
+
+                body = "#{code_block}\n\n#{cause_str}"
+                return title, body
+            end
+
+            def format_cause()
+                return "#{cause}" unless cause.is_a?(Core::Error)
+                return cause.to_formatted()
+            end
+
+        end
+
+        class InvalidDSL_var <  PgVerify::Core::Error
+            def initialize(message)
+                @message = message
+            end
+            def formatted()
+                hint = [ "Define variables like this:" ]
+                hint << "var <name>: <range> [, init: <condition>]"
+                hint << "  where:"
+                hint << "  <name>      is the name of the variable"
+                hint << "  <range>     is a range of integers like (0..15) or an array of symbols like [ :yes, :no ]"
+                hint << "  <condition> is either a value in that range or an expression"
+                return @message, nil, hint.join("\n")
+            end
+        end
+
+        class InvalidDSL_state <  PgVerify::Core::Error
+            def initialize(message)
+                @message = message
+            end
+            def formatted()
+                hint = [ "Define states like this:" ]
+                hint << "states <states>"
+                hint << "  where:"
+                hint << "  <states> is an array of symbols like :on, :off"
+                return @message, nil, hint.join("\n")
+            end
+        end
+
+        class InvalidDSL_graph <  PgVerify::Core::Error
+            def initialize(message)
+                @message = message
+            end
+            def formatted()
+                hint = [ "Define graphs like this:" ]
+                hint << "graph <name> do ... end"
+                return @message, nil, hint.join("\n")
+            end
+        end
+
+        class InvalidDSL_transition <  PgVerify::Core::Error
+            def initialize(message)
+                @message = message
+            end
+            def formatted()
+                hint = [ "Define transitions like this:" ]
+                hint << "transition <pre-state> => <post-state> do ... end"
+                hint << "  where"
+                hint << "  <pre-state> & <post-state> are states in this graph, like :on or :off"
+                return @message, nil, hint.join("\n")
+            end
+        end
+
+        class InvalidDSL_expression <  PgVerify::Core::Error
+            def initialize(type, message)
+                @type, @message = type, message
+            end
+            def formatted()
+                hint = [ "Define #{@type}s like this:" ]
+                hint << "#{@type} <expression>"
+                hint << "  where"
+                hint << "  <expression> is a valid expression as a string or symbol"
+                return @message, nil, hint.join("\n")
+            end
+        end
+
+        class InvalidDSL_model <  PgVerify::Core::Error
+            def initialize(type, message)
+                @type, @message = type, message
+            end
+            def formatted()
+                hint = [ "Define models like this:" ]
+                hint << "model <name> do ... end"
+                hint << "  where"
+                hint << "  <name> is a string or symbol"
+                return @message, nil, hint.join("\n")
+            end
+        end
+        
+        class NoSuchStateError < PgVerify::Core::Error
+            def initialize(state, component)
+                @state, @component = state, component
+            end 
+            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(', ')}"
+                hint = "Make sure to define states before defining transitions."
+                return title, body, hint
+            end
+        end
+
+        class NoSuchScriptError < Core::Error
+            def initialize(script_path)
+                @script_path = script_path
+            end
+
+            def formatted()
+                title = "Could not find script at #{@script_path}"
+                body = "No script file at #{@script_path.c_error}!"
+                hint = "Make sure to create a program graph script at \n#{File.expand_path(@script_path)}"
+                return title, body, hint
+            end
+
+        end
+        
+    end
+
+end

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

@@ -0,0 +1,72 @@
+
+module PgVerify
+    module Interpret
+
+        class PgScript
+
+            # List of models which are defined in this script
+            attr_accessor :models
+            # The full path to the source script file
+            attr_accessor :script_file
+
+
+            def initialize()
+                @models = []
+            end
+        
+            def interpret(file, validate: true)
+                file = File.expand_path(file)
+                raise NoSuchScriptError.new(file) unless File.file?(file)
+                @script_file ||= file
+                
+                begin
+                    Dir.chdir(File.dirname(file)) { eval(File.read(file), get_binding(), file) }
+                rescue Exception => e
+                    re_raise_exception(file, self, e)
+                end
+
+                @models.each { |model| Model::Validation.validate!(model) } if validate
+                
+                return @models
+            end
+
+            def model(name, &blk)
+                raise InvalidDSL_model.new("Name '#{name}' is neither a symbol nor string") unless name.is_a?(Symbol) || name.is_a?(String)
+                graph_ctx = Interpret::GraphContext.new(name.to_sym, self)
+                graph_ctx.instance_eval(&blk)
+                @models << graph_ctx.to_model()
+            end
+
+            # Re-raise an exception which occurred during evaluation of a script to more user
+            # friendly error messages.
+            def re_raise_exception(file, script, ex)
+                # Determine the line in the script file where the error was raised
+                line_number = find_source_location(ex.backtrace).line_number
+
+                # Include the full backtrace in the message if enabled
+                if Settings.full_stack_trace
+                    title = "Here is the full backtrace of the exception!".c_sidenote + "\n"
+                    title += "(You don't have to bother with this unless you are developing pg-verify)".c_sidenote
+                    bt = ex.backtrace.map(&:c_sidenote).join("\n").indented(str: ">>  ".c_sidenote)
+                end
+
+                raise InterpretError.new(file, line_number, ex)
+            end
+            private :re_raise_exception
+
+            def find_source_location(trace = caller())
+                line_number = trace
+                    .select { |l| l.include?(@script_file) }
+                    .map { |l| l.split(":in")[0] }.reject(&:blank?)
+                    .map { |l| l.split(":")[-1] }.reject(&:blank?)
+                    .uniq.first.to_i
+                Model::SourceLocation.new(@script_file, line_number)
+            end
+
+            def get_binding()
+                binding()
+            end
+        
+        end
+    end
+end

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

@@ -0,0 +1,90 @@
+module PgVerify
+    module Interpret
+
+        class LTLBuilder
+
+            def globally()
+                return LTLBuilderGlobally.new()
+            end
+            def after(expression)
+                return LTLBuilderAfter.new(expression)
+            end
+            def before(expression)
+                LTLBuilderBefore.new(expression)
+            end
+            def between(); end
+            def after_until(); end
+
+            class LTLBuilderBase
+
+                def build(pattern, map)
+                    map.each { |key, val|
+                        pattern = pattern.gsub(key.to_s, "#{val}")
+                    }
+                    return pattern
+                end
+
+            end
+
+            class LTLBuilderGlobally < LTLBuilderBase
+                def global(p)
+                    build "G p", { p: p }
+                end
+                def never(p)
+                    build "G !( p )", { p: p }
+                end
+                def exists(p)
+                    build "F p", { p: p }
+                end
+                def reacts(p, s)
+                    build "G ( p => F s )", { p: p, s: s }
+                end
+                def precedes(p, s)
+                    build "!(p) W s", { p: p, s: s }
+                end
+            end
+
+            class LTLBuilderAfter < LTLBuilderBase
+                attr_accessor :q
+                def initialize(q); @q = q end
+                def global(p)
+                     build "G ( q -> G p )", { p: p, q: q }
+                end
+                def never(p) 
+                    build "G ( q -> G !(p))", { p: p, q: q }
+                end
+                def exists(p)
+                     build "( G !(q) ) || ( F ( q && F p ) )", { p: p, q: q }
+                end
+                def reacts(p, s)
+                    build "G ( q => G (p => F s) )", { p: p, q: q, s: s} 
+                end
+                def precedes(p, s)
+                    build "G !(q) || F ( q && !(p) W s )", { p: p, q: q, s: s} 
+                end
+            end
+
+            class LTLBuilderBefore < LTLBuilderBase
+                attr_accessor :q
+                def initialize(q); @q = q end
+                def global(p)
+                    
+                end
+                def never(p) 
+                    build "( F q ) => ( !(p) U q )", { p: p, q: q }
+                end
+                def exists(p)
+                     
+                end
+                def reacts(p, s)
+                    
+                end
+                def precedes(p, s)
+                    
+                end
+            end
+
+        end
+
+    end
+end

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

@@ -0,0 +1,32 @@
+module PgVerify
+    module Interpret
+
+        class SpecContext
+            # The text of this spec as a string.
+            attr_accessor :text
+
+            # The LTL/CTL expression of this spec
+            attr_accessor :expression
+
+            # The parent set of this spec 
+            attr_accessor :parent
+
+            attr_accessor :source_location
+
+            def initialize(text, expression, parent)
+                @text, @expression, @parent = text, expression, parent
+                @expression = Model::ParsedExpression.new(expression, Model::ParsedExpression::TYPE_TL)
+                @expression.source_location = parent.parent_graph.parent_script.find_source_location()
+                @source_location = parent.parent_graph.parent_script.find_source_location()
+            end
+
+            def to_model(parent)
+                spec = Model::Spec.new(@text, @expression, parent)
+                spec.source_location = @source_location
+                return spec
+            end
+
+        end
+
+    end
+end

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

@@ -0,0 +1,67 @@
+module PgVerify
+    module Interpret
+
+        class SpecSetContext
+
+            # The text of this spec set as a string.
+            attr_accessor :text
+
+            # The sub-spec sets contained in this spec set
+            attr_accessor :children
+
+            attr_accessor :parent
+
+            attr_accessor :assumption
+
+            attr_accessor :parent_graph
+
+            attr_accessor :source_location
+
+            def initialize(text, parent_graph, parent, children = [])
+                @text, @parent, @children = text, parent, children
+                @parent_graph = parent_graph
+                @source_location = parent_graph.parent_script.find_source_location()
+            end
+
+            def specify(text, &blk)
+                subset = SpecSetContext.new(text, @parent_graph, self)
+                subset.instance_eval(&blk)
+                children << subset
+            end
+
+            def assuming(hash, &blk)
+                assumption_text = hash.keys.first
+                assumption_expression = hash.values.first
+                subset = SpecSetContext.new("", @parent_graph, self)
+                subset.assumption = { text: assumption_text, expression: assumption_expression }
+                subset.instance_eval(&blk)
+                children << subset
+            end
+
+            def no_errors()
+                err_graphs = @parent_graph.components.select(&:represents_fault)
+                expression = err_graphs.map { |g| "#{g.name} == No" }.join(" && ")
+                return { "there are no errors" => "G ( #{expression} )" }
+            end
+
+            def it(hash)
+                # TODO: Handle errors
+                text = hash.keys.first
+                expression = hash[text]
+                children << SpecContext.new(text, expression.to_s, self)
+            end
+
+            def ltl()
+                return LTLBuilder.new()
+            end
+
+            def to_model(parent)
+                model = Model::SpecSet.new(@text, @assumption, parent, [])
+                model.children = @children.map { |child| child.to_model(model) }
+                return model
+            end
+
+        end
+    end
+
+end

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

@@ -0,0 +1,55 @@
+module PgVerify
+    module Interpret
+
+        class TransitionContext
+
+            TempExpression = Struct.new(:string, :source_location)
+
+            # Back-reference to the component which owns this transition
+            attr_accessor :parent_component
+
+            # Source and target states as symbols
+            attr_accessor :src_state, :tgt_state
+
+            # Strings for the guars, actions and preconditions
+            attr_accessor :guard, :action, :precon
+
+            # Source location for this transition
+            attr_accessor :source_location
+
+            def initialize(parent_component, src_state, tgt_state)
+                @parent_component = parent_component
+                @src_state, @tgt_state = src_state, tgt_state
+                @source_location = @parent_component.parent_graph.parent_script.find_source_location()
+            end
+
+            def guard(str)
+                raise "Guard was already defined!" unless @guard.nil?
+                raise InvalidDSL_expression.new("guard", "Expression is neither a sting, nor symbol: #{str}") unless str.is_a?(String) | str.is_a?(Symbol)
+                @guard = Model::ParsedExpression.new(str, Model::ParsedExpression::TYPE_GUARD)
+                @guard.source_location = @parent_component.parent_graph.parent_script.find_source_location()
+            end
+
+            def action(str)
+                raise "Action was already defined!" unless @action.nil?
+                raise InvalidDSL_expression.new("action", "Expression is neither a sting, nor symbol: #{str}") unless str.is_a?(String) | str.is_a?(Symbol)
+                @action = Model::ParsedExpression.new(str, Model::ParsedExpression::TYPE_ACTION)
+                @action.source_location = @parent_component.parent_graph.parent_script.find_source_location()
+            end
+
+            def precon(str)
+                raise "Precondition was already defined!" unless @guard.nil?
+                raise InvalidDSL_expression.new("precon", "Expression is neither a sting, nor symbol: #{str}") unless str.is_a?(String) | str.is_a?(Symbol)
+                @precon = Model::ParsedExpression.new(str, Model::ParsedExpression::TYPE_GUARD)
+                @precon.source_location = @parent_component.parent_graph.parent_script.find_source_location()
+            end
+
+            def to_model()
+                Model::Transition.new(@src_state, @tgt_state, action: @action, precon: @precon, guard: @guard)
+            end
+
+
+        end
+
+    end
+end

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

@@ -0,0 +1,28 @@
+module PgVerify
+    module Model
+
+        class AllocationSet
+
+            # An array of variables
+            attr_accessor :variables
+
+            # An array of allocations for those variables.
+            # Each allocation is a an array like [0, 1] where indices match the variable array
+            # to represent values for that variable
+            attr_accessor :allocations
+
+            def initialize(variables, allocations)
+                if !allocations.empty? && variables.length != allocations.first.length
+                    raise "Variables and allocations must match in length!" 
+                end
+                @variables, @allocations = variables, allocations
+            end
+
+            def length()
+                allocations.length
+            end
+
+        end
+
+    end
+end

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

@@ -0,0 +1,34 @@
+
+module PgVerify
+    module Model
+
+        class Assignment
+
+            ASSIGN_OPERATOR = ':='
+
+            # The name of the variable which is assigned a value
+            attr_accessor :assigned_variable
+
+            # The Model::Expression which of this assignment
+            attr_accessor :expression
+
+            def self.from_string(string)
+                raise "Not an assignment: #{string}" unless string.include?(ASSIGN_OPERATOR)
+                split = string.split(ASSIGN_OPERATOR).map(&:strip)
+                assigned_variable = split[0].to_sym
+                expression = Expression.from_string(split[1])
+                return Assignment.new(assigned_variable, expression)
+            end
+
+            def initialize(assigned_variable, expression)
+                @assigned_variable, @expression = assigned_variable, expression
+            end
+
+            def to_s()
+                return "#{assigned_variable} #{ASSIGN_OPERATOR} #{expression.to_s}"
+            end
+
+        end
+
+    end
+end

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

@@ -0,0 +1,40 @@
+
+module PgVerify
+    module Model
+
+        class Component
+            
+            # The name of this component as a symbol
+            attr_accessor :name
+            # A list of symbols representing states
+            attr_accessor :states
+            # A list of transitions between states
+            attr_accessor :transitions
+            # Flag on whether this component is used to represent a fault.
+            attr_accessor :represents_fault
+            # The source location of this components definition 
+            attr_accessor :source_location
+
+            # A Model::ParsedExpression used as the init expression.
+            # This expression must hold true initially. It can be used
+            # to restrict or set the initial state and variables.
+            # Can be left as nil in order to not restrict anything
+            attr_accessor :init_expression
+
+            def initialize(args = {})
+                @name = ( args[:name] || raise('Blubb') )
+                @states = ( args[:states] || [] )
+                @transitions = ( args[:transitions] || [] )
+                @represents_fault = args[:represents_fault].nil? ? false : args[:represents_fault]
+                @source_location =  ( args[:source_location] )
+                @init_expression =  args[:init_expression]
+            end
+
+            def represents_fault?()
+                return @represents_fault
+            end
+
+        end
+
+    end
+end

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

@@ -0,0 +1,16 @@
+module PgVerify
+    module Model
+
+        class Hazard
+
+            attr_accessor :text
+            attr_accessor :expression
+
+            def initialize(text, expression)
+                @text, @expression = text, expression
+            end
+
+        end
+
+    end
+end