cauldron 0.1.3 → 0.1.5

data/lib/cauldron/env.rb

@@ -1 +0,0 @@
-TAB = '  '

data/lib/cauldron/sexp2cauldron.rb

@@ -1,139 +0,0 @@
-require 'rubygems'
-require 'ruby2ruby'
-require 'sexp_processor'
-
-module Cauldron
-  
-  class Sexp2Cauldron < SexpProcessor
-    
-    VARIABLE_EXPRESSION = /var[|_]*(\d+)/
-    
-    def initialize
-      super
-      self.expected = Object   
-      self.auto_shift_type = true
-      self.strict = true      
-      @debug[:lasgn] = nil
-      @unsupported_checked = true
-    end
-    
-    def process_lit(exp)
-      val = exp.shift
-      return Literal.new(val)
-    end
-    
-    def in_context type, &block
-      self.context.unshift type
-      yield
-      self.context.shift
-    end    
-    
-    def process_str(exp)
-      Literal.new(exp.shift)
-    end
-    
-    # => Overwritten method
-    def process_lasgn(exp)
-      next_exp = exp.shift
-      if next_exp.to_s.match(VARIABLE_EXPRESSION)
-        s = Statement.new(convert_to_variable(next_exp),Equal.new)
-      end
-      a = process(exp.shift)
-      s.add a
-      return s
-    end    
-    
-    def process_if(exp)
-      inner_statement_sexp = exp.shift 
-      scope = process(exp.shift)   # => The content of the if statement
-      exp.shift
-      open_statement = OpenStatement.new(Statement.new(If.new,Container.new(process(inner_statement_sexp))))
-      open_statement << scope unless scope.nil?
-      return open_statement
-    end    
-    
-    def process_return(exp)
-      return Statement.new(Return.new,process(exp.shift))
-    end
-    
-    def process_call(exp)
-      results = []
-      until exp.empty?
-        atom = exp.shift
-        if atom.to_s.match(VARIABLE_EXPRESSION)
-          results << convert_to_variable(atom)
-          next
-        end
-        if atom == :==
-          results << Equivalent.new
-          next
-        end   
-        next if atom.nil?
-        res = process(atom)
-        next if res.nil?
-        results << res     
-      end
-      return Statement.new(*results)
-    end    
-    
-    def process_arglist(exp)
-      return process exp.shift
-    end
-    
-    def process_defn(exp)
-      type = exp.shift
-      args = exp.shift
-      scope = exp.shift
-      
-      usage = (args.length==2) ? process(args) : MethodUsage.new
-      method_id = type.to_s.match(/method_(\d)+/)[1]
-      method = RuntimeMethod.new(usage,method_id)
-      statements = process(scope)
-      unless statements.nil?
-        statements.each do |statement|
-          method << statement unless statement.nil?
-        end
-      end
-      return method
-      
-    end
-    
-    def process_args(exp)
-      atom = exp.shift
-      variable_id = atom.to_s.match(VARIABLE_EXPRESSION)[1]
-      param = MethodParameter.new()
-      param.variable_id = variable_id
-      return MethodUsage.new(param)
-    end
-    
-    def process_scope(exp)
-      block = exp.shift
-      res = process(block)
-      return res
-    end
-    
-    def process_block(exp)
-      result = []   
-      until exp.empty?
-        atom = exp.shift
-        next if atom.first == :nil
-        result << process(atom)
-      end
-      return result
-    end
-    
-    def process_lvar(exp)
-      var = exp.shift
-      return convert_to_variable(var)
-    end
-    
-  private
-   
-    def convert_to_variable(variable)
-      return Unknown.new(variable.to_s.match(VARIABLE_EXPRESSION)[1])
-    end
-    
-  end
-  
-  
-end

data/lib/cauldron/theory_factory.rb

@@ -1,10 +0,0 @@
-
-
-module Cauldron
-  
-  class TheoryFactory
-    
-    
-  end
-  
-end

data/lib/cauldron/util/home.rb

@@ -1,21 +0,0 @@
-module Cauldron
-  
-  module Util
-  
-    module Home
-      
-      private 
-      
-        # Check that the home directory exists
-        def home
-          realHome = ["HOME", "HOMEPATH"].detect {|h| ENV[h] != nil}
-          if not realHome
-            StandardLogger.instance.warning "Couldn't detect a home directory"
-          end
-          return ENV[realHome]  
-        end      
-      
-    end
-  
-  end
-end

data/lib/cauldron/util/saver.rb

@@ -1,45 +0,0 @@
-module Cauldron::Util::Saver
-  
-  def self.save(obj)
-    dir_path = FileUtils.mkdir(next_directory).first
-   begin 
-      dump_file_path = File.join(dir_path,'dump')
-      dump_file = File.open(dump_file_path,'w+')
-      data = Marshal.dump(obj)
-      dump_file << data
-      return dump_file_path
-    ensure 
-      dump_file.close
-    end
-  end
-  
-  def self.debug_directory
-    # the home directory code is duplicated
-    realHome = ["HOME", "HOMEPATH"].detect {|h| ENV[h] != nil}
-    if not realHome
-      StandardLogger.instance.warning "Couldn't detect a home directory"
-    end
-    return File.join(ENV[realHome],'cauldron','debug')    
-  end   
-  
-  def self.next_directory
-    FileUtils.mkdir(debug_directory) unless File.exists?(debug_directory)
-    highest_integer = 0
-    Dir.glob(File.join(debug_directory,'*')).each do |filename|
-      if filename.match(/(\d+)/)
-        highest_integer = $1.to_i if $1.to_i > highest_integer     
-      end
-    end
-    return File.join(debug_directory,(highest_integer + 1).to_s)
-  end
-  
-  def self.load(id)
-    Dir.glob(File.join(debug_directory,'*')).each do |filename|
-      if m = filename.match(/(\d+)/) and m[0].to_i == id
-        dump_file = File.open(File.join(filename,'dump'),'r')
-        return Marshal.load(dump_file.read)        
-      end
-    end
-  end
-  
-end

data/lib/core/ActsAsCode.rb

@@ -1,25 +0,0 @@
-#
-# This module is used in the various code containers used in Cauldren
-#
-module ActsAsCode
-  
-  # Returns a string description of the statement with any of tokens replaced with 
-  # token markers.
-  # 
-  # So var_1 = var_2 + 3
-  #
-  # becomes a = b + c
-  #
-  # The order of replacement is important, the first token becomes a, the second b
-  # and so forth.
-  # 
-  def write_structure
-      # TODO  Not sure how to handle duplicate literals
-      output = self.write
-      self.tokens.zip(('a'..'z').to_a) do |x,y|
-        output.gsub!(x.write,y)
-      end      
-      return output
-  end   
-   
-end

data/lib/core/BlockToken.rb

@@ -1,33 +0,0 @@
-# I'm not sure whether to keep this class as I already have BlockVariable but that
-# is a bit overkill - I'm not sure I need to keep BlockVariable either.
-#
-# Instances of this are used in theories where a variable that shouldn't be 
-# replaced is used.  This might be a Global variable or a block variable.
-#
-# if(var1.any? {|x| x == var2})
-#   return false 
-# end
-# 
-# In the theory above if x was a normal TheoryVariable it would be replaced and the theory 
-# would break.
-#
-class BlockToken 
-  include Token
-  
-  def initialize(identitiy)
-    @identitiy = identitiy  
-  end
-  
-  def write
-    return @identitiy
-  end
-  
-  def describe
-    return write
-  end
-  
-  def copy
-    return BlockToken.new(@identitiy.copy)
-  end
-  
-end

data/lib/core/CCall.rb

@@ -1,7 +0,0 @@
-class CCall
-  
-  def initialize
-    
-  end
-  
-end

data/lib/core/CTestCase.rb

@@ -1,27 +0,0 @@
-# This is an individual test case that has an input an output.  It is essentially
-# just a hash but I've created a new class for it just for the convenience of using
-# the .kind_of? method in theory chains.     
-#
-# TODO  Don't like extending core datatypes
-class CTestCase < Hash
- 
-  # TODO  Should be able pass the hash directly or usea variable to contain the hash
-  def initialize(inputs=nil,output=nil)
-    super()
-    self[:params] = inputs
-    self[:output] = output
-  end
-  
-  def copy    
-    return Marshal.load(Marshal.dump(self))    
-  end  
-  
-  def cauldron_method_calls
-    results = self.collect do |key,value|
-      '[:'+key.to_s+']'
-    end
-    results << '.kind_of?'
-    return results
-  end
-
-end

data/lib/core/ClassMethodCallContainer.rb

@@ -1,58 +0,0 @@
-# 
-# FixnumVariable.new(8)
-#
-class ClassMethodCallContainer < CallContainer
-  attr_reader :method_call, :parameters
-  
-  def initialize(class_name,method_call,*parameters)
-    
-    # Check the type for the class name
-    raise StandardError.new('Unexpected data type '+class_name.class.to_s) unless class_name.kind_of?(ClassName)
-    @class_name = class_name
-    
-    super(class_name,method_call,*parameters)
-  end
-  
-  def class_name
-    return @subject
-  end
-  
-  def copy
-    return ClassMethodCallContainer.new(@subject.copy,@method_call.copy,*@parameters.collect {|x| x.copy})
-  end
-  
-  # This method is used during tracking to print a general description of what
-  # the instance call is doing. e.g. MethodUsage.new.
-  #
-  def to_literal_string
-    return @class_name.write+'.'+@method_call.to_literal_string
-  end  
-  
-  # Returns true if the supplied argument is the same class, has the equivalent subjects
-  # and parameters. 
-  #
-  def equivalent?(to)
-    return false unless self.class == to.class
-    return false unless @class_name.class == to.class_name.class
-    return false unless @method_call.class == to.method_call.class
-    @parameters.each_with_index do |x,i|
-      return false unless x.equivalent?(to.parameters[i])
-    end
-    return true 
-  end
-  
-  def replace_variables_alt!(map)
-    @parameters.each_with_index do |x,i|
-      if x.kind_of?(TheoryVariable)
-        map.each do |key,value|
-          if x.theory_variable_id == key.theory_variable_id
-            @parameters[i] = value
-          end
-        end
-      else
-        x.replace_variables_alt!(map)
-      end
-    end  
-  end
- 
-end

data/lib/core/Container.rb

@@ -1,95 +0,0 @@
-# This is just a wrapper for elements that should be wrapped in parenthesis.  
-#
-class Container
-  
-  def initialize(*tokens)
-    @tokens = tokens
-  end      
-
-  def replace_theory_variables!(mapping)
-    @tokens.each_with_index do |x,i|
-      if x.kind_of?(TheoryVariable) && mapping.has_key?(x.theory_variable_id)
-        @tokens[i] = mapping[x.theory_variable_id].copy
-        next
-      end
-      @tokens[i].replace_theory_variables!(mapping) if @tokens[i].respond_to?(:replace_theory_variables!)
-    end
-  end     
-
-  def subst_variable!(id,var)
-    @tokens.each_with_index do |token,i|
-      if token.kind_of?(Variable) && id == token.variable_id
-        @tokens[i] = var
-      end
-      if token.kind_of?(Statement)
-        token.subst_variable!(id,var)
-      end
-    end
-    self
-  end
-
-  def write(tab=0)
-    line = '('
-    tab.times {line += "  " }
-    @tokens.each do |code|
-      line += code.write
-      break if code.object_id == @tokens.last.object_id
-    end
-    return line+')'
-  end
-  
-  def describe(tab=0)
-    line = '('
-    tab.times {line += "\t" }
-    @tokens.each do |code|
-      line += code.describe
-      break if code.object_id == @tokens.last.object_id
-    end
-    return line+')'
-  end  
-  
-  def copy
-    return Container.new(*@tokens.collect {|x| x.copy} )
-  end
-  
-  def select_all(results=[],&block)
-    results.push self if block.call(self)
-    @tokens.each do |x|
-      if block.call(x)
-        results.push(x)
-      end
-      if x.respond_to?(:select_all) 
-        x.select_all(results,&block)  
-      end
-    end
-    return results
-  end    
-  
-  def has?(&block)
-    return true if block.call(self)
-    @tokens.each do |x|
-      return true if block.call(x)
-    end
-    return false
-  end      
-  
-  # This method writes the statement out as a literal string.  In the sense
-  # that any of the variables used in the statement are converted to literals
-  # and written.  Unknown variables are not written yet though.
-  #
-  # This method is called during tracking to give an indication what the statement
-  # being tracked is doing.
-  # 
-  # TODO  I am treating unknown variables as a special case that is the same 
-  #       value e.g. 'var' - but for determining equivalent processes it isn't
-  #       ideal becuase you loose track of what variables is used in each 
-  #       statement.  Although I'll wait unitl I can come up with an example
-  #       and come up with a solution then.
-  #
-  def to_literal_string
-    return @tokens.inject('') do |complete,part|
-      complete += part.to_literal_string
-    end
-  end    
-  
-end