pg-verify 0.1.0

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

@@ -0,0 +1,43 @@
+module PgVerify
+    module Shell
+
+        module LoadingPrompt
+
+            def self.while_loading(loading_message)
+                if Shell.in_pipe? || !Settings.use_animations
+                    # Do not play animations when piped
+                    animation = NoAnimation.new(loading_message).start
+                else
+                    animation = LineAnimation.new(loading_message).start
+                end
+
+                start_time = Time.now
+
+                begin
+                    result = yield(animation) if block_given?
+                    delta_time = Time.now - start_time
+                rescue StandardError, SignalException, Interrupt, IOError => e
+                    exception = e
+                ensure
+                    status = exception.nil? ? (result.nil? ? :empty : :success) : :error
+                    status = result.state if !result.nil? && result.is_a?(LoadingResult)
+                    animation.stop(status, result.is_a?(LoadingResult) ? result.message : "")
+                    result = result.data if result.is_a?(LoadingResult)
+                    raise exception unless exception.nil?
+                end
+
+                return result
+            end
+
+            class LoadingResult
+                attr_accessor :data, :message, :state
+                def initialize(data, message, state: :success)
+                    @data = data
+                    @message = message
+                    @state = state
+                end
+            end
+
+        end
+    end
+end

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

@@ -0,0 +1,20 @@
+require_relative 'loading_animation.rb'
+
+module PgVerify
+
+    module Shell
+
+        class NoAnimation < LoadingAnimation
+
+            def initialize(loading_message)
+                super(loading_message)
+            end
+
+            def on_anim(passed_time)
+                nil
+            end
+
+        end
+
+    end
+end

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

@@ -0,0 +1,30 @@
+# Require all module files
+Dir[File.join(__dir__, "**", '*.rb')].sort.each { |file| require file }
+require 'io/console'
+
+module PgVerify
+    module Shell
+
+        def self.in_pipe?()
+            !in_tty?()
+        end
+
+        def self.in_tty?()
+            $stdout.isatty
+        end
+
+        def self.gen_prompt(level)
+            prompt = Settings.prompt.prompt_format % Settings.prompt[level]
+            prompt.color(level)
+        end
+
+        def self.expand_to_console(left, right)
+            return "#{left}    (#{right})" unless Settings.allow_right_print
+            return "#{left}    (#{right})" unless Shell.in_tty?
+            width = IO.console.nil? ? 4 : IO.console.winsize[1]
+            space = " " * [(width -(Colorizer.uncolorize(left).length + Colorizer.uncolorize(right).length)), 1].max
+            return left + space.c_sidenote + right
+        end
+
+    end
+end

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

@@ -0,0 +1,7 @@
+# Require all module files
+Dir[File.join(__dir__, "**", '*.rb')].sort.each { |file| require file }
+
+module PgVerify
+    module Simulation
+    end
+end

data/lib/pg-verify/simulation/simulator.rb

@@ -0,0 +1,90 @@
+module PgVerify
+    module Simulation
+
+        class Simulator
+
+            attr_accessor :graph
+
+            def initialize(graph)
+                @graph = graph
+            end
+
+            def run(steps: 10, state: State.for_variable_set(@graph.all_variables))
+                state_stack = [ state ]
+                steps.times {
+                    component_transitions = find_next_transitions(state)
+                    state = run_transitions(component_transitions, state)
+                    state_stack << state
+                }
+                return state_stack
+            end
+
+            # Returns a map from 'component' to 'transition' which should
+            # be used for that component based in the state.
+            # If there is no matching transition for a component, that
+            # component is omitted as to use the "tau-transition".
+            def find_next_transitions(state)
+                 return @graph.components.map { |cmp|
+                    matching_transitions = cmp.transitions.select { |trans|
+                        transition_accepted?(trans, cmp, state)
+                    }
+                    # Do not change the state if no transitions match
+                    next if matching_transitions.empty?
+
+                    # TODO: Choose random one using seed
+                    chosen_transition = matching_transitions.shuffle().first
+                    [cmp, chosen_transition]
+                }.compact.to_h
+            end
+
+            # Performs the specified transitions on the specified state
+            # and returns a new updated state.
+            def run_transitions(component_transitions, state)
+                new_state = state.clone()
+                component_transitions.each { |component, transition|
+                    # Update the component state
+                    new_state[component.name] = transition.tgt_state
+
+                    # Perform the action
+                    next if transition.action.nil?
+                    parts = transition.action.to_s.split(":=")
+                    assigned_variable = parts[0].strip
+                    expression = parts[1].strip
+
+                    new_state[assigned_variable.to_sym] = eval_expression(expression, state)
+                }
+                return new_state
+            end
+
+            def transition_accepted?(transition, component, state)
+                # Transition can't be used unless the component is in the required
+                # source state.
+                return false unless transition.src_state == state[component.name]
+                
+                guard_expression = [ transition.guard, transition.precon ]
+                    .map(&:to_s).reject(&:empty?).join(" && ")
+
+                return false if eval_expression(guard_expression, state) == false
+
+                return true
+            end
+
+            def eval_expression(expression, state)
+                state.names.sort_by(&:length).reverse.each { |var|
+                    value = state[var]
+                    expression = expression.gsub(var.to_s, value.to_s)
+                }
+                
+                expression = Model::ParsedExpression.new(expression, nil)
+                words = expression.word_tokens.uniq
+                expression = expression.to_s
+                words.each { |word|
+                    expression = expression.gsub(word.to_s, "'#{word}'")
+                }
+                return eval(expression)
+            end
+
+        end
+
+    end
+end

data/lib/pg-verify/simulation/state.rb

@@ -0,0 +1,53 @@
+module PgVerify
+    module Simulation
+
+        class State
+
+            attr_accessor :value_map
+
+            def self.for_variable_set(var_set)
+                value_map = var_set.map { |var|
+                    # TODO: Choose random one when nil
+                    raise "TODO: Implement this"
+                    [var, init_val]
+                }.to_h
+                return self.new(value_map)
+            end
+
+            def initialize(value_map)
+                @value_map = value_map
+            end
+
+            def [](var)
+                var = var.to_sym if var.is_a?(String)
+                var = @value_map.keys.detect { |v| v.name == var } if var.is_a?(Symbol)
+                return @value_map[var]
+            end
+
+            def []=(var, value)
+                var = var.to_sym if var.is_a?(String)
+                var = @value_map.keys.detect { |v| v.name == var } if var.is_a?(Symbol)
+                @value_map[var] = value
+            end
+
+            def variables()
+                return @value_map.keys
+            end
+
+            def names()
+                return @value_map.keys.map(&:name)
+            end
+
+            def clone()
+                self.class.new(value_map.map { |k, v| [k, v] }.to_h)
+            end
+
+            def to_s()
+                var_s = @value_map.keys.map(&:name).join("\n")
+                val_s = @value_map.values.join("\n")
+                return var_s.line_combine(val_s, separator: " = ")
+            end
+
+        end
+    end
+end

data/lib/pg-verify/transform/hash_transformation.rb

@@ -0,0 +1,104 @@
+module PgVerify
+    module Transform
+
+        class HashTransformation
+
+            def transform_graph(graph)
+                return { graph.name.to_s => 
+                    graph.components.map { |c| transform_component(graph, c) }
+                }
+            end
+
+            def parse_graph(hash)
+                name = hash.keys.first.to_sym
+                graph = Model::Graph.new(name)
+                components = hash[hash.keys.first].map { |c| parse_component(graph, c) }
+                graph.components = components
+                return graph
+            end
+
+            def transform_component(graph, component)
+                variables = graph.variables.select_by_owner(component)
+                return { component.name.to_s => {
+                    "states" => component.states.map(&:to_s),
+                    "variables" => variables.map { |v| transform_variable(v) },
+                    "transitions" => component.transitions.map { |t| transform_transition(t) },
+                    "represents_fault" => component.represents_fault
+                }}
+            end
+
+            def parse_component(graph, hash)
+                name = hash.keys.first
+                states = hash[name]["states"].map(&:to_sym)
+                variables = hash[name]["variables"].map { |v| parse_variable(name, v) }
+                transitions = hash[name]["transitions"].map { |t| parse_transition(t) }
+                represents_fault = hash[name]["represents_fault"]
+
+                graph.variables += variables
+
+                return Model::Component.new(name: name.to_sym, states: states, 
+                    transitions: transitions, represents_fault: represents_fault)
+            end
+
+            def transform_variable(variable)
+                return { variable.name.to_s => {
+                    "range" => transform_variable_range(variable.range),
+                    "init" => transform_expression(variable.init_expression)
+                }}
+            end
+
+            def parse_variable(owner_name, hash)
+                name = hash.keys.first
+                range = hash[name]["range"]
+                init_expression = parse_expression(hash[name]["init"])
+                return Model::Variable.new(name.to_sym, range, owner_name.to_sym, nil, init: init_expression)
+            end
+
+            def transform_variable_range(range)
+                return "#{range.first}..#{range.last}"if range.is_a?(Range)
+                return range
+            end
+
+            def parse_variable_range(range)
+                if range.is_a?(String) && range.match(/\A\d+\.\.\d+\z/)
+                    first, last = range.split("..")[0], range.split("..")[-1]
+                    return Range.new(first, last)
+                end
+                return range
+            end
+
+            def transform_expression(expression)
+                return nil if expression.nil?
+                return { 
+                    "string" => expression.expression_string, 
+                    "type" => expression.type.to_s
+                }
+            end
+
+            def parse_expression(expression)
+                return nil if expression.nil?
+                string = expression["string"]
+                type = expression["type"].to_sym
+                return Model::ParsedExpression.new(string, type)
+            end
+
+            def transform_transition(transition)
+                name = "#{transition.src_state} -> #{transition.tgt_state}"
+                return { name => {
+                    "precon" => transition.precon&.to_s,
+                    "guard" => transition.guard&.to_s,
+                    "action" => transition.action&.to_s,
+                }}
+            end
+
+            def parse_transition(hash)
+                src_state, tgt_state = hash.keys.first.split("->").map(&:strip).map(&:to_sym)
+                precon = hash.values.first["precon"]
+                guard  = hash.values.first["guard"] 
+                action = hash.values.first["action"]
+                return Model::Transition.new(src_state, tgt_state, precon: precon, guard: guard, action: action)
+            end
+
+        end
+    end
+end

data/lib/pg-verify/transform/nusmv_transformation.rb

@@ -0,0 +1,261 @@
+module PgVerify
+    module Transform
+
+        class NuSmvTransformation
+
+            def transform_graph(program_graph)
+                variables  = program_graph.all_variables
+                components = program_graph.components
+
+                var_s  = transform_variables(variables)
+                cmp_s  = transform_components(components, variables)
+                main_s = transform_main_module(components)
+
+                specs = transform_specification(program_graph.specification, variables)
+
+                return "#{var_s}\n\n#{cmp_s}\n\n#{main_s}\n\n#{specs}\n"
+            end
+
+            def transform_variables(varset)
+                vars_s = varset.to_a.map { |v| transform_variable(v) }.join("\n")
+                return module_string("_VARS", var: vars_s)
+            end
+
+            def transform_components(components, varset)
+                return components.map { |c| transform_component(c, varset) }.join("\n\n")
+            end
+
+            def transform_variable(variable)
+                return "#{transform_varname(variable.name)} : #{transform_range(variable.range)}"
+            end
+
+            def transform_range(range)
+                # Transform state variables
+                return "{#{range.map { |e| transform_const(e) }.join(", ")}};" if range.is_a?(Array)
+                # Transform small integer variables
+                return "{#{range.to_a.join(", ")}};" if (range.last - range.first) < 5
+                # Transform regular integer variables
+                return "#{range.first}..#{range.last};"
+            end
+
+            def transform_component(component, varset)
+                # Name of the component module
+                name = transform_module_name(component.name)
+                # The component takes all variables v
+                name += "(v)"
+
+                # Grab all variables which this component defines and thus owns
+                owned_vars = varset.select_by_owner(component.name).to_a
+
+                # Create the INIT block expression which must hold initially
+                # This is used to initialize variables and decide on the initial
+                # state of this component. This can all be randomized by setting
+                # the init state to true
+                init_expression = transform_init_expression(component, varset, owned_vars)
+
+                # Transform all transitions which are defined in this component
+                trans = component.transitions.map { |transition|
+                    trans_s = transform_transition(varset, component, transition)
+                    "( #{trans_s} )"
+                }
+
+                # Create a default transition which is taken whenever no other
+                # transitions can.
+                tau_transition = []
+                # Combine the precondition, guard and source state conditions
+                # For each transition of this component
+                other_transitions = component.transitions.map { |transition| 
+                    precon_s = transform_expression(transition.precon, varset)
+                    guard_s  = transform_expression(transition.guard, varset)
+
+                    cmp_varname = transform_varname(component.name)
+                    this_state = transform_const(transition.src_state)
+                    state_s = "v.#{cmp_varname} = #{this_state}"
+
+                    [ state_s, precon_s, guard_s ].compact.reject(&:empty?).map{ |s| "( #{s} )" }.join(' & ')
+                }.compact.reject(&:empty?)
+                # Only take the tau transition when all other transitions do not match 
+                tau_transition << "!(\n\t#{other_transitions.join(" | \n\t")})\n\t" unless other_transitions.empty?
+
+                # Keep this components state when using the default transition
+                # Keep all owned variables equal when using the default transition
+                tau_transition += owned_vars.map { |var|
+                    varname = "v.#{transform_varname(var.name)}"
+                    "next(#{varname}) = #{varname}"
+                }
+                # Add the tau transition
+                trans << "(#{tau_transition.join(" & ")})"
+
+                trans = trans.join(" | \n") + ";"
+
+                return module_string(name, init: init_expression, trans: trans)
+            end
+
+            def transform_init_expression(component, varset, owned_vars)
+                init = owned_vars.map { |var|
+                    next if var.init_expression.nil?
+                    transform_expression(var.init_expression, varset)
+                }
+                init << transform_expression(component.init_expression, varset) unless  component.init_expression.nil?
+                init = init.compact.join(" & ")
+                init = "TRUE" if init.empty?
+                return init
+            end
+
+            def transform_transition(varset, component, transition)
+                expression = []
+
+                cmp_varname = transform_varname(component.name)
+                prev_state  = transform_const(transition.src_state)
+                expression << "v.#{cmp_varname} = #{prev_state}"
+
+                next_state = transform_const(transition.tgt_state)
+                expression << "next(v.#{cmp_varname}) = #{next_state}"
+
+                precon_s = transform_expression(transition.precon, varset)
+                guard_s  = transform_expression(transition.guard, varset)
+
+                action_s, assigned_vars = transform_assignment(transition.action, component, varset)
+                
+                keep_vars_constant = varset.select_by_owner(component.name).names
+                    .reject { |v| assigned_vars&.map(&:to_s)&.include?(v.to_s) }
+                    .reject { |v| v.to_s == component.name.to_s }
+                    .map { |v| "next(v.#{transform_varname(v)}) = v.#{transform_varname(v)}" }
+                    .join(' & ')
+
+                expression << precon_s
+                expression << guard_s
+                expression << action_s
+                expression << keep_vars_constant
+
+                return expression.compact.reject(&:empty?).map{ |s| "( #{s} )" }.join(' & ')
+            end
+
+            def transform_assignment(assignment_expression, component, varset)
+                return nil if assignment_expression.nil?
+
+                # Handle composite actions (a := 1 | b := 2) by recursively transforming
+                # the individual actions and then combining them
+                sub_assignments = assignment_expression.to_s.split("|")
+                if sub_assignments.length > 1
+                    action_s_acc, assigned_vars_acc = [], []
+                    sub_assignments = sub_assignments.map { |a|
+                        action_s, assigned_vars = transform_assignment(a, component, varset)
+                        action_s_acc << action_s
+                        assigned_vars_acc += assigned_vars
+                    }
+                    return action_s_acc.join(" & "), assigned_vars_acc.uniq
+                end
+
+
+                parts = assignment_expression.to_s.split(":=")
+
+                assigned_variable = parts[0].strip
+
+                unless varset.varname?(assigned_variable)
+                    raise Model::Validation::UnknownVariableError.new(assigned_variable, assignment_expression, varset)
+                end
+                unless varset[assigned_variable].owner_name == component.name
+                    raise Model::Validation::ForeignVariableAssignmentError.new(assigned_variable, assignment_expression, varset, component)
+                end
+                if varset[assigned_variable].state_variable?
+                    raise Model::Validation::AssignmentToStateVariableError.new(assigned_variable, assignment_expression, varset)
+                end
+
+                assigned_variable_s = "next(v.#{transform_varname(assigned_variable)})"
+
+                expression = parts[1].strip
+                expression = transform_expression(Model::ParsedExpression.new(expression, Model::ParsedExpression::TYPE_TERM), varset)
+
+                assignment_s = "#{assigned_variable_s} = #{expression}"
+
+                return assignment_s, [assigned_variable]
+            end
+
+            def transform_expression(expression, varset)
+                return nil if expression.nil?
+
+                variables, constants = [], []
+                expression.word_tokens.select { |w| 
+                    if varset.names.include?(w)
+                        variables << w
+                    elsif  varset.values.include?(w)
+                        constants << w
+                    else
+                        raise Model::Validation::UnknownTokenError.new(w, expression, varset)
+                    end
+                }
+                variables, constants = variables.uniq, constants.uniq
+
+                constants = expression.word_tokens.select { |w| varset.values.include?(w) }.uniq
+
+                expression_tokens = expression.tokenize
+
+                variables.each { |v| expression_tokens = expression_tokens.gsub(v.to_s, "v." + transform_varname(v))  }
+                constants.each { |c| expression_tokens = expression_tokens.gsub(c.to_s, transform_const(c))  }
+
+                expression_tokens = expression_tokens.gsub('&&', '&')
+                expression_tokens = expression_tokens.gsub('||', '|')
+                expression_tokens = expression_tokens.gsub('||', '|')
+                expression_tokens = expression_tokens.gsub('==', '=')
+                expression_tokens = expression_tokens.gsub('=>', '->')
+                expression_tokens = expression_tokens.gsub('<=>', '<->')
+
+                expression_s = expression_tokens.join(" ")
+
+                return expression_s
+            end
+
+            def transform_main_module(components)
+                # Instantiate variable module as v
+                var_s = "v : _VARS();\n"
+                # Instantiate all component modules, passing in v
+                var_s += components.map { |component|
+                    instance = transform_module_instance_name(component.name)
+                    modul    = transform_module_name(component.name)
+                    "#{instance} : #{modul}(v);"
+                }.join("\n")
+                return module_string("main", var: var_s)
+            end
+
+            def module_string(name, hash = {})
+                blocks = [ "MODULE #{name}" ]
+                hash.each { |key, val|
+                    blocks << key.to_s.upcase.indented
+                    blocks << val.indented(num: 2)
+                }
+                return blocks.join("\n")
+            end
+
+            def transform_varname(name)
+                "V_#{name}"
+            end
+
+            def transform_const(value)
+                return value.to_s unless value.is_a?(Symbol) || value.is_a?(String)
+                "L_#{value}"
+            end
+
+            def transform_module_name(name)
+                "_P_#{name}"
+            end
+
+            def transform_module_instance_name(name)
+                "p_#{name}"
+            end
+
+            def transform_specification(specification, varset)
+                return specification.flatten().map { |s| transform_spec(s, varset) }.join("\n")
+            end
+
+            def transform_spec(spec, varset)
+                expression_s  = "-- #{spec.text}\n"
+                expression_s += "-- Defined in: #{spec.source_location.to_s}\n"
+                expression_s += "LTLSPEC " + transform_expression(spec.expression, varset)
+                return expression_s
+            end
+
+        end
+
+    end
+end