adsl 0.0.3 → 0.1.0

data/lib/ds/data_store_spec.rb

@@ -1,292 +0,0 @@
-require 'util/util'
-
-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
-  end
-
-  class DSRelation < DSNode
-    container_for :cardinality, :from_class, :to_class, :name, :inverse_of
-
-    def to_s
-      "#{from}.#{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
-  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 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 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

data/lib/fol/first_order_logic.rb

@@ -1,260 +0,0 @@
-require 'active_support/all'
-require 'util/util'
-
-class String
-  def resolve_spass
-    self
-  end
-
-  def split_by_zero_level_comma
-    parts = []
-    sequence_beginning_index = 0
-    index = 0
-    paren_level = 0
-    while index < length
-      if self[index, 1] == '('
-        paren_level += 1
-      elsif self[index, 1] == ')'
-        paren_level -= 1
-        raise ArgumentError, 'Unmatching parenthesis' if paren_level < 0
-      elsif self[index, 1] == ',' and paren_level == 0
-        parts << self[sequence_beginning_index, index - sequence_beginning_index].strip
-        sequence_beginning_index = index + 1
-      end
-      index += 1
-    end
-    parts << self[sequence_beginning_index, length - sequence_beginning_index].strip
-    parts
-  end
-end
-
-class Symbol
-  def resolve_spass
-    to_s
-  end
-end
-
-class TrueClass
-  def resolve_spass
-    "true"
-  end
-end
-
-class FalseClass
-  def resolve_spass
-    "false"
-  end
-end
-
-module FOL
-  class Not
-    def initialize(*formulae)
-      @formulae = formulae.flatten
-      raise ArgumentError, "At least one subformula required" if @formulae.empty?
-    end
-
-    def resolve_spass
-      children = @formulae.map{ |obj| obj.resolve_spass }
-      children.delete_if{ |a| a == 'false' }
-      return 'false' if children.include? 'true'
-      return And.new(children.map{ |child| child.match('\Anot\((.*)\)\z') ? $1 : "not(#{child})" }).resolve_spass
-    end
-  end
-
-  
-  class And
-    attr_reader :objs
-    
-    def initialize(*objs)
-      @objs = objs.flatten
-    end
-
-    def resolve_spass
-      children = @objs.map{ |child| child.resolve_spass }
-      children = children.map{ |child| child.match('\Aand\((.*)\)\z') ? $1.split_by_zero_level_comma : child }.flatten
-      children.delete_if{ |a| a == 'true' }
-      return 'false' if children.include? 'false'
-      return 'true' if children.empty?
-      return children.first if children.length == 1
-      return "and(#{children.join(', ')})"
-    end
-  end
-
-  class Or
-    attr_reader :objs
-
-    def initialize(*objs)
-      @objs = objs.flatten
-    end
-
-    def resolve_spass
-      children = @objs.map{ |child| child.resolve_spass }
-      children = children.map{ |child| child.match('\Aor\((.*)\)\z') ? $1.split_by_zero_level_comma : child }.flatten
-      children.delete_if{ |a| a == 'false' }
-      return 'true' if children.include? 'true'
-      return 'false' if children.empty?
-      return children.first if children.length == 1
-      return "or(#{children.join(', ')})"
-    end
-  end
-  
-  class ForAll
-    def initialize(*params)
-      params = params.flatten
-      raise ArgumentError, "At least a formula required" if params.length < 1
-      @args = params.first(params.length - 1)
-      @formula = params.last
-    end
-
-    def resolve_spass
-      args = @args.map{ |obj| obj.resolve_spass }
-      formula = @formula.resolve_spass
-      return formula if args.empty?
-      return 'true' if formula == 'true'
-      return 'false' if formula == 'false'
-      "forall( [#{args.join(', ')}], #{formula})" 
-    end
-  end
-
-  class Exists
-    def initialize(*params)
-      params = params.flatten
-      raise ArgumentError, "At least a formula required" if params.length < 1
-      @args = params.first(params.length - 1)
-      @formula = params.last
-    end
-
-    def resolve_spass
-      args = @args.map{ |obj| obj.resolve_spass }
-      formula = @formula.resolve_spass
-      return formula if args.empty?
-      return 'true' if formula == 'true'
-      return 'false' if formula == 'false'
-      "exists( [#{args.join(', ')}], #{formula})" 
-    end
-  end
-  
-  class Equal
-    def initialize(*subformulae)
-      @subformulae = subformulae.flatten
-      raise ArgumentError, "At least two subformulae required" if @subformulae.length < 2
-    end
-
-    def resolve_spass
-      return @subformulae.first.resolve_spass if @subformulae.length == 1
-      combinations = []
-      (@subformulae.length-1).times do |index|
-        combinations << "equal(#{@subformulae[index].resolve_spass}, #{@subformulae[index+1].resolve_spass})"
-      end
-      return And.new(combinations).resolve_spass
-    end
-  end
-
-  class Equiv
-    def initialize(*subformulae)
-      @subformulae = subformulae.flatten
-      raise ArgumentError, "At least two subformulae required" if @subformulae.length < 2
-    end
-
-    def resolve_spass
-      subformulae = @subformulae.map{ |sub| sub.resolve_spass }
-      return subformulae.first if subformulae.length == 1
-      return And.new(subformulae).resolve_spass if subformulae.include? 'true'
-      return Not.new(subformulae).resolve_spass if subformulae.include? 'false'
-      combinations = []
-      (subformulae.length-1).times do |index|
-        combinations << "equiv(#{subformulae[index]}, #{subformulae[index+1]})"
-      end
-      return And.new(combinations).resolve_spass
-    end
-  end
-  
-  class Implies
-    def initialize(from, to)
-      @from = from
-      @to = to
-    end
-
-    def resolve_spass
-      from = @from.resolve_spass
-      to = @to.resolve_spass
-      return to if from == 'true'
-      return 'true' if from == 'false'
-      return Not.new(from).resolve_spass if to == 'false'
-      return 'true' if to == 'true'
-      return "implies(#{from}, #{to})"
-    end
-  end
-
-  class OneOf
-    def initialize(*formulae)
-      @formulae = formulae.flatten
-    end
-
-    def resolve_spass
-      return 'false' if @formulae.empty?
-      return @formulae.first.resolve_spass if @formulae.length == 1
-      return Equiv.new(Not.new(@formulae.first), @formulae.last).resolve_spass if @formulae.length == 2
-
-      substatements = []
-      @formulae.length.times do |i|
-        formulae_without_i = @formulae.first(i) + @formulae.last(@formulae.length - 1 - i)
-        substatements << Implies.new(@formulae[i], Not.new(formulae_without_i))
-      end
-      And.new(Or.new(@formulae), substatements).resolve_spass
-    end
-  end
-
-  class IfThenElse
-    def initialize(iif, tthen, eelse)
-      @iif = iif
-      @tthen = tthen
-      @eelse = eelse
-    end
-
-    def resolve_spass
-      And.new(Implies.new(@iif, @tthen), Implies.new(Not.new(@iif), @eelse)).resolve_spass
-    end
-  end
-  
-  class IfThenElseEq
-    def initialize(iif, tthen, eelse)
-      @iif = iif
-      @tthen = tthen
-      @eelse = eelse
-    end
-
-    def resolve_spass
-      And.new(Equiv.new(@iif, @tthen), Equiv.new(Not.new(@iif), @eelse)).resolve_spass
-    end
-  end
-  
-  class PairwiseEqual
-    def initialize(*list)
-      list = list.flatten
-      @list1 = list.first((list.length/2.0).ceil)
-      @list2 = list.last((list.length/2.0).floor)
-      raise ArgumentError, "Lists not of equal length: [#{@list1.join(", ")}], [#{@list2.join(", ")}]" if @list1.length != @list2.length
-    end
-
-    def resolve_spass
-      equalities = []
-      @list1.length.times do |i|
-        equalities << Equal.new(@list1[i], @list2[i])
-      end
-      return And.new(equalities).resolve_spass
-    end
-  end
-
-  # 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
-      send :define_method, "_#{klass_name.to_s.underscore}".to_sym do |*args|
-        klass.new(*args).resolve_spass
-      end
-    end
-  end
-end
-