adsl 0.0.2 → 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6b26fde19cd7f72d505d12b67a37e9eb7c76aba2
+  data.tar.gz: 425182f63a8d718786e63dc9f21439c764f9332a
+SHA512:
+  metadata.gz: a15fbddc4618acafd6cfe069195656f11ac0ec58ac3d22b36341fa90b0c5a690d15e3ad5c687a0a1c3af134e82093428a93a07737d19f09fcd7241dca437c1a6
+  data.tar.gz: 6f84daa5917019dbf27dc523e693d7eee093329de27826777b85c9ce173a09268751e396cbba04d55984e3bdc48c7363b66c12492b3a74428da06ea75facc5f9

data/Gemfile

@@ -7,7 +7,7 @@ source "http://rubygems.org"
   gem "i18n"
 
 # lexer/parser
-gem "rex"
+gem "rexical"
 gem "racc"
 
 # used all over the place
@@ -15,3 +15,6 @@ gem "active_support"
 
 # terminal color output
 gem "colorize"
+
+# extraction tools
+gem "ruby_parser"

data/README.md

@@ -1,11 +1,32 @@
 ADSL - Abstract Data Store Language Parser and Translator
 =========================================================
 
-This package contains adsl, a Ruby gem for verifying ADSL specifications.
+This tool an Abstract Data Store Language (ADSL) specification verification tool.
+
+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.
+
+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!
+
 
 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.
+ - [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
 -----
 
@@ -14,28 +35,31 @@ Usage
 For options and other modes of operation, run
 
     adsl-verify --help
-  
+
+You can download sample ADSL specifications 
+
+
 Development
 -----------
 
 ### Source Repository
 
-The ADSL gem is currently hosted at github. The github web page is
-http://github.com/Bocete/adsl. The public git clone URL is
+The ADSL gem is currently hosted at github. The github web page is http://github.com/Bocete/adsl.
+You can download the source using our public git clone URL:
 
     git://github.com/Bocete/adsl.git
 
 ### Issues and Bug Reports
 
-Feature requests and bug reports can be made here
+Feature requests and bug reports can be made at https://github.com/Bocete/adsl/issues
 
-    https://github.com/Bocete/adsl/issues
 
 License
 -------
 
 Rake is available under a [Lesser GPL (LGPL) license](LICENSE).
 
+
 Warranty
 --------
 
@@ -43,3 +67,6 @@ This software is provided "as is" and without any express or
 implied warranties, including, without limitation, the implied
 warranties of merchantibility and fitness for a particular
 purpose.
+
+  [1]: http://www.spass-prover.org/ "Spass"
+  [2]: https://rubygems.org/gems/adsl "RubyGems.org"

data/lib/ds/data_store_spec.rb

@@ -12,7 +12,7 @@ module DS
 
     def replace(what, with)
       to_inspect = [self]
-      inspected = Set[]
+      inspected = Set.new
       replaced = false
       while not to_inspect.empty?
         elem = to_inspect.pop
@@ -26,7 +26,7 @@ module DS
             end
             inspected << elem[i]
           end
-        elsif elem.class.methods.include? 'container_for_fields'
+        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

data/lib/fol/first_order_logic.rb

@@ -1,4 +1,3 @@
-require 'rubygems'
 require 'active_support/all'
 require 'util/util'
 
@@ -247,12 +246,12 @@ module FOL
     end
   end
 
-  # define a function for each of the above classes, starting with underscore and underscored* afterwards
+  # define a method for each of the above classes, starting with underscore and underscored* afterwards
   # *see: http://api.rubyonrails.org/v2.3.8/classes/ActiveSupport/CoreExtensions/String/Inflections.html
   self.constants.each do |klass_name|
     instance_eval do
-      klass = FOL.const_get(klass_name)
-      self.send :define_method, "_#{klass_name.underscore}".to_sym do |*args|
+      klass = FOL.const_get klass_name
+      send :define_method, "_#{klass_name.to_s.underscore}".to_sym do |*args|
         klass.new(*args).resolve_spass
       end
     end

data/lib/parser/adsl_ast.rb

@@ -214,7 +214,7 @@ module ADSL
       # name => [astnode, dsobj]
       @classes = ActiveSupport::OrderedHash.new
       # classname => name => [astnode, dsobj]
-      @relations = ActiveSupport::OrderedHash.new { |hash, key| hash[key] = ActiveSupport::OrderedHash.new }
+      @relations = ActiveSupport::OrderedHash.new{ |hash, key| hash[key] = ActiveSupport::OrderedHash.new }
       # stack of name => [astnode, dsobj]
       @actions = ActiveSupport::OrderedHash.new
       @invariants = []
@@ -234,10 +234,7 @@ module ADSL
       end
       @actions = source.actions.dup
       @invariants = source.invariants.dup
-      @var_stack = []
-      source.var_stack.each do |frame|
-        @var_stack << frame.dup
-      end
+      @var_stack = source.var_stack.map{ |frame| frame.dup }
     end
     
     def on_var_write(&block)
@@ -312,10 +309,10 @@ module ADSL
     def self.context_vars_that_differ(*contexts)
       vars_per_context = []
       contexts.each do |context|
-        vars_per_context << context.var_stack.inject({}) { |so_far, frame| so_far.merge! frame }
+        vars_per_context << context.var_stack.inject(ActiveSupport::OrderedHash.new) { |so_far, frame| so_far.merge! frame }
       end
       all_vars = vars_per_context.map{ |c| c.keys }.flatten.uniq
-      packed = {}
+      packed = ActiveSupport::OrderedHash.new
       all_vars.each do |v|
         packed[v] = vars_per_context.map{ |vpc| vpc[v][1] }
       end
@@ -466,23 +463,25 @@ module ADSL
 
     def typecheck_and_resolve(context)
       context.push_frame
+
       contexts = [context]
-      (1..@blocks.length-1).each do |i|
+      (@blocks.length-1).times do
         contexts << context.dup
       end
-     
+
       blocks = []
       @blocks.length.times do |i|
         blocks << @blocks[i].typecheck_and_resolve(contexts[i])
       end
 
-      contexts.each do |context|
-        context.pop_frame
+      contexts.each do |c|
+        c.pop_frame
       end
 
       either = DS::DSEither.new :blocks => blocks
 
       lambdas = []
+
       ADSLTypecheckResolveContext::context_vars_that_differ(*contexts).each do |var_name, vars|
         var = DS::DSVariable.new :name => var_name, :type => vars.first.type
         objset = DS::DSEitherLambdaObjset.new :either => either, :vars => vars

data/lib/parser/adsl_parser.racc

@@ -138,8 +138,8 @@ module ADSL
 
 # generated by racc
   def generate_ast(str)
-    scan_evaluate str
-    do_parse
+    scan str
+    # do_parse
   end
 
   def parse(str)

data/lib/parser/adsl_parser.rex

@@ -42,7 +42,7 @@ rule
   =              { [text, lineno] }
   \+             { [text, lineno] }
   [01]           { [text, lineno] }
-  \w+            { [:IDENT, ADSLIdent.new(:lineno => lineno, :text => text)] }
+  \w+            { [:IDENT, ADSL::ADSLIdent.new(:lineno => lineno, :text => text)] }
   \s              # blank, no action
   .              { [:unknown_symbol, [text, lineno]] }
 end

data/lib/parser/adsl_parser.rex.rb

@@ -1,196 +1,199 @@
 #--
 # DO NOT MODIFY!!!!
-# This file is automatically generated by rex 1.0.2
+# This file is automatically generated by rex 1.0.5
 # from lexical definition file "./lib/parser/adsl_parser.rex".
 #++
 
 require 'racc/parser'
 require 'parser/adsl_ast'
 
-module ADSL
-class ADSLParser < Racc::Parser
+class ADSL::ADSLParser < Racc::Parser
   require 'strscan'
 
   class ScanError < StandardError ; end
 
-  attr_reader :lineno
-  attr_reader :filename
+  attr_reader   :lineno
+  attr_reader   :filename
+  attr_accessor :state
 
-  def scan_setup ; end
+  def scan_setup(str)
+    @ss = StringScanner.new(str)
+    @lineno =  1
+    @state  = nil
+  end
 
-  def action &block
+  def action
     yield
   end
 
-  def scan_str( str )
-    scan_evaluate  str
+  def scan_str(str)
+    scan_setup(str)
     do_parse
   end
+  alias :scan :scan_str
 
   def load_file( filename )
     @filename = filename
     open(filename, "r") do |f|
-      scan_evaluate  f.read
+      scan_setup(f.read)
     end
   end
 
   def scan_file( filename )
-    load_file  filename
+    load_file(filename)
     do_parse
   end
 
+
   def next_token
-    @rex_tokens.shift
+    return if @ss.eos?
+    
+    # skips empty actions
+    until token = _next_token or @ss.eos?; end
+    token
   end
 
-  def scan_evaluate( str )
-    scan_setup
-    @rex_tokens = []
-    @lineno  =  1
-    ss = StringScanner.new(str)
-    state = nil
-    until ss.eos?
-      text = ss.peek(1)
-      @lineno  +=  1  if text == "\n"
-      case state
-      when nil
-        case
-        when (text = ss.scan(/\/\/[^\n\z]*/))
-          ;
+  def _next_token
+    text = @ss.peek(1)
+    @lineno  +=  1  if text == "\n"
+    token = case @state
+    when nil
+      case
+      when (text = @ss.scan(/\/\/[^\n\z]*/))
+        ;
 
-        when (text = ss.scan(/\#[^\n\z]*/))
-          ;
+      when (text = @ss.scan(/\#[^\n\z]*/))
+        ;
 
-        when (text = ss.scan(/\/\*(?:[^\*]*(?:\*+[^\/]+)?)*\*\//))
-          ;
+      when (text = @ss.scan(/\/\*(?:[^\*]*(?:\*+[^\/]+)?)*\*\//))
+        ;
 
-        when (text = ss.scan(/class\b/))
-           @rex_tokens.push action { [:class, lineno] }
+      when (text = @ss.scan(/class\b/))
+         action { [:class, lineno] }
 
-        when (text = ss.scan(/extends\b/))
-           @rex_tokens.push action { [:extends, lineno] }
+      when (text = @ss.scan(/extends\b/))
+         action { [:extends, lineno] }
 
-        when (text = ss.scan(/inverseof\b/))
-           @rex_tokens.push action { [:inverseof, lineno] }
+      when (text = @ss.scan(/inverseof\b/))
+         action { [:inverseof, lineno] }
 
-        when (text = ss.scan(/create\b/))
-           @rex_tokens.push action { [:create, lineno] }
+      when (text = @ss.scan(/create\b/))
+         action { [:create, lineno] }
 
-        when (text = ss.scan(/delete\b/))
-           @rex_tokens.push action { [:delete, lineno] }
+      when (text = @ss.scan(/delete\b/))
+         action { [:delete, lineno] }
 
-        when (text = ss.scan(/foreach\b/))
-           @rex_tokens.push action { [:foreach, lineno] }
+      when (text = @ss.scan(/foreach\b/))
+         action { [:foreach, lineno] }
 
-        when (text = ss.scan(/either\b/))
-           @rex_tokens.push action { [:either, lineno] }
+      when (text = @ss.scan(/either\b/))
+         action { [:either, lineno] }
 
-        when (text = ss.scan(/action\b/))
-           @rex_tokens.push action { [:action, lineno] }
+      when (text = @ss.scan(/action\b/))
+         action { [:action, lineno] }
 
-        when (text = ss.scan(/or\b/))
-           @rex_tokens.push action { [:or, lineno] }
+      when (text = @ss.scan(/or\b/))
+         action { [:or, lineno] }
 
-        when (text = ss.scan(/subset\b/))
-           @rex_tokens.push action { [:subset, lineno] }
+      when (text = @ss.scan(/subset\b/))
+         action { [:subset, lineno] }
 
-        when (text = ss.scan(/oneof\b/))
-           @rex_tokens.push action { [:oneof, lineno] }
+      when (text = @ss.scan(/oneof\b/))
+         action { [:oneof, lineno] }
 
-        when (text = ss.scan(/\.\s*all\b/))
-           @rex_tokens.push action { [:dotall, lineno] }
+      when (text = @ss.scan(/\.\s*all\b/))
+         action { [:dotall, lineno] }
 
-        when (text = ss.scan(/forall\b/))
-           @rex_tokens.push action { [:forall, lineno] }
+      when (text = @ss.scan(/forall\b/))
+         action { [:forall, lineno] }
 
-        when (text = ss.scan(/exists\b/))
-           @rex_tokens.push action { [:exists, lineno] }
+      when (text = @ss.scan(/exists\b/))
+         action { [:exists, lineno] }
 
-        when (text = ss.scan(/in\b/))
-           @rex_tokens.push action { [:in, lineno] }
+      when (text = @ss.scan(/in\b/))
+         action { [:in, lineno] }
 
-        when (text = ss.scan(/invariant\b/))
-           @rex_tokens.push action { [:invariant, lineno] }
+      when (text = @ss.scan(/invariant\b/))
+         action { [:invariant, lineno] }
 
-        when (text = ss.scan(/true\b/))
-           @rex_tokens.push action { [:true, lineno] }
+      when (text = @ss.scan(/true\b/))
+         action { [:true, lineno] }
 
-        when (text = ss.scan(/false\b/))
-           @rex_tokens.push action { [:false, lineno] }
+      when (text = @ss.scan(/false\b/))
+         action { [:false, lineno] }
 
-        when (text = ss.scan(/!=/))
-           @rex_tokens.push action { [text, lineno] }
+      when (text = @ss.scan(/!=/))
+         action { [text, lineno] }
 
-        when (text = ss.scan(/!|not\b/))
-           @rex_tokens.push action { [:not, lineno] }
+      when (text = @ss.scan(/!|not\b/))
+         action { [:not, lineno] }
 
-        when (text = ss.scan(/and\b/))
-           @rex_tokens.push action { [:and, lineno] }
+      when (text = @ss.scan(/and\b/))
+         action { [:and, lineno] }
 
-        when (text = ss.scan(/equal\b/))
-           @rex_tokens.push action { [:equal, lineno] }
+      when (text = @ss.scan(/equal\b/))
+         action { [:equal, lineno] }
 
-        when (text = ss.scan(/equiv\b/))
-           @rex_tokens.push action { [:equiv, lineno] }
+      when (text = @ss.scan(/equiv\b/))
+         action { [:equiv, lineno] }
 
-        when (text = ss.scan(/empty\b/))
-           @rex_tokens.push action { [:empty, lineno] }
+      when (text = @ss.scan(/empty\b/))
+         action { [:empty, lineno] }
 
-        when (text = ss.scan(/implies\b/))
-           @rex_tokens.push action { [:implies, lineno] }
+      when (text = @ss.scan(/implies\b/))
+         action { [:implies, lineno] }
 
-        when (text = ss.scan(/\.\./))
-           @rex_tokens.push action { [text, lineno] }
+      when (text = @ss.scan(/\.\./))
+         action { [text, lineno] }
 
-        when (text = ss.scan(/[{}:\(\)\.,]/))
-           @rex_tokens.push action { [text, lineno] }
+      when (text = @ss.scan(/[{}:\(\)\.,]/))
+         action { [text, lineno] }
 
-        when (text = ss.scan(/\+=/))
-           @rex_tokens.push action { [text, lineno] }
+      when (text = @ss.scan(/\+=/))
+         action { [text, lineno] }
 
-        when (text = ss.scan(/\-=/))
-           @rex_tokens.push action { [text, lineno] }
+      when (text = @ss.scan(/\-=/))
+         action { [text, lineno] }
 
-        when (text = ss.scan(/==/))
-           @rex_tokens.push action { [text, lineno] }
+      when (text = @ss.scan(/==/))
+         action { [text, lineno] }
 
-        when (text = ss.scan(/<=>/))
-           @rex_tokens.push action { [text, lineno] }
+      when (text = @ss.scan(/<=>/))
+         action { [text, lineno] }
 
-        when (text = ss.scan(/<=/))
-           @rex_tokens.push action { [text, lineno] }
+      when (text = @ss.scan(/<=/))
+         action { [text, lineno] }
 
-        when (text = ss.scan(/=>/))
-           @rex_tokens.push action { [text, lineno] }
+      when (text = @ss.scan(/=>/))
+         action { [text, lineno] }
 
-        when (text = ss.scan(/=/))
-           @rex_tokens.push action { [text, lineno] }
+      when (text = @ss.scan(/=/))
+         action { [text, lineno] }
 
-        when (text = ss.scan(/\+/))
-           @rex_tokens.push action { [text, lineno] }
+      when (text = @ss.scan(/\+/))
+         action { [text, lineno] }
 
-        when (text = ss.scan(/[01]/))
-           @rex_tokens.push action { [text, lineno] }
+      when (text = @ss.scan(/[01]/))
+         action { [text, lineno] }
 
-        when (text = ss.scan(/\w+/))
-           @rex_tokens.push action { [:IDENT, ADSLIdent.new(:lineno => lineno, :text => text)] }
+      when (text = @ss.scan(/\w+/))
+         action { [:IDENT, ADSL::ADSLIdent.new(:lineno => lineno, :text => text)] }
 
-        when (text = ss.scan(/\s/))
-          ;
+      when (text = @ss.scan(/\s/))
+        ;
 
-        when (text = ss.scan(/./))
-           @rex_tokens.push action { [:unknown_symbol, [text, lineno]] }
-
-        else
-          text = ss.string[ss.pos .. -1]
-          raise  ScanError, "can not match: '" + text + "'"
-        end  # if
+      when (text = @ss.scan(/./))
+         action { [:unknown_symbol, [text, lineno]] }
 
       else
-        raise  ScanError, "undefined state: '" + state.to_s + "'"
-      end  # case state
-    end  # until ss
-  end  # def scan_evaluate
+        text = @ss.string[@ss.pos .. -1]
+        raise  ScanError, "can not match: '" + text + "'"
+      end  # if
+
+    else
+      raise  ScanError, "undefined state: '" + state.to_s + "'"
+    end  # case state
+    token
+  end  # def _next_token
 
 end # class
-end # module