pg-verify 0.1.0

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

@@ -0,0 +1,180 @@
+module PgVerify
+    module Doctor
+
+        Warning = Struct.new(:title, :text)
+
+        class DoctorError < PgVerify::Core::Error
+            def initialize(warnings)
+                @warnings = warnings
+            end
+            def formatted()
+                is_are, s = @warnings.length == 1 ? ["is", ""] : ["are", "s"]
+                header = "There #{is_are} #{@warnings.length} warning#{s} for your installation:"
+                string = @warnings.each_with_index.map { |w, i|
+                    title = "#{i + 1}) #{w.title}".c_warn
+                    body  = w.text.indented(str: "   ")
+                    "#{title}\n#{body}"
+                }.join("\n\n")
+                return header, string
+            end
+        end
+
+        def self.check()
+            checks = Doctor.methods
+                .select { |method| method.to_s.start_with?("check_") }
+                .map { |sym| sym.to_s.sub("check_", "").to_sym }
+                .sort
+            warnings = checks.map { |check| run_check(check) }.flatten.compact
+            raise DoctorError.new(warnings) unless warnings.empty?
+        end
+
+        def self.run_check(symbol)
+            Shell::LoadingPrompt.while_loading("Checking #{symbol.to_s.gsub('_', ' ').c_string}") {
+                warnings = ([self.send(:"check_#{symbol}")] || []).flatten.compact
+                state = warnings.empty? ? :success : :error
+                msg   = warnings.empty? ? "Ok" : "#{warnings.length} warning(s)!"
+                # Allow returning :skip from the check to mark the check as skipped
+                if warnings.length == 1 && warnings.first == :skip
+                    state, msg, warnings = :empty, "Skipped!", []
+                end
+                Shell::LoadingPrompt::LoadingResult.new(warnings, msg, state: state)
+            }
+        end
+
+        def self.check_01_Can_find_NuSMV()
+            return [] unless PgVerify::NuSMV::Runner.new.find_nusmv_path.nil?
+            return Warning.new("Unable to locate the NuSMV executable", 
+                "Make sure to install NuSMV by unpacking it and placing the entire folder into\n" \
+                "the #{'addon'.c_file} directory of your project. " \
+                "(#{File.expand_path('addon').c_sidenote})\n" \
+                "Alternatively you can set the #{'nusmv.path'.c_string} in the configuration."
+            )
+        end
+
+        def self.check_02_Can_run_NuSMV()
+            path = PgVerify::NuSMV::Runner.new.find_nusmv_path
+            return :skip if path.nil?
+
+            # Test by evaluating some example smv file
+            example_file = File.join(PgVerify.root, "data", "nusmv.sample.smv")
+            return [] if Core::CMDRunner.run_for_exit_code("#{path} #{example_file}") == 0
+
+            return Warning.new("Unable to run the NuSMV executable", 
+                "NuSMV could be found here: #{path.c_file}\n" \
+                "However it could not be executed. Here are a few things to try:\n" \
+                " - Make sure the file is executable\n" \
+                " - Make sure you have the required permissions"
+            )
+        end
+
+        def self.check_03_Run_integration_tests()
+            return :skip if PgVerify::NuSMV::Runner.new.find_nusmv_path.nil?
+
+            warnings = []
+
+            test_files = Dir[File.join(PgVerify.root, "integration_tests", "ruby_dsl", "*.rb")].sort
+            warnings += test_files.map { |test_file|
+                model = Interpret::PgScript.new.interpret(test_file).first
+                PgVerify::Model::Validation.validate!(model)
+                results = NuSMV::Runner.new().run_specs(model)
+                failures = results.reject(&:success)
+                next if failures.empty?
+
+                test_name = File.basename(test_file, '.*').gsub("_", "-")
+                failures_s = failures.map { |f| "#{f.spec.text} (#{f.spec.expression.to_s.c_blue})" }
+                show_command = "$ pg-verify show nusmv --script #{File.expand_path(test_file)}".c_cyan
+                test_command = "$ pg-verify test --script #{File.expand_path(test_file)}".c_cyan
+                Warning.new("Failed integration test in #{test_name}", 
+                   "The test #{test_name.c_string} contains the following unsatisfied specifications:\n" \
+                   "\t- #{failures_s.join("\n\t- ")}\n" \
+                   "These specifications should be valid if pg-verify works as expected.\n" \
+                   "You can use the following commands to debug this:\n" \
+                   "  #{show_command}\n  #{test_command}"
+                )
+            }.compact
+
+            warnings += test_files.map { |test_file|
+                model = Interpret::PgScript.new.interpret(test_file).first
+                next if model.hazards.empty?
+                require 'set'
+
+                dcca = Model::DCCA.new(model, NuSMV::Runner.new)
+                result = dcca.perform()
+
+                expected_cut_sets = File.read(test_file)
+                    .split("\n")
+                    .find { |l| l.include?("Expected Cut Sets") }
+                    .scan(/\{([^}]+)\}/).flatten
+                    .map { |string| string.split(",").map(&:strip).map(&:to_sym) }
+                    .map { |cut_set| Set.new(cut_set) }
+
+                actual_cut_sets = result.values.first.map { |cut_set| Set.new(cut_set) }
+                
+                next if Set.new(actual_cut_sets) == Set.new(expected_cut_sets)
+                
+                Warning.new("Failed DCCA for #{File.basename(test_file)}",
+                   "The DCCA for hazard #{result.keys.first.expression.to_s.c_blue} yielded unexpected cut sets:\n" \
+                   "Expected: #{expected_cut_sets}\n" \
+                   "Got     : #{actual_cut_sets}\n"
+                )
+            }.compact
+
+
+            return warnings
+        end
+
+        def self.check_04_Check_project_files()
+            warnings = []
+            script = Settings.ruby_dsl.default_script_name
+
+            return Warning.new("Failed to find model definition at #{script}", 
+                "If you run PG verify without any arguments it expects a program graph definition\n" \
+                "at your working directory, which should be named #{script.c_file} by default.\n" \
+                "Based on your current working directory this would be this full path:\n" \
+                "\t#{File.expand_path(script).c_file}"
+            ) unless File.file?(script)
+
+            begin 
+                Interpret::PgScript.new.interpret(script)
+            rescue Exception => e
+                return Warning.new("Failed to interpret model at #{script}", 
+                    "Your default model definition at #{script.c_file}\n" \
+                    "(Full path: #{File.expand_path(script).c_sidenote})\n" \
+                    "Could not be interpreted. Make sure there are no syntax errors."
+                ) 
+            end
+
+            return []
+        end
+
+        # def self.check_03_Can_find_PlantUML()
+        #     return [] unless PgVerify::Puml.find_path.nil?
+        #     return Warning.new("Unable to find the PlantUML executable", 
+        #         "Make sure to install PlantUML by dropping the jar into\n" \
+        #         "the #{'addon'.c_file} directory of your project. " \
+        #         "(#{File.expand_path('addon').c_sidenote})\n" \
+        #         "You can get it from here: #{"https://plantuml.com/download".c_string}\n" \
+        #         "pg-verify will fall back to using the PlantUML web-server otherwise."
+        #     )
+        # end
+
+        # def self.check_04_Can_run_PlantUML()
+        #     path = PgVerify::Puml.find_path
+        #     return :skip if path.blank?
+
+        #     return [] if Core::CMDRunner.run_for_exit_code("java -jar #{path} -help") == 0
+        #     puts "java -jar #{path} -help"
+
+        #     return Warning.new("Unable to run the PlantUML executable",
+        #         "PlantUML could be found here: #{path.c_file}\n" \
+        #         "However it could not be executed. Here are a few things to try:\n" \
+        #         " - Make sure the file is executable\n" \
+        #         " - Make sure you have the required permissions"
+        #     )
+        # end
+
+    end
+end
+
+# Require all module files
+Dir[File.join(__dir__, "**", '*.rb')].sort.each { |file| require file }

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

@@ -0,0 +1,31 @@
+module PgVerify
+    module EbnfParser
+
+        class Ast
+
+            attr_accessor :map
+
+            def initialize(map)
+                @map = map
+            end
+
+            def find_variables(element=@map)
+                # TODO: Actually parse the variables
+                # puts "REC #{element.class}: #{element}"
+                # puts "\n"
+                # ret = []
+                # ret += element.map { |val| find_variables(val) }.flatten if element.is_a?(Array)
+                # element.each { |key, value| 
+                #     # We found a variable if we found a value which is not a number nor a boolean constant
+                #     if key == :Value && value.is_a?(String) && !(/\d+/.match?(value)) && value != 'true' && value != 'false'
+                #         ret << value
+                #     end
+                #     ret += find_variables(value)
+                # }  if element.is_a?(Hash)
+                # return ret
+            end
+
+        end
+
+    end
+end

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

@@ -0,0 +1,26 @@
+require 'ebnf'
+require 'ebnf/terminals'
+require 'ebnf/peg/parser'
+require 'sxp'
+require 'logger'
+require 'json'
+
+# Require all module files
+Dir[File.join(__dir__, "**", '*.rb')].sort.each { |file| require file }
+
+module PgVerify
+    module EbnfParser
+
+        def self.parse_expression(expression, type: :Expression)
+            parser = ExpressionParser.new(type: type)
+            error, ast = nil, nil
+            begin
+                ast = parser.parse!(expression)
+            rescue EBNF::PEG::Parser::Error => e 
+                error = e
+            end
+            return ParserResult.new(ast, error)
+        end
+
+    end
+end

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

@@ -0,0 +1,177 @@
+module PgVerify
+    module EbnfParser
+
+        class ExpressionParser
+            include EBNF::PEG::Parser
+        
+            # Abstract syntax tree from parse
+            attr_reader :ast
+            attr_accessor :rules
+            attr_accessor :options
+            attr_accessor :type
+
+
+            # production(:Assignment, clear_packrat: true) do |value|
+            #     # puts"Assignment:".ljust(25) + " #{value}"
+            #     value
+            # end
+
+            # production(:BoolExpr, clear_packrat: true) do |value|
+            #     # puts"BoolExpr:".ljust(25) + " #{value}"
+            #     value
+            # end
+
+            # production(:Equivalence, clear_packrat: true) do |value|
+            #     # puts"Equivalence:".ljust(25) + " #{value}"
+            #     value
+            # end
+
+            # production(:Implication, clear_packrat: true) do |value|
+            #     # puts"Implication:".ljust(25) + " #{value}"
+            #     value
+            # end
+
+            # production(:Disjunction, clear_packrat: true) do |value|
+            #     # puts"Disjunction:".ljust(25) + " #{value}"
+            #     value
+            # end
+
+            # production(:Konjunction, clear_packrat: true) do |value|
+            #     # puts"Konjunction:".ljust(25) + " #{value}"
+            #     value
+            # end
+
+            # production(:Negation, clear_packrat: true) do |value|
+            #     puts"Negation:".ljust(25) + "#{value.class} #{value}"
+            #     value
+            # end
+
+            # production(:Comparison, clear_packrat: true) do |value|
+            #     # puts"Comparison:".ljust(25) + " #{value}"
+            #     value
+            # end
+
+            # production(:IntExpr, clear_packrat: true) do |value|
+            #     # puts"IntExpr:".ljust(25) + " #{value}"
+            #     value
+            # end
+
+            # production(:Sum, clear_packrat: true) do |value|
+            #     # puts"Sum:".ljust(25) + " #{value}"
+            #     value
+            # end
+
+            # production(:Product, clear_packrat: true) do |value|
+            #     # puts"Product:".ljust(25) + " #{value}"
+            #     valuex
+            # end
+
+
+
+            # [{:Value=>"3"}, {:_Product_1=>"* 5 * 5"}]
+            production(:Product) do |value|
+                val = value.first[:Value]
+                prod1 = value.last[:_Product_1]
+                ret = "#{val} #{prod1}"
+                puts"Product:".ljust(25) + " #{value} -> #{ret}"
+                ret
+            end
+
+            # A list of product operations plus values ['+ 4', '+ 4']
+            production(:_Product_1) do |value|
+                ret = value.join(' ')
+                # puts"Product1:".ljust(25) + " #{value} -> #{ret}"
+                ret
+            end
+
+            # A product operation plus value '+ 4'
+            production(:_Product_2) do |value|
+                op  = value.first[:_Product_3]
+                val = value.last[:Value]
+                ret = "#{op} #{val}"
+                puts "Product2:".ljust(25) + " #{value} -> #{ret}"
+                ret
+            end
+
+            # A product operation '*' '/'
+            production(:_Product_3) do |value|
+                operation = value
+                value
+            end
+
+            # An atomic value like '3', 'true' or 'variable'
+            production(:Value) do |value|
+                value
+            end
+            # An expression in braces 
+            production(:_Value_1) do |value|
+                value.is_a?(Hash) ? value[:Expression] : value
+            end
+            # A number like '42' or '-7'
+            production(:NUMBER) do |value|
+                value
+            end
+            # A boolean value like 'true' or 'false'
+            production(:BOOL) do |value|
+                value
+            end
+            # A boolean expression in braces like '(3 < 2 <-> true)'
+            production(:_BOOL_1) do |value|
+                value.is_a?(Hash) ? value[:BoolExpr] : value
+                value
+            end
+            # Integer comparison operators like '>' and '!='
+            production(:CMPOP) do |value|
+                value
+            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
+
+                skeletton = EBNF.parse(File.open(ebnf_file)).make_peg.to_s.split("\n").reverse.map { |line|
+                    rule = line.split(/\s+/)[1]
+                    comment = "# Rule: '#{line.split(/\s+/).join(" ")}'"
+                    puts_line = 'puts "' + rule + ': \'#{input}\' -> \'#{output}\'"'
+                    body    = "\toutput = input\n\t#{puts_line}\n\toutput"
+                    method =  "production(:#{rule}) do |input|\n#{body}\nend"
+                    [comment, method].join("\n")
+                }.join("\n\n")
+                File.write(File.expand_path("expressions.rb", __dir__), skeletton)
+
+                # TODO: Remove 
+                File.write(File.expand_path("expressions.peg", __dir__), EBNF.parse(File.open(ebnf_file)).make_peg)
+            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