pg-verify 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '0582b670fd565351fe5f6f01f34e5dd7358f4fd6f2385ced16d7a487c0b65a8d'
+  data.tar.gz: ea5556b7831154f0330e96e145be74fba25a31d5a775dc5e6abc5d32eaba9b03
+SHA512:
+  metadata.gz: fb81fb19377bda7a3c109a5dfb7ee4174c5d529a3133223b784ff814bc68636487664ed07ce8cc6f39eed1cdf99ebd3e20ac027ab5a19da9416f32f6977a5105
+  data.tar.gz: 5453f990cda9252b0be7b9e6c0a71ce8f1d8fc77f064ef5f3f6eb29c03dbb1a5a44f370e54b8137398c02c0a3643a9135558ea5c20066684545618ab60f5de94

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in pg-verify.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"

data/Gemfile.lock

@@ -0,0 +1,98 @@
+PATH
+  remote: .
+  specs:
+    pg-verify (0.1.0)
+      config (~> 4.2.1)
+      ebnf (~> 2.3.4)
+      plantuml_builder (~> 0.3.0)
+      rainbow (~> 3.0.0)
+      thor (~> 1.2.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    concurrent-ruby (1.2.2)
+    config (4.2.1)
+      deep_merge (~> 1.2, >= 1.2.1)
+      dry-validation (~> 1.0, >= 1.0.0)
+    deep_merge (1.2.2)
+    diff-lcs (1.5.0)
+    docopt (0.5.0)
+    dry-configurable (0.13.0)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 0.6)
+    dry-container (0.9.0)
+      concurrent-ruby (~> 1.0)
+      dry-configurable (~> 0.13, >= 0.13.0)
+    dry-core (0.7.1)
+      concurrent-ruby (~> 1.0)
+    dry-inflector (0.2.1)
+    dry-initializer (3.0.4)
+    dry-logic (1.2.0)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 0.5, >= 0.5)
+    dry-schema (1.8.0)
+      concurrent-ruby (~> 1.0)
+      dry-configurable (~> 0.13, >= 0.13.0)
+      dry-core (~> 0.5, >= 0.5)
+      dry-initializer (~> 3.0)
+      dry-logic (~> 1.0)
+      dry-types (~> 1.5)
+    dry-types (1.5.1)
+      concurrent-ruby (~> 1.0)
+      dry-container (~> 0.3)
+      dry-core (~> 0.5, >= 0.5)
+      dry-inflector (~> 0.1, >= 0.1.2)
+      dry-logic (~> 1.0, >= 1.0.2)
+    dry-validation (1.7.0)
+      concurrent-ruby (~> 1.0)
+      dry-container (~> 0.7, >= 0.7.1)
+      dry-core (~> 0.5, >= 0.5)
+      dry-initializer (~> 3.0)
+      dry-schema (~> 1.8, >= 1.8.0)
+    ebnf (2.3.4)
+      htmlentities (~> 4.3)
+      rdf (~> 3.2)
+      scanf (~> 1.0)
+      sxp (~> 1.2)
+      unicode-types (~> 1.8)
+    htmlentities (4.3.4)
+    link_header (0.0.8)
+    matrix (0.4.2)
+    plantuml_builder (0.3.0)
+      docopt (~> 0.5.0)
+    rainbow (3.0.0)
+    rake (13.0.6)
+    rdf (3.2.11)
+      link_header (~> 0.0, >= 0.0.8)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.0)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
+    scanf (1.0.0)
+    sxp (1.2.4)
+      matrix (~> 0.4)
+      rdf (~> 3.2)
+    thor (1.2.1)
+    unicode-types (1.8.0)
+
+PLATFORMS
+  x86_64-darwin-19
+  x86_64-linux
+
+DEPENDENCIES
+  pg-verify!
+  rake (~> 13.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.3.26

data/README.md

@@ -0,0 +1,29 @@
+# PgVerify
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/pg-verify`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add pg-verify
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install pg-verify
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/pg-verify.

data/Rakefile

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+
+task :itest do
+    versions = [ "3.0", "2.6" ]
+    versions.each { |v| test_ruby_version(v) }
+end
+
+
+def test_ruby_version(version)
+
+    message = "Running tests on ruby v#{version}"
+    puts "#" * message.length
+    puts message
+    puts "#" * message.length
+
+    FileUtils.rm_rf(".pg-work")
+    FileUtils.mkdir(".pg-work")
+
+    # Generate docker file
+    dockerfile_path = File.join(".pg-work", "Dockerfile")
+    image_name = "pg-verify-test"
+    dockerfile = [ "FROM ruby:#{version}" ]
+    File.write(dockerfile_path, dockerfile.join("\n"))
+    sh "docker build --file #{dockerfile_path} --tag #{image_name} ."
+
+    test_cmd = []
+    test_cmd << "rm -f Gemfile.lock"
+    test_cmd << "bundle config set without packaging documentation"
+    test_cmd << "gem update --system --silent --no-document"
+    test_cmd << "bundle lock"
+    test_cmd << "bundle install --path /tmp/gems"
+    test_cmd << "ruby --version"
+    test_cmd << "bundle exec rspec"
+    test_cmd << "bundle exec rake build"
+    test_cmd << "gem install pkg/*"
+    test_cmd << "pg-verify --help"
+    test_cmd << "pg-verify doctor"
+    test_cmd = test_cmd.join(" && ")
+
+    docker_run = [ "docker run" ]
+    docker_run << "--rm"
+    docker_run << "--name pg-verify-container"
+    docker_run << "--mount type=bind,source='#{Dir.pwd}',target=/app"
+    docker_run << "--workdir /app"
+    docker_run << image_name
+    docker_run << "bash -c \"#{test_cmd}\""
+    docker_run = docker_run.join(" ")
+
+    sh docker_run
+
+    gem_file = Dir[File.join("pkg", "*.gem")].first
+    FileUtils.mkdir_p("out")
+    out_path = File.join("out", File.basename(gem_file).gsub(".gem", "-r#{version}.gem"))
+    mv gem_file, out_path
+end

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "pg-verify"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/pg-verify.rb

@@ -0,0 +1,18 @@
+require "bundler/setup"
+require 'pg-verify'
+
+module PgVerify
+    
+    class PgVerifyCLI
+
+        def run()
+            begin
+                Cli::BaseCommand.start()
+            rescue Core::Error => e
+                puts e.to_formatted()
+            end
+        end
+
+    end
+
+end

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/calc.ebnf

@@ -0,0 +1,21 @@
+[1] Assignment  ::= VARIABLE ':=' IntExpr
+[2] Expression  ::= BoolExpr
+
+[3] BoolExpr    ::= Equivalence
+[4] Equivalence ::= Implication (('<->' | '<!>') Implication)*
+[5] Implication ::= Disjunction ('=>' Disjunction)*
+[6] Disjunction ::= Konjunction ('||' Konjunction)*
+[7] Konjunction ::= Negation ('&&' Negation)*
+[8] Negation    ::= '!' Comparison | Comparison
+
+[9] Comparison ::= Sum (CMPOP Sum)*
+
+[10] IntExpr  ::= Sum
+[11] Sum      ::= Product (('+' | '-') Product)*
+[12] Product  ::= Value (('*' | '/') Value)*
+[13] Value    ::= NUMBER | BOOL | VARIABLE | '(' Expression ')'
+
+[14] NUMBER   ::= [0-9]+
+[15] BOOL     ::= 'true' | 'false'
+[16] VARIABLE ::= [a-zA-Z_][a-zA-Z0-9_]*
+[17] CMPOP    ::= '<=' | '>=' | '<' | '>' | '==' | '!='

data/data/config/pg-verify.yml

@@ -0,0 +1,66 @@
+# The working directory for temporary files and caches
+workdir: <%= File.expand_path('.pg-work', Dir.pwd) %>
+
+# The default output directory for generated files like images
+outdir: <%= File.expand_path('out', Dir.pwd) %>
+
+# Configuration for the NuSMV addon
+nusmv:
+  # Path the the NuSMV executable. Can be omitted if NuSMV is dropped into the addon/ dir
+  path: null
+
+# Configuration for the PlantUML addon
+puml:
+  active_state_color: "#FF0000/FFFF00"
+  path: null
+
+# Configuration for the Ruby DSL
+ruby_dsl:
+  # Default model definition script file when pg-verify is invoked without arguments
+  default_script_name: "program-graph.rb"
+
+# Enable/Disable colored printing all together
+use_colors: true
+# Enable/Disable colored printing when the output of pg-verify
+# is not piped into a TTY directly.
+use_colors_in_pipe: false
+# Print full stack traces on any error.
+full_stack_trace: false
+# Enable/Disable shell animations
+use_animations: true
+print_loading_times: true
+allow_right_print: true
+
+trace:
+  # Colorize certain values while printing traces
+  colors:
+    Closed: green
+    Open: red
+
+# Colors theme for the TTY
+theme:
+  state: ["deepskyblue", "bold"]
+  trans: [ "springgreen", "italic" ]
+  var:   [ "limegreen", "italic" ]
+  cmp:   ["deepskyblue", "bold", "italic"]
+  num: dodgerblue
+  literal: dodgerblue
+  string: orange
+  success: springgreen
+  warn: khaki
+  error: red
+  sidenote: "darkslategray"
+  file: [ "limegreen", "bold" ]
+  expression: ["deepskyblue", "italic"]
+  command: ["deepskyblue", "italic"]
+
+prompt:
+  prompt_format: " %s"
+  debug:    "D "
+  verbose:  "V "
+  info:     "➜ "
+  warn:     "⚡"
+  error:    "✘ "
+  empty:    "~ "
+  success:  "✓ "
+  question: "» "

data/data/nusmv.sample.smv

@@ -0,0 +1,179 @@
+MODULE cache-device
+
+VAR
+  state : {invalid,shared,owned};
+
+
+DEFINE
+  readable := ((state = shared) | (state = owned)) & !waiting;
+  writable := (state = owned) & !waiting;
+
+ASSIGN
+  init(state) := invalid;
+  next(state) :=
+    case
+      abort : state;
+      master :
+        case
+          CMD = read-shared        : shared;
+          CMD = read-owned         : owned;
+          CMD = write-invalid      : invalid;
+          CMD = write-resp-invalid : invalid;
+          CMD = write-shared       : shared;
+          CMD = write-resp-shared  : shared;
+          TRUE : state;
+        esac;
+      !master & state = shared & (CMD = read-owned | CMD = invalidate) :
+         invalid;
+      state = shared : {shared,invalid};
+      TRUE : state;
+    esac;
+
+DEFINE
+  reply-owned := !master & state = owned;
+
+VAR
+  snoop : {invalid,owned,shared};
+
+ASSIGN
+  init(snoop) := invalid;
+  next(snoop) := 
+    case
+      abort : snoop;
+      !master & state = owned & CMD = read-shared : shared;
+      !master & state = owned & CMD = read-shared : owned;
+      master & CMD = write-resp-invalid : invalid;
+      master & CMD = write-resp-shared  : invalid;
+      TRUE : snoop;
+    esac;
+
+MODULE bus-device
+
+VAR
+  master  : boolean;
+  cmd : {idle,read-shared,read-owned,write-invalid,write-shared,
+	 write-resp-invalid,write-resp-shared,invalidate,response};
+  waiting : boolean;
+  reply-stall : boolean;
+
+ASSIGN
+  init(waiting) := FALSE;
+  next(waiting) :=
+    case
+      abort : waiting;
+      master  & CMD = read-shared        : TRUE;
+      master  & CMD = read-owned         : TRUE;
+      !master & CMD = response           : FALSE;
+      !master & CMD = write-resp-invalid : FALSE;
+      !master & CMD = write-resp-shared  : FALSE;
+      TRUE : waiting;
+    esac;
+
+DEFINE
+  reply-waiting := !master & waiting;
+  abort := REPLY-STALL
+           | ((CMD = read-shared | CMD = read-owned) & REPLY-WAITING);
+
+MODULE processor(CMD,REPLY-OWNED,REPLY-WAITING,REPLY-STALL)
+ISA bus-device
+ISA cache-device
+
+ASSIGN
+  cmd :=
+    case
+      master & state = invalid : {read-shared,read-owned};
+      master & state = shared  : read-owned;
+      master & state = owned & snoop = owned : write-resp-invalid;
+      master & state = owned & snoop = shared : write-resp-shared;
+      master & state = owned & snoop = invalid : write-invalid;
+      TRUE : idle;
+    esac;
+
+MODULE memory(CMD,REPLY-OWNED,REPLY-WAITING,REPLY-STALL)
+VAR
+  master : boolean;
+  cmd : {idle,read-shared,read-owned,write-invalid,write-shared,
+	 write-resp-invalid,write-resp-shared,invalidate,response};
+  busy : boolean;
+  reply-stall : boolean;
+
+
+DEFINE
+  reply-owned := FALSE;
+  reply-waiting := FALSE;
+  abort := REPLY-STALL
+          | (CMD = read-shared | CMD = read-owned) & REPLY-WAITING
+	  | (CMD = read-shared | CMD = read-owned) & REPLY-OWNED;
+
+ASSIGN
+  init(busy) := FALSE;
+  next(busy) :=
+    case
+      abort : busy;
+      master & CMD = response : FALSE;
+      !master & (CMD = read-owned | CMD = read-shared) : TRUE;
+      TRUE : busy;
+    esac;
+  cmd :=
+    case
+      master & busy : {response,idle};
+      TRUE : idle;
+    esac;
+  reply-stall :=
+    case
+      busy & (CMD = read-shared | CMD = read-owned
+	      | CMD = write-invalid | CMD = write-shared
+	      | CMD = write-resp-invalid | CMD = write-resp-shared) : TRUE;
+      TRUE : {FALSE,TRUE};
+    esac;
+
+MODULE main
+VAR
+  CMD : {idle,read-shared,read-owned,write-invalid,write-shared,
+	   write-resp-invalid,write-resp-shared,invalidate,response};
+  p0 : processor(CMD,REPLY-OWNED,REPLY-WAITING,REPLY-STALL);
+  p1 : processor(CMD,REPLY-OWNED,REPLY-WAITING,REPLY-STALL);
+  p2 : processor(CMD,REPLY-OWNED,REPLY-WAITING,REPLY-STALL);
+  m : memory(CMD,REPLY-OWNED,REPLY-WAITING,REPLY-STALL);
+
+DEFINE
+  REPLY-OWNED := p0.reply-owned | p1.reply-owned | p2.reply-owned;
+  REPLY-WAITING := p0.reply-waiting | p1.reply-waiting | p2.reply-waiting;
+  REPLY-STALL := p0.reply-stall | p1.reply-stall | p2.reply-stall |
+	         m.reply-stall;
+
+ASSIGN
+  CMD := 
+    case
+      p1.cmd = idle & p2.cmd = idle & m.cmd = idle : p0.cmd;
+      p0.cmd = idle & p2.cmd = idle & m.cmd = idle : p1.cmd;
+      p0.cmd = idle & p1.cmd = idle & m.cmd = idle : p2.cmd;
+      p0.cmd = idle & p1.cmd = idle & p2.cmd = idle : m.cmd;
+      TRUE : {idle,read-shared,read-owned,write-invalid,write-shared,
+	   write-resp-invalid,write-resp-shared,invalidate,response};
+    esac;
+
+ASSIGN
+  p0.master := {FALSE,TRUE};
+  p1.master :=
+    case
+      p0.master : FALSE;
+      TRUE : {FALSE,TRUE};
+    esac;
+  p2.master :=
+    case
+      p0.master | p1.master : FALSE;
+      TRUE : {FALSE,TRUE};
+    esac;
+  m.master :=
+    case
+      p0.master | p1.master | p2.master : FALSE;
+      TRUE : {FALSE,TRUE};
+    esac;
+
+SPEC
+  AG EF (p0.readable)
+SPEC
+  AG EF (p0.writable)
+SPEC
+  AG !(p0.writable & p1.writable)

data/data/project-template/.gitignore.resource

@@ -0,0 +1,4 @@
+.pg-work/
+addon/
+out/
+.vscode

data/data/project-template/README.md

@@ -0,0 +1,18 @@
+# Welcome to your project 🎉
+
+PG verify is a CLI application which allows you to develop program graph models
+and verify characteristics of those models.
+
+To get started you can run `pg-verify doctor` to verify your installation and guide
+you through the steps needed to install external addons like the NuSMV model checker.
+
+You can always run `pg-verify help` to get a list of available commands.
+For example try running `pg-verify show png` to render a PNG image of your program graph
+and save that to your working directory.
+
+## Project files
+
+There are a couple of prelude files and directories in your project to get you started:
+
+- `program-graph.rb`: This file defines the default program graph you will be working on
+- `addon/`: This is the directory where you will place addon resources like the NuSMV executable.

data/data/project-template/program-graph.rb.resource

@@ -0,0 +1,103 @@
+####################################################################
+# Model definition
+####################################################################
+
+model :FeelThePain do
+
+    # Define a graph called 'Hand'.
+    graph :Hand do
+        # The hand can be touching the fence or be somewhere else
+        # It starts in 'somewhere' as that state is listed first
+        states :somewhere, :at_fence
+
+        # Transition non-deterministically between those states
+        transition :somewhere => :somewhere
+        transition :somewhere => :at_fence
+        transition :at_fence => :somewhere
+        transition :at_fence => :at_fence
+    end
+
+    # Define another graph called 'PowerSwitch', which also
+    # transitions non-deterministically.
+    graph :PowerSwitch do
+        states :off, :on
+        transition :off => :off
+        transition :off => :on
+        transition :on  => :off
+        transition :on  => :on
+    end
+
+    graph :Fence do
+        # The fence has no states we are interested in
+        states :exists
+
+        # The fence has a voltage which can go up to 15
+        var :voltage => (0..12), init: 0
+
+        # The voltage increases when the power switch is on
+        transition :exists => :exists do
+            guard "PowerSwitch == on"
+            action "voltage := voltage + 1"
+        end
+        # ..and instantly stops when the switch is off
+        transition :exists => :exists do
+            guard "PowerSwitch == off"
+            action "voltage := 0"
+        end
+
+    end
+
+    graph :Pain do
+        # We can either be in pain or not
+        states :No, :Yes
+        # Using regular variables with string interpolation
+        pain_threshold = 7
+        transition :No => :Yes do
+            # action "voltage := 2"
+            guard "Hand == at_fence && voltage >= #{pain_threshold}"
+        end
+        transition :Yes => :No do
+            guard "Hand == somewhere || voltage < #{pain_threshold}"
+        end
+    end
+
+    ####################################################################
+    # Validity tests
+    ####################################################################
+
+    # Specification of validity characteristics regarding the hand.
+    # The 'specify' block serves as a namespace/container for the contained specifications
+    specify "The Hand" do
+        # Define some simple specs using a description text and an LTL expression
+        it "isn't always touching the fence"  => :"F Hand == somewhere"
+        it "isn't always away form the fence" => :"F Hand == at_fence"
+    end
+
+    # Specification of validity characteristics regarding the pain
+    specify "The pain" do
+        # Use a regular LTL Formula as the expression
+        it "is felt at some point" => :"F Pain == Yes"
+        # Use a more declarative syntax. This becomes useful for complex expressions
+        # as LTL patterns can be used very easily
+        it "is always felt at some point" => ltl.globally.exists(:"Pain == Yes")
+
+        # Pattern: 'Universality', range: 'after q'
+        it "is felt after the switch is activated" => ltl.after(:"PowerSwitch == on").exists(:"Pain == Yes")
+        # Pattern: 'Absence', range: 'before q'
+        it "is never felt before the switch is activated" => ltl.before(:"PowerSwitch == on").never(:"Pain == Yes")
+        # Pattern: 'Reaction', range: 'global'
+        it "always reacts to the switch being activated"  => ltl.globally.reacts(:"PowerSwitch == on", :"Pain == Yes")
+
+        # Define an assumption. That assumption must be true for all contained specs
+        assuming "the switch is never activated" => :"G PowerSwitch == off" do
+            it "is never felt " => :"G Pain == No"
+        end
+
+        # Assumptions can be nested and used with the declarative syntax.
+        assuming "the switch is activated" => ltl.globally.exists(:"PowerSwitch == No") do
+            assuming "the hand never touches the fence" => :"G Hand != at_fence" do
+                it "is never felt " => :"G Pain == No"
+            end
+        end
+    end
+end

data/devpg

@@ -0,0 +1,5 @@
+#!/bin/sh
+
+# Simple wrapper to run pg-verify during development.
+
+ruby -Ilib ./exe/pg-verify "$@"