pg-verify 0.1.0

data/lib/pg-verify/ebnf_parser/expression_parser2.rb

@@ -0,0 +1,422 @@
+module PgVerify
+    module EbnfParser
+
+        class ExpressionParser2
+            include EBNF::PEG::Parser
+        
+            # Abstract syntax tree from parse
+            attr_reader :ast
+            attr_accessor :rules
+            attr_accessor :options
+            attr_accessor :type
+
+            # Rule: '[20] CMPOP ::= "<=" | ">=" | "<" | ">" | "==" | "!="'
+            production(:CMPOP) do |input|
+                output = input
+                puts "CMPOP: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[19.2] _VARIABLE_2 ::= [a-zA-Z_]'
+            production(:_VARIABLE_2) do |input|
+                output = input
+                puts "_VARIABLE_2: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[19.6] _VARIABLE_6 ::= [a-zA-Z0-9_]'
+            production(:_VARIABLE_6) do |input|
+                output = input
+                puts "_VARIABLE_6: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[19.5] _VARIABLE_5 ::= _VARIABLE_6*'
+            production(:_VARIABLE_5) do |input|
+                output = input
+                puts "_VARIABLE_5: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[19.4] _VARIABLE_4 ::= [a-zA-Z_]'
+            production(:_VARIABLE_4) do |input|
+                output = input
+                puts "_VARIABLE_4: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[19.3] _VARIABLE_3 ::= [^('true'#x20|#x20'false')]'
+            production(:_VARIABLE_3) do |input|
+                output = input
+                puts "_VARIABLE_3: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[19.1] _VARIABLE_1 ::= _VARIABLE_3 _VARIABLE_4 _VARIABLE_5'
+            production(:_VARIABLE_1) do |input|
+                output = input
+                puts "_VARIABLE_1: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[19] VARIABLE ::= _VARIABLE_1 | _VARIABLE_2'
+            production(:VARIABLE) do |input|
+                output = input
+                puts "VARIABLE: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[18.1] _BOOL_1 ::= "(" BoolExpr ")"'
+            production(:_BOOL_1) do |input|
+                output = input
+                puts "_BOOL_1: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[18] BOOL ::= "true" | "false" | _BOOL_1'
+            production(:BOOL) do |input|
+                output = input
+                puts "BOOL: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[17.3] _NUMBER_3 ::= [0-9]'
+            production(:_NUMBER_3) do |input|
+                output = input
+                puts "_NUMBER_3: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[17.2] _NUMBER_2 ::= _NUMBER_3+'
+            production(:_NUMBER_2) do |input|
+                output = input
+                puts "_NUMBER_2: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[17.1] _NUMBER_1 ::= "-"?'
+            production(:_NUMBER_1) do |input|
+                output = input
+                puts "_NUMBER_1: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[17] NUMBER ::= _NUMBER_1 _NUMBER_2'
+            production(:NUMBER) do |input|
+                output = input
+                puts "NUMBER: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[16.1] _Value_1 ::= "(" Expression ")"'
+            production(:_Value_1) do |input|
+                output = input
+                puts "_Value_1: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[16] Value ::= NUMBER | VARIABLE | _Value_1'
+            production(:Value) do |input|
+                output = input
+                puts "Value: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[15.3] _Product_3 ::= "*" | "/"'
+            production(:_Product_3) do |input|
+                output = input
+                puts "_Product_3: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[15.2] _Product_2 ::= _Product_3 Value'
+            production(:_Product_2) do |input|
+                operation = input.first[:_Product_3]
+                value     = input.last[:Value]
+                output = "#{operation} #{value}"
+                puts "_Product_2: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[15.1] _Product_1 ::= _Product_2*'
+            production(:_Product_1) do |input|
+                output = input
+                puts "_Product_1: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[15] Product ::= Value _Product_1'
+            production(:Product) do |input|
+                value             = input.first[:Value]
+                product_1_results = input.last[:_Product_1]
+                output = "#{value} #{product_1_results.join(' ')}"
+                puts "Product: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[14.3] _Sum_3 ::= "+" | "-"'
+            production(:_Sum_3) do |input|
+                output = input
+                puts "_Sum_3: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[14.2] _Sum_2 ::= _Sum_3 Product'
+            production(:_Sum_2) do |input|
+                operation = input.first[:_Sum_3]
+                value     = input.last[:Product]
+                output = "#{operation} #{value}"
+                puts "_Sum_2: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[14.1] _Sum_1 ::= _Sum_2*'
+            production(:_Sum_1) do |input|
+                output = input
+                puts "_Sum_1: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[14] Sum ::= Product _Sum_1'
+            production(:Sum) do |input|
+                value         = input.first[:Product]
+                sum_1_results = input.last[:_Sum_1]
+                output = "#{value} #{sum_1_results.join(' ')}"
+                puts "Sum: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[13] IntExpr ::= Sum'
+            production(:IntExpr) do |input|
+                output = input
+                puts "IntExpr: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[12.3] _Comparison_3 ::= CMPOP Sum'
+            production(:_Comparison_3) do |input|
+                output = input
+                puts "_Comparison_3: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[12.2] _Comparison_2 ::= _Comparison_3+'
+            production(:_Comparison_2) do |input|
+                output = input
+                puts "_Comparison_2: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[12.1] _Comparison_1 ::= Sum _Comparison_2'
+            production(:_Comparison_1) do |input|
+                output = input
+                puts "_Comparison_1: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[12] Comparison ::= BOOL | _Comparison_1'
+            production(:Comparison) do |input|
+                output = input
+                puts "Comparison: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[11.1] _Negation_1 ::= "!" Comparison'
+            production(:_Negation_1) do |input|
+                output = input
+                puts "_Negation_1: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[11] Negation ::= _Negation_1 | Comparison'
+            production(:Negation) do |input|
+                output = input
+                puts "Negation: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[10.2] _Konjunction_2 ::= "&&" Negation'
+            production(:_Konjunction_2) do |input|
+                output = input
+                puts "_Konjunction_2: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[10.1] _Konjunction_1 ::= _Konjunction_2*'
+            production(:_Konjunction_1) do |input|
+                output = input
+                puts "_Konjunction_1: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[10] Konjunction ::= Negation _Konjunction_1'
+            production(:Konjunction) do |input|
+                output = input
+                puts "Konjunction: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[9.2] _Disjunction_2 ::= "||" Konjunction'
+            production(:_Disjunction_2) do |input|
+                output = input
+                puts "_Disjunction_2: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[9.1] _Disjunction_1 ::= _Disjunction_2*'
+            production(:_Disjunction_1) do |input|
+                output = input
+                puts "_Disjunction_1: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[9] Disjunction ::= Konjunction _Disjunction_1'
+            production(:Disjunction) do |input|
+                output = input
+                puts "Disjunction: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[8.2] _Implication_2 ::= "->" Disjunction'
+            production(:_Implication_2) do |input|
+                output = input
+                puts "_Implication_2: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[8.1] _Implication_1 ::= _Implication_2*'
+            production(:_Implication_1) do |input|
+                output = input
+                puts "_Implication_1: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[8] Implication ::= Disjunction _Implication_1'
+            production(:Implication) do |input|
+                output = input
+                puts "Implication: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[7.3] _Equivalence_3 ::= "<->" | "<!>"'
+            production(:_Equivalence_3) do |input|
+                output = input
+                puts "_Equivalence_3: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[7.2] _Equivalence_2 ::= _Equivalence_3 Implication'
+            production(:_Equivalence_2) do |input|
+                output = input
+                puts "_Equivalence_2: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[7.1] _Equivalence_1 ::= _Equivalence_2*'
+            production(:_Equivalence_1) do |input|
+                output = input
+                puts "_Equivalence_1: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[7] Equivalence ::= Implication _Equivalence_1'
+            production(:Equivalence) do |input|
+                output = input
+                puts "Equivalence: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[6] BoolExpr ::= Equivalence'
+            production(:BoolExpr) do |input|
+                output = input
+                puts "BoolExpr: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[5] Expression ::= BoolExpr | IntExpr'
+            production(:Expression) do |input|
+                output = input
+                puts "Expression: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[4] Assignment ::= VARIABLE ":=" IntExpr'
+            production(:Assignment) do |input|
+                output = input
+                puts "Assignment: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[3] Precon ::= BoolExpr'
+            production(:Precon) do |input|
+                output = input
+                puts "Precon: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[2] Guard ::= BoolExpr'
+            production(:Guard) do |input|
+                output = input
+                puts "Guard: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[1.2] _Action_2 ::= "|" Assignment'
+            production(:_Action_2) do |input|
+                output = input
+                puts "_Action_2: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[1.1] _Action_1 ::= _Action_2*'
+            production(:_Action_1) do |input|
+                output = input
+                puts "_Action_1: '#{input}' -> '#{output}'"
+                output
+            end
+
+            # Rule: '[1] Action ::= Assignment _Action_1'
+            production(:Action) do |input|
+                output = input
+                puts "Action: '#{input}' -> '#{output}'"
+                output
+            end
+            
+
+            def initialize(type: :Expression)
+                @type = type
+                @options = {}
+                # @options[:logger] = Logger.new(STDERR)
+                # @options[:logger].level = :info
+                # @options[:logger].formatter = lambda {|severity, datetime, progname, msg| "#{severity} #{msg}\n"}
+        
+                # Intantiate the grammar
+                ebnf_file = File.expand_path("expressions.ebnf", __dir__)
+                # Perform PEG-specific transformation to the associated rules, which will be passed directly to the parser.
+                @rules = EBNF.parse(File.open(ebnf_file)).make_peg.ast
+
+            end
+
+            def parse!(input)
+                raise "Empty expression!" if input.nil? || input.empty?
+                ast_map = parse(input, @type, @rules, **@options)
+                Ast.new(ast_map)
+            end
+        
+            # def evaluate!(input, type: :Expression)
+            #     # TODO: Change this to actually eval (Also in specs)
+            #     parse(input, type, @rules, **@options)
+            # end
+
+            # def accepts?(input, type: :Expression)
+            #     begin
+            #         evaluate!(input, type: type) 
+            #         return true
+            #     rescue EBNF::PEG::Parser::Error => e 
+            #         return false
+            #     end
+            # end
+        end
+
+    end
+end

data/lib/pg-verify/ebnf_parser/expressions.ebnf

@@ -0,0 +1,33 @@
+/*
+    This grammar accepts a combination of 
+    Note that boolean variables are not supported, thus
+    this expression will be rejected: 'A && true'
+*/
+
+[1] Action ::= Assignment ('|' Assignment)*
+[2] Guard  ::= BoolExpr
+[3] Precon ::= BoolExpr
+
+[4] Assignment  ::= VARIABLE ':=' IntExpr
+[5] Expression  ::= BoolExpr | IntExpr
+
+[6] BoolExpr     ::= Equivalence
+[7] Equivalence  ::= Implication (('<->' | '<!>') Implication)*
+[8] Implication  ::= Disjunction ('->' Disjunction)*
+[9] Disjunction  ::= Konjunction ('||' Konjunction)*
+[10] Konjunction ::= Negation ('&&' Negation)*
+[11] Negation    ::= '!' Comparison | Comparison
+
+[12] Comparison ::= BOOL | Sum (CMPOP Sum)+
+
+[13] IntExpr  ::= Sum
+[14] Sum      ::= Product (('+' | '-') Product)*
+[15] Product  ::= Value (('*' | '/') Value)*
+[16] Value    ::= NUMBER | VARIABLE | '(' Expression ')'
+
+[17] NUMBER   ::= '-'?[0-9]+
+[18] BOOL     ::= 'true' | 'false' | '(' BoolExpr ')'
+// Note that we do have to exclude 'true' & 'false' because otherwise 'true' & 'false'
+// would be legal Integer expressions as they would be considered variables
+[19] VARIABLE ::= [^('true' | 'false')][a-zA-Z_][a-zA-Z0-9_]* | [a-zA-Z_]
+[20] CMPOP    ::= '<=' | '>=' | '<' | '>' | '==' | '!='

data/lib/pg-verify/ebnf_parser/expressions.peg

@@ -0,0 +1,52 @@
+[1]    Action         ::= Assignment _Action_1
+[1.1]  _Action_1      ::= _Action_2*
+[1.2]  _Action_2      ::= "|" Assignment
+[2]    Guard          ::= BoolExpr
+[3]    Precon         ::= BoolExpr
+[4]    Assignment     ::= VARIABLE ":=" IntExpr
+[5]    Expression     ::= BoolExpr | IntExpr
+[6]    BoolExpr       ::= Equivalence
+[7]    Equivalence    ::= Implication _Equivalence_1
+[7.1]  _Equivalence_1 ::= _Equivalence_2*
+[7.2]  _Equivalence_2 ::= _Equivalence_3 Implication
+[7.3]  _Equivalence_3 ::= "<->" | "<!>"
+[8]    Implication    ::= Disjunction _Implication_1
+[8.1]  _Implication_1 ::= _Implication_2*
+[8.2]  _Implication_2 ::= "->" Disjunction
+[9]    Disjunction    ::= Konjunction _Disjunction_1
+[9.1]  _Disjunction_1 ::= _Disjunction_2*
+[9.2]  _Disjunction_2 ::= "||" Konjunction
+[10]   Konjunction    ::= Negation _Konjunction_1
+[10.1] _Konjunction_1 ::= _Konjunction_2*
+[10.2] _Konjunction_2 ::= "&&" Negation
+[11]   Negation       ::= _Negation_1 | Comparison
+[11.1] _Negation_1    ::= "!" Comparison
+[12]   Comparison     ::= BOOL | _Comparison_1
+[12.1] _Comparison_1  ::= Sum _Comparison_2
+[12.2] _Comparison_2  ::= _Comparison_3+
+[12.3] _Comparison_3  ::= CMPOP Sum
+[13]   IntExpr        ::= Sum
+[14]   Sum            ::= Product _Sum_1
+[14.1] _Sum_1         ::= _Sum_2*
+[14.2] _Sum_2         ::= _Sum_3 Product
+[14.3] _Sum_3         ::= "+" | "-"
+[15]   Product        ::= Value _Product_1
+[15.1] _Product_1     ::= _Product_2*
+[15.2] _Product_2     ::= _Product_3 Value
+[15.3] _Product_3     ::= "*" | "/"
+[16]   Value          ::= NUMBER | VARIABLE | _Value_1
+[16.1] _Value_1       ::= "(" Expression ")"
+[17]   NUMBER         ::= _NUMBER_1 _NUMBER_2
+[17.1] _NUMBER_1      ::= "-"?
+[17.2] _NUMBER_2      ::= _NUMBER_3+
+[17.3] _NUMBER_3      ::= [0-9]
+[18]   BOOL           ::= "true" | "false" | _BOOL_1
+[18.1] _BOOL_1        ::= "(" BoolExpr ")"
+[19]   VARIABLE       ::= _VARIABLE_1 | _VARIABLE_2
+[19.1] _VARIABLE_1    ::= _VARIABLE_3 _VARIABLE_4 _VARIABLE_5
+[19.3] _VARIABLE_3    ::= [^('true'#x20|#x20'false')]
+[19.4] _VARIABLE_4    ::= [a-zA-Z_]
+[19.5] _VARIABLE_5    ::= _VARIABLE_6*
+[19.6] _VARIABLE_6    ::= [a-zA-Z0-9_]
+[19.2] _VARIABLE_2    ::= [a-zA-Z_]
+[20]   CMPOP          ::= "<=" | ">=" | "<" | ">" | "==" | "!="

data/lib/pg-verify/ebnf_parser/parser_result.rb

@@ -0,0 +1,26 @@
+module PgVerify
+    module EbnfParser
+
+        class ParserResult
+
+            attr_accessor :ast
+            attr_accessor :error
+
+            def initialize(ast, error)
+                @ast, @error = ast, error
+            end
+
+            def check!()
+                return unless error?()
+                # TODO: Custom exception
+                raise @error
+            end
+
+            def error?()
+                return !@error.nil?
+            end
+
+        end
+
+    end
+end

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

@@ -0,0 +1,125 @@
+
+module PgVerify
+    module Interpret
+
+        class ComponentContext
+
+            # Name of this component as a symbol
+            attr_accessor :name
+
+            # The list of states of this component as symbols
+            attr_accessor :states_list
+
+            # The list of transitions of this component
+            attr_accessor :transition_list
+
+            # The list of variables which is component has declared
+            # and thus owns
+            attr_accessor :owned_variables
+
+            # Back reference to the parent graph
+            attr_accessor :parent_graph
+
+            # 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
+
+            attr_accessor :init_expressions
+
+            def initialize(name, parent_graph)
+                @name, @parent_graph = name, parent_graph
+                @states_list, @transition_list = [], []
+                @owned_variables = []
+                @init_expressions = []
+                @represents_fault = false
+                @source_location = parent_graph.parent_script.find_source_location()
+            end
+
+            # DSL method for declaring a variable to be owned by this component
+            def var(hash)
+                raise InvalidDSL_var.new("Invalid argument '#{hash}'") unless hash.is_a?(Hash)
+                name = hash.keys.first
+                range = hash[name]
+                raise "Variable name must be different to the component that owns it" if name.to_sym == @name
+                raise InvalidDSL_var.new("Name '#{name}' is not a symbol") unless name.is_a?(Symbol)
+                raise InvalidDSL_var.new("Range '#{range}' is not a range or array") unless range.is_a?(Range) && range.first.is_a?(Integer)
+                sloc = @parent_graph.parent_script.find_source_location()
+                variable = Model::Variable.new(name, range, @name, sloc)
+
+                # The "init" argument can be an expression, or a value out of the
+                # range of that variable
+                if hash.key?(:init)
+                    init_expr = variable.values().include?(hash[:init]) \
+                        ? "#{variable.name} == #{hash[:init]}" \
+                        : hash[:init]
+                    raise "Neither a string, nor a valid initial value: #{hash[:init]}" unless init_expr.is_a?(String)
+                    variable.init_expression = Model::ParsedExpression.new(init_expr, Model::ParsedExpression::TYPE_PL)
+                end
+
+                @owned_variables << variable
+                return variable
+            end
+
+            # DSL method to define states which this component can have
+            def states(*states, init: nil)
+                states.each { |state|
+                    raise InvalidDSL_state.new("State '#{state}' is neither a string or symbol") unless state.is_a?(String) || state.is_a?(Symbol)
+                    raise InvalidDSL_state.new("State '#{state}' was already declared for component '#{name}'") if @states_list.include?(state)
+                    raise InvalidDSL_state.new("Initial state '#{init}' is none of #{state}") unless init.nil? || states.include?(init)
+                }
+                @states_list += states.map(&:to_sym)
+                self.init("#{@name} == #{init}") unless init.nil?
+            end
+
+            # DSL method for the definition of one state
+            def state(state)
+                states(state)
+            end
+
+            # DSL method for the decleration of a transition between states of this component
+            def transition(hash, &blk)
+                raise InvalidDSL_transition.new("Invalid argument '#{hash}'") unless hash.is_a?(Hash)
+                from = hash.keys.first
+                to =  hash[from]
+                [ from, to ].each { |state| 
+                    next if @states_list.include?(state)
+                    raise NoSuchStateError.new(state, self)
+                }
+                transition = TransitionContext.new(self, from, to)
+                transition.instance_eval(&blk) unless blk.nil?
+                @transition_list << transition
+                return transition
+            end
+
+            def init(string)
+                @init_expressions << string
+            end
+
+            def to_model()
+                params = {}
+                # Use the name as is
+                params[:name] = @name
+                # Use states as is
+                params[:states] = @states_list
+                # Convert the transitions to their model representation
+                params[:transitions] = @transition_list.map(&:to_model)
+                params[:represents_fault] = @represents_fault
+                # Pass the source location
+                params[:source_location] = @source_location
+                # Pass the init expression
+                unless @init_expressions.empty?
+                    init_expression = @init_expressions.map { |e| "( #{e} )" }.join(" && ")
+                    init_expression = Model::ParsedExpression.new(init_expression, Model::ParsedExpression::TYPE_PL) 
+                    params[:init_expression] = init_expression
+                end
+                
+                # Create a model component using these params
+                Model::Component.new(params)
+            end
+            
+        end
+
+    end
+end