adsl 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6b26fde19cd7f72d505d12b67a37e9eb7c76aba2
-  data.tar.gz: 425182f63a8d718786e63dc9f21439c764f9332a
+  metadata.gz: ebe37d86fc7f4beca92d9a2774ea9261f65bd3fa
+  data.tar.gz: 81b1927dd5809ded4855b31283a53222160160e4
 SHA512:
-  metadata.gz: a15fbddc4618acafd6cfe069195656f11ac0ec58ac3d22b36341fa90b0c5a690d15e3ad5c687a0a1c3af134e82093428a93a07737d19f09fcd7241dca437c1a6
-  data.tar.gz: 6f84daa5917019dbf27dc523e693d7eee093329de27826777b85c9ce173a09268751e396cbba04d55984e3bdc48c7363b66c12492b3a74428da06ea75facc5f9
+  metadata.gz: a2d4e8b5fb36b758459a10309ca14fef2007894f73b26301c6eb6c50ed72f7d61a829a7a5fe1606f86e46b0a40488df6950d2a1582bbb96ebd9f5036a9dc839f
+  data.tar.gz: ecd21de07c4f79acd1b7dd4f16240dd02adfb8ba96b0f570e937b48cff376e7925450069898ae9389e88589f15814e8fab2109656538d347b2f83765d10374b6

data/Gemfile

@@ -1,20 +1,2 @@
-source "http://rubygems.org"
-
-# base
-# indentation added to prevent these dependencies when building the gem
-  gem "rake"
-  gem "test-unit"
-  gem "i18n"
-
-# lexer/parser
-gem "rexical"
-gem "racc"
-
-# used all over the place
-gem "active_support"
-
-# terminal color output
-gem "colorize"
-
-# extraction tools
-gem "ruby_parser"
+source 'https://rubygems.org'
+gemspec

data/README.md

@@ -1,17 +1,15 @@
-ADSL - Abstract Data Store Language Parser and Translator
+ADSL - Abstract Data Store Library
 =========================================================
 
-This tool an Abstract Data Store Language (ADSL) specification verification tool.
+ADSL is a gem for formal verification of Ruby on Rails models.  Simply include it in your Gemfile, write a few 
+invariants (rules) about ActiveRecord data that you wish to verify (for example, that at any given moment, every
+Address has a User) and run `rake verify`!
 
-ADSL is a language for specifying Abstract Data Stores using a syntax familiar to anyone that has experience
-with ORM tools such as Hibernate and ActiveRecord. A specification contains the model classes, actions executed
-using a RESTful interface, and a set of invariants to be verified.
+Besides the verification algorithm, this tool includes a DSL for specifying invariants.  The syntax should feel
+natural to any Rails user. Look at /examples.
 
-This tool verifies a specification by translating it into a first order logic theorem verifiable by [Spass] [1],
-a theorem prover. It provides detailed information on the actions and invariants verified in human-readable or
-CSV format.
-
-This tool is distributed as a Ruby gem and is uploaded to [RubyGems.org] [2]. Install it and give it a try!
+This tool is distributed as a Ruby gem and is uploaded to [RubyGems.org] [2]. It requires Spass[1] to run. Install
+it and give it a try!
 
 
 Installation
@@ -20,24 +18,19 @@ Installation
 This gem is tested on 32 and 64 bit Linux. OS-X compatibility not tested, give it a try
 and tell us if it works! Windows is not supported at this moment.
 
- - Ruby 1.8.7 or later required. We suggest using the [Ruby Version Manager](https://rvm.io/rvm/install/) to manage this installation.
+ - Ruby 1.9.3 or later required, along with Rails 3.2.  We suggest using the [Ruby Version Manager](https://rvm.io/rvm/install/) to manage this installation.
  - [Download and install Spass](http://www.spass-prover.org/download/index.html) and make sure its executable (`bin/SPASS`) on your $PATH
  - Install the ADSL gem by running `gem install adsl`.
-   
    If you receive an error while generating documentation for 'activesupport' run `gem install rdoc adsl` instead.
- - Test the installation by verifying [the example specification](https://raw.github.com/Bocete/adsl/master/example/running-example.adsl)
-
+ 
 Usage
 -----
 
-    adsl-verify <specification-file>
-
-For options and other modes of operation, run
-
-    adsl-verify --help
-
-You can download sample ADSL specifications 
+    rake verify <options>
+    
+Or, to just observe the extracted model,
 
+    rake adsl_translate
 
 Development
 -----------

data/bin/adsl-verify

@@ -9,7 +9,7 @@ options.language = 'spass'
 options.halt_on_error = false
 options.check_satisfiability = true
 options.timeout = 30
-options.csv_output = false
+options.output = 'terminal'
 options.actions = nil
 options.invariants = nil
 
@@ -36,10 +36,10 @@ OptionParser.new do |opts|
     options.check_satisfiability = check
   end
 
-  opts.on("-s", "--stats-csv",
-          "Output the results of the verification with stats in CSV form.",
-          "  Default: #{options.csv_output}") do
-    options.csv_output = true
+  opts.on("-o", "--output-format FORMAT",
+          "Sets the output format. Options: terminal, csv, or silent", 
+          "  Default: #{options.output}") do |format|
+    options.output = format
   end
 
   opts.on("-t", "--timeout TIMEOUT", Integer,
@@ -87,14 +87,14 @@ $LOAD_PATH.unshift GEM_LIB_PATH unless $LOAD_PATH.include? GEM_LIB_PATH
 
 case options.language
 when 'spass'
-  require 'spass/bin'
-  include Spass::Bin
+  require 'adsl/spass/bin'
+  include ADSL::Spass::Bin
   begin
     verify(input,
       :halt_on_error => options.halt_on_error,
       :check_satisfiability => options.check_satisfiability,
       :timeout => options.timeout,
-      :csv_output => options.csv_output,
+      :output => options.output,
       :actions => options.actions,
       :invariants => options.invariants)
   rescue Exception => e

data/lib/adsl.rb

@@ -0,0 +1,3 @@
+module ADSL
+  require 'adsl/railtie' if defined?(Rails)
+end

data/lib/adsl/adsl.rb

@@ -0,0 +1,3 @@
+module ADSL
+  require 'adsl/realtie' if refined?(Rails)
+end

data/lib/adsl/ds/data_store_spec.rb

@@ -0,0 +1,339 @@
+require 'adsl/util/general'
+
+module ADSL
+  module DS
+    class DSNode
+      def list_entity_classes_written_to
+        recursively_gather :entity_class_writes
+      end
+
+      def list_entity_classes_read
+        recursively_gather :entity_class_reads
+      end
+
+      def replace(what, with)
+        to_inspect = [self]
+        inspected = Set.new
+        replaced = false
+        while not to_inspect.empty?
+          elem = to_inspect.pop
+          if elem.kind_of? Array
+            elem.length.times do |i|
+              if elem[i] == what
+                elem[i] = with
+                replaced = true
+              else
+                to_inspect << elem[i] unless inspected.include? elem[i]
+              end
+              inspected << elem[i]
+            end
+          elsif elem.class.methods.include? 'container_for_fields' or elem.class.methods.include? :container_for_fields
+            elem.class.container_for_fields.each do |field_name|
+              field_val = elem.send field_name
+              if field_val == what
+                elem.send "#{field_name}=", with
+                replaced = true
+              elsif field_val.kind_of?(Array) or field_val.class.methods.include?('container_for_fields')
+                to_inspect << field_val unless inspected.include? field_val
+              end
+              inspected << field_val
+            end
+          end
+        end
+        replaced
+      end
+    end
+    
+    class DSSpec < DSNode
+      container_for :classes, :actions, :invariants
+    end
+
+    class DSClass < DSNode
+      container_for :name, :parent, :relations, :inverse_relations do
+        @relations = [] if @relations.nil?
+        @inverse_relations = [] if @inverse_relations.nil?
+      end
+
+      def to_s
+        @name
+      end
+
+      def superclass_of?(other_class)
+        until other_class.nil?
+          return true if other_class == self
+          other_class = other_class.parent
+        end
+        return false
+      end
+
+      def self.common_supertype(classes)
+        types = classes.uniq
+        types.delete nil
+        while types.length > 1
+          type1 = types.pop
+          type2 = types.pop
+          if type1.superclass_of? type2
+            types << type2
+          elsif type2.superclass_of? type1
+            types << type1
+          else
+            raise ADSLError, "Object sets are not of compatible types: #{classes.map { |c| c.name }.join(", ")}"
+          end
+        end
+        types.first
+      end
+    end
+
+    class DSRelation < DSNode
+      container_for :cardinality, :from_class, :to_class, :name, :inverse_of
+
+      def to_s
+        "#{from_class.name}.#{name}"
+      end
+    end
+
+    class DSAction < DSNode
+      container_for :name, :args, :cardinalities, :block
+
+      def statements
+        @block.statements
+      end
+    end
+
+    class DSBlock < DSNode
+      container_for :statements
+    end
+
+    class DSAssignment < DSNode
+      container_for :var, :objset
+    end
+
+    class DSCreateObj < DSNode
+      container_for :klass
+      
+      def entity_class_writes
+        Set[@klass]
+      end
+    end
+    
+    class DSCreateObjset < DSNode
+      container_for :createobj
+
+      def type
+        @createobj.klass
+      end
+    end
+
+    class DSCreateTup < DSNode
+      container_for :objset1, :relation, :objset2
+    end
+
+    class DSDeleteObj < DSNode
+      container_for :objset
+      
+      def entity_class_writes
+        Set[@objset.type]
+      end
+    end
+
+    class DSDeleteTup < DSNode
+      container_for :objset1, :relation, :objset2
+    end
+
+    class DSEither < DSNode
+      container_for :blocks, :lambdas
+    end
+    
+    class DSEitherLambdaObjset < DSNode
+      container_for :either, :vars
+    end
+
+    class DSForEachCommon < DSNode
+      container_for :objset, :block
+    end
+
+    class DSForEach < DSForEachCommon
+    end
+
+    class DSFlatForEach < DSForEachCommon
+    end
+
+    class DSForEachIteratorObjset < DSNode
+      container_for :for_each
+
+      def typecheck_and_resolve(context)
+        self
+      end
+
+      def type
+        @for_each.objset.type
+      end
+    end
+
+    class DSForEachPreLambdaObjset < DSNode
+      container_for :for_each, :before_var, :inside_var
+    end
+    
+    class DSForEachPostLambdaObjset < DSNode
+      container_for :for_each, :before_var, :inside_var
+    end
+
+    class DSVariable < DSNode
+      container_for :name, :type
+    end
+
+    class DSAllOf < DSNode
+      container_for :klass
+      
+      def type
+        @klass
+      end
+
+      def entity_class_reads
+        @klass
+      end
+    end
+
+    class DSSubset < DSNode
+      container_for :objset
+
+      def type
+        @objset.type
+      end
+    end
+
+    class DSUnion < DSNode
+      container_for :objsets
+
+      def type
+        DSClass.common_supertype objsets.reject{ |o| o.type.nil? }.map{ |o| o.type }
+      end
+    end
+
+    class DSOneOfObjset < DSNode
+      container_for :objsets
+
+      def type
+        DSClass.common_supertype objsets.reject{ |o| o.type.nil? }.map{ |o| o.type }
+      end
+    end
+
+    class DSOneOf < DSNode
+      container_for :objset
+      def type
+        @objset.type
+      end
+    end
+
+    class DSDereference < DSNode
+      container_for :objset, :relation
+
+      def type
+        @relation.to_class
+      end
+    end
+
+    class DSEmptyObjset < DSNode
+      container_for
+
+      def type
+        nil
+      end
+    end
+
+    class DSInvariant < DSNode
+      container_for :name, :formula
+    end
+
+    class DSBoolean < DSNode
+      container_for :bool_value
+
+      TRUE = DSBoolean.new :bool_value => true
+      FALSE = DSBoolean.new :bool_value => false
+
+      def type
+        :formula
+      end
+    end
+
+    class DSForAll < DSNode
+      container_for :vars, :objsets, :subformula
+
+      def type
+        :formula
+      end
+    end
+    
+    class DSExists < DSNode
+      container_for :vars, :objsets, :subformula
+
+      def type
+        :formula
+      end
+    end
+
+    class DSIn < DSNode
+      container_for :objset1, :objset2
+      
+      def type
+        :formula
+      end
+    end
+    
+    class DSEmpty < DSNode
+      container_for :objset
+      
+      def type
+        :formula
+      end
+    end
+
+    class DSNot < DSNode
+      container_for :subformula
+
+      def type
+        :formula
+      end
+    end
+    
+    class DSAnd < DSNode
+      container_for :subformulae
+
+      def type
+        :formula
+      end
+    end
+    
+    class DSOr < DSNode
+      container_for :subformulae
+
+      def type
+        :formula
+      end
+    end
+
+    class DSImplies < DSNode
+      container_for :subformula1, :subformula2
+
+      def type
+        :formula
+      end
+    end
+    
+    class DSEquiv < DSNode
+      container_for :subformulae
+
+      def type
+        :formula
+      end
+    end
+    
+    class DSEqual < DSNode
+      container_for :objsets
+
+      def type
+        :formula
+      end
+    end
+  end
+end