cauldron 0.1.0

data/lib/core/BlockToken.rb

@@ -0,0 +1,33 @@
+# 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

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

data/lib/core/CTestCase.rb

@@ -0,0 +1,27 @@
+# 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

@@ -0,0 +1,45 @@
+# 
+# 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  
+  
+  # TODO  Write tests
+  # 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
+ 
+end

data/lib/core/Container.rb

@@ -0,0 +1,85 @@
+# 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 write(tab=0)
+    line = '('
+    tab.times {line += "\t" }
+    @tokens.each do |code|
+      line += code.write
+      break if code.object_id == @tokens.last.object_id
+      line += ' '
+    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
+      line += ' '
+    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

data/lib/core/InstanceCallContainer.rb

@@ -0,0 +1,272 @@
+# This class represents any instance method call.  For example:
+#
+# 'test'.length
+# foo.class
+# bar.nil?
+#
+# TODO  The InstanceCallContainer should may be be replaced with just statement - the parser
+#       just has :call types.
+#
+class InstanceCallContainer < CallContainer
+  include PrintVariables
+  include VariableIncluded
+  
+  attr_reader :subject, :method_call
+  attr_reader :value
+
+  # 
+  # @param  subject       The variable or literal that is being acted upon
+  # @param  method_call   The method call being made against the variable 
+  #                       or literal
+  #  
+  def initialize(subject,method_call,*params)
+    raise StandardError.new('Use ClassMethodCallContainer here') if subject.kind_of?(ClassName)
+    super(subject,method_call,*params)    
+  end
+  
+  def write_with_uniq_id
+    if @subject.respond_to?('write_with_uniq_id')
+      return @subject.write_with_uniq_id+'.'+method_call.write+write_params(@parameters)
+    end
+    return @subject.write+'.'+method_call.write+write_params(@parameters)
+  end
+  
+  # TODO  There are many similar version of this method used
+  def replace_theory_variables!(mapping)
+    if @subject.kind_of?(TheoryVariable) && mapping.has_key?(@subject.theory_variable_id)
+      @subject = mapping[@subject.theory_variable_id].copy
+    elsif @subject.respond_to?(:replace_theory_variables!)
+      @subject.replace_theory_variables!(mapping)
+    end
+    @parameters.each_with_index do |x,i|
+      if x.kind_of?(TheoryVariable) && mapping.has_key?(x.theory_variable_id)
+        @parameters[i] = mapping[x.theory_variable_id].copy
+        next
+      end
+      @parameters[i].replace_theory_variables!(mapping) if @parameters[i].respond_to?(:replace_theory_variables!)
+    end
+
+  end
+
+  # TODO  This can probably replace replace_theory_variables!
+  def replace_variables!(mapping)
+    if @subject.kind_of?(Variable) && mapping.has_key?(@subject.variable_id)
+      @subject = mapping[@subject.variable_id].copy
+    elsif @subject.respond_to?(:replace_variables!)
+      @subject.replace_variables!(mapping)
+    end
+    @parameters.each_with_index do |x,i|
+      if x.kind_of?(Variable) && mapping.has_key?(x.variable_id)
+        @parameters[i] = mapping[x.variable_id].copy
+        next
+      end
+      @parameters[i].replace_variables!(mapping) if @parameters[i].respond_to?(:replace_variables!)
+    end
+
+  end  
+  
+  # Returns a duplicate instance call container with any matching
+  # variables replaced with the variable supplied.
+  #
+  # @param  var     The variable that will replace any matching variables
+  #
+  def replace_variable_if(var,&block)
+    container = self.copy.clear   
+    if block.call(@subject)    
+      container.subject = var if block.call(@subject)
+    end
+    @parameters.each do |x|
+      if x.kind_of?(Variable)
+        container.push(var) if block.call(x)  
+      end
+      container.push(x.copy)           
+    end
+    return container
+  end
+  
+  def contains?(&block)
+    return true if @parameters.contains?(&block)
+    return true if block.call(@subject)  
+    return true if block.call(@method_call)      
+    return false
+  end
+  
+  def write_in_context(context=self)  
+    return @subject.write_in_context(context)+'.'+method_call.write
+  end
+  
+  def copy
+    copied_subject = @subject.copy
+    return InstanceCallContainer.new(copied_subject,@method_call.copy,*@parameters.collect {|x| x.copy})
+  end
+  
+  def variable
+    return @subject
+  end
+  
+  def literalisable?
+    return @subject.literalisable?
+  end
+  
+  # Attempts to return a literal value for the result of calling
+  # this instance call.
+  #
+  def literalise(context=self)
+    unless(@subject.literalisable?)
+      raise FailedToLiteraliseError.new('Failed to literalise '+self.write+' couln\'t literalise '+@subject.write)
+    end 
+    return eval(@subject.literalise.write(context)+@method_call.write)
+  end
+  
+  def value
+    return literalise
+  end
+  
+  # Returns the actual variable with the specified id. 
+  # 
+  # @param  id  
+  #
+  def find_actual_variable(id)
+    return @subject if @subject.uniq_id == id
+    @parameters.each do |x|
+      return x if x.uniq_id == id
+    end
+    throw :variable_not_found
+  end  
+  
+  def response
+    case value.class.to_s
+      when 'string'.class.to_s
+        return StringVariable.new(value)
+        break
+      when 8.class.to_s
+        return FixnumVariable.new(value)
+    else
+      raise StandardError.new('Unknown class '+value.class.to_s)
+    end
+  end
+  
+  # Set the value of the container for the subject
+  #
+  def container=(val)
+    @container = val
+    @subject.container = @container
+  end
+  
+  # Determines whether the is an imediate 'self' in the instance
+  # call.
+  def contains_self?
+    return true if subject.kind_of? This
+    return false
+  end
+  
+  # Substitutes one variable for another one providing the 
+  # the block returns true.
+  # 
+  def subst!(var,&block)
+    @subject = var.copy if block.call(@subject)
+    @parameters.each_with_index do |x,i|
+      if block.call(x)
+        @parameters[i] = var.copy
+      end
+    end
+    return self
+  end
+  
+  # Substitutes the 'self' in the instance call for a literal
+  # value and evaluates it.
+  #
+  def subst_self_for literal
+    if subject.kind_of? This
+      @subject = literal
+    end
+  end
+  
+  def subject=(val)
+    @subject = val
+  end
+  
+  def variable_id
+    return @subject.variable_id
+  end
+  
+  def find_variable(id)
+    raise StandardError.new('This instance call does not contain the variable with the id '+id.to_s) unless variable_id == id
+    return contextual_subject
+  end
+  
+  # 
+  def copy_contextual_variable
+    return contextual_subject  
+  end
+  
+  def declaration_statement
+    new_instance_call = ClassMethodCallContainer.new(InstanceCallContainerClass.new,New.new,@subject.copy.declaration_statement,@method_call.copy.declaration_statement)    
+    return Statement.new(new_instance_call)
+  end
+  
+  # This method is used during tracking to print a general description of what
+  # the instance call is doing. e.g. 'test'.chop.
+  #
+  def to_literal_string
+    return @subject.to_literal_string+'.'+@method_call.to_literal_string
+  end
+  
+  # Returns a declaration instance that will create a InstanceCallContainer with 
+  # same properies as this InstanceCallContainer.
+  #
+  def to_declaration
+    return VariableDeclaration.new('InstanceCallContainer',*[@subject.to_declaration,@method_call.to_declaration,*@parameters.collect {|x| x.to_declaration}])  
+  end
+  
+  # Returns an array of all the variables used in this instance call.
+  #
+  def variables
+    if @subject.kind_of?(Variable) 
+      results = [@subject.copy]
+    end
+    results ||= []
+    @parameters.each do |x|
+      results.push(x.copy)
+    end
+    return results
+  end
+  
+  # Returns true if the supplied argument is equivant to this instance call 
+  # container.  They are equivalent if the their classes are the same, their
+  # subjects are equivalent, their method_calls are the same and use equivalent
+  # arguments.
+  #
+  def equivalent?(to)
+    return false unless self.class == to.class
+    return false unless self.length == to.length
+    return false unless @subject.equivalent?(to.subject)
+    return false unless @method_call.class == to.method_call.class
+    return false if @parameters.length != to.parameters.length
+    @parameters.each_with_index do |x,i|
+      return false unless x.equivalent?(to.parameters[i])
+    end
+    return true
+  end
+    
+protected
+
+  def contextual_subject
+    
+    # Check that the literal supports the method call
+    if @subject.kind_of? Literal
+      raise NameError.new('Literal '+self.write+' does not have the method call '+@method_call.write) unless @subject.allowed? @method_call  
+    end
+    
+    # Copy the subject variable
+    copied_subject = @subject.copy
+    
+    # Retrieve any requirements associated with the method call
+    @method_call.requirements do |req|
+      copied_subject.push(req)
+    end
+    return copied_subject
+    
+  end
+  
+end