cauldron 0.1.0

data/lib/core/Token.rb

@@ -0,0 +1,7 @@
+# This module is included with elements that are either variables, literals, intrinsic runtime 
+# method or intrinsic test cases.  These types of elements need identified to compare the structures
+# of thories and theory implementations.
+#
+module Token
+  
+end

data/lib/core/assignment/Assignment.rb

@@ -0,0 +1,18 @@
+class Assignment
+  
+  def initialize
+  end
+
+  def write
+    return self.class.to_s+' has not be described yet'
+  end  
+  
+  def describe
+    return write
+  end
+  
+  def copy
+    return self.class.new
+  end  
+  
+end

data/lib/core/assignment/Equal.rb

@@ -0,0 +1,39 @@
+# Reflects the use of the (=)
+#
+
+class Equal < Equivalent
+  
+  def initialize
+    super
+  end
+  
+  def write()
+    return '='
+  end
+  
+  def describe
+    return write
+  end
+  
+  def copy
+    return Equal.new
+  end
+  
+  def declaration_statement
+    return ClassMethodCallContainer.new(EqualClass.new,New.new)    
+  end
+  
+  def to_literal_string
+    return '='
+  end
+  
+  def to_declaration
+    return VariableDeclaration.new(self.class.to_s)
+  end
+  
+  def equivalent?(to)
+    return true if to.class == self.class
+    return false    
+  end
+  
+end

data/lib/core/assignment/Equivalent.rb

@@ -0,0 +1,20 @@
+
+class Equivalent < Assignment
+  
+  def initialize
+    super
+  end
+  
+  def write
+    return '=='
+  end
+  
+  def copy
+    return Equivalent.new  
+  end
+  
+  def to_literal_string
+    return write
+  end  
+  
+end

data/lib/core/assignment/NotEqual.rb

@@ -0,0 +1,14 @@
+# Reflects the use of the (=)
+#
+
+class NotEqual < Assignment
+  
+  def initialize
+    super
+  end
+  
+  def write()
+    return '!='
+  end
+  
+end

data/lib/core/call_container/CallContainer.rb

@@ -0,0 +1,66 @@
+class CallContainer < Array
+  include WriteParameters  
+  
+  attr_reader :parameters
+  
+  def initialize(subject,method_call,*parameters)
+    
+    # Check the type for the class name
+    @subject = subject
+    
+    # Check the datatype of the method_call
+    @method_call = method_call
+    
+    @parameters = parameters
+    
+    super()    
+  end    
+  
+  def write(tab=0)
+    return ("\t"*tab)+@subject.write+method_call.write+write_params(@parameters,method_call.closure)
+  end  
+  
+  def describe(tab=0)
+    return ("\t"*tab)+@subject.describe+method_call.write+describe_params(@parameters,method_call.closure)
+  end    
+  
+  def has?(&block)
+    @parameters.each do |x|
+      return true if block.call(x)
+    end
+    return true if block.call(@subject)
+    return true if block.call(@method_call)
+    return false
+  end  
+  
+  # [Overwrite - from Array] Returns any elements that match the supplied
+  # criteria with this array as well as the subject.
+  #
+  def select_all(results=[],&block)
+     results.push(@subject) if block.call(@subject)
+     results.push(@method_call) if block.call(@method_call)
+     if @subject.respond_to?(:select_all) 
+       @subject.select_all(results,&block)
+     end
+     if @method_call.respond_to?(:select_all)
+       @method_call.select_all(results,&block)
+     end
+     @parameters.select_all(results,&block)
+     return results
+  end
+
+  def replace_theory_variables!(mapping)
+    @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
+      end
+    end
+    if @subject.kind_of?(TheoryVariable) && mapping.has_key?(@subject.theory_variable_id)
+      @subject = mapping[@subject.theory_variable_id].copy
+    end
+    if @method_call.kind_of?(TheoryVariable) && mapping.has_key?(@method_call.theory_variable_id)
+      @method_call = mapping[@method_call.theory_variable_id].copy
+    end    
+  end        
+  
+end  

data/lib/core/class_method_call/New.rb

@@ -0,0 +1,15 @@
+class New < RuntimeClassMethodCall
+  
+  def initialize
+    super()
+  end
+  
+  def write
+    return '.new'
+  end
+  
+  def copy
+    return New.new
+  end
+  
+end

data/lib/core/class_method_call/RuntimeClassMethodCall.rb

@@ -0,0 +1,31 @@
+class RuntimeClassMethodCall
+  
+  def initialize()
+    
+  end
+  
+  def copy
+    raise StandardError.new('Copy hasn\'nt been included for ('+self.class.to_s+')')
+  end
+  
+  def requirements
+    raise StandardError.new('Requirements have not been defined for '+self.class.to_s+'')
+  end
+  
+  def write
+    raise StandardError.new('"write" has not been defined for '+self.class.to_s+'')
+  end
+  
+  def use(*parameters)
+    raise StandardError.new('"use" has not been defined for '+self.class.to_s+'')
+  end  
+  
+  def to_literal_string
+    return self.write
+  end
+  
+  def closure
+    return ['(',')']
+  end  
+  
+end

data/lib/core/declaration/Declaration.rb

@@ -0,0 +1,16 @@
+class Declaration < Array
+  
+  def initialize(val)
+    super()
+    @value = val
+  end
+  
+  def write
+    return @value
+  end
+  
+  def copy
+    return Declaration.new(@value.clone)
+  end
+    
+end

data/lib/core/declaration/LiteralDeclaration.rb

@@ -0,0 +1,47 @@
+# Literal declarations when written appear like.  'ssdkfj' or MethodUsage.new
+# while VariableDeclarations when write appear like var_0 etc.
+#
+class LiteralDeclaration < Declaration
+  attr_reader :value
+  
+  def initialize(val)
+     
+     #  Check that the value is valid
+    case val.class.to_s
+      when 'String'
+      when 'Array'
+      when 'Fixnum'
+      when 'NilClass'      
+    else
+      raise StandardError.new('Unexpected literal declaration value '+val.class.to_s)
+    end
+     
+      super(val)
+  end
+  
+  def write
+    return @value.write
+  end
+  
+  def copy    
+    unless @value.nil? then return LiteralDeclaration.new(@value.copy) end
+    return LiteralDeclaration.new(nil)
+  end
+  
+  # Returns the declaration as a string.  Essentially just writing the value since
+  # these are literals.
+  #
+  def to_literal_string
+    return write
+  end
+
+  # Compares the passed argument and returns true if the comparison is
+  # the same class and same value.
+  # 
+  def equivalent?(to)
+    return false if to.class != self.class
+    return false unless to.value == @value
+    return true
+  end       
+      
+end

data/lib/core/declaration/VariableDeclaration.rb

@@ -0,0 +1,59 @@
+class VariableDeclaration < Declaration
+  
+  attr_reader :class_name
+  
+  def initialize(class_name,*parameters)
+    super(nil)
+    
+    raise StandardError.new('Expecting class name as a string but is a '+class_name.to_s) unless class_name.kind_of?(String)
+    
+    # The name of the class to be instantiated
+    @class_name = class_name
+    parameters.each do |x|
+      raise StandardError.new('unexpect data type '+x.class.to_s) unless x.kind_of?(Declaration)
+      self.push x
+    end
+  end
+  
+  def write
+    l = @class_name.to_s+'.new('
+    self.each do |x|
+      l += x.write
+      l += ', ' unless x.object_id == self.last.object_id
+    end
+    l += ')'
+    return l
+  end
+  
+  def copy
+    return VariableDeclaration.new(@class_name,*self.collect {|x| x.copy})
+  end
+  
+  # Returns the evaluated value of the current declaration.
+  def evaluate
+     CodeEvaluation.new.evaluate_code(self.write)
+  end
+  
+  def has?(&block)
+    self.each do |x|
+      return true if block.call(x)
+    end
+    return false
+  end      
+  
+  # This replaces a variable declaration with a scope value.  This will general
+  # called on Statement VariableDeclarations that contain TheoryVariable declarations
+  # e.g. Statement.new(Return.new(), TheoryVariable.new(9))
+  #
+  # It would then be supplied a hash {9=><#some_instance>}, this would then
+  # be substituted into the statement variable declaration. 
+  #  
+  def replace_theory_variable_declarations!(mapping)
+    self.each_with_index do |x,i|
+      if x.kind_of?(VariableDeclaration) && x.class_name == 'TheoryVariable' && mapping.has_key?(x.first.value)
+        self[i] = mapping[x.first.value].copy
+      end
+    end        
+  end  
+  
+end

data/lib/core/instance_call/ArrayEach.rb

@@ -0,0 +1,23 @@
+
+class ArrayEach < InstanceCall
+  
+  def initialize
+    super
+  end
+  
+  def write
+    return '.each'
+  end
+  
+  def copy
+    return ArrayEach.new
+  end  
+  
+  # Returns false indicating that .each doesn't alter the variable
+  # it acts on.
+  #
+  def destructive?
+    return false
+  end
+  
+end

data/lib/core/instance_call/ArrayLength.rb

@@ -0,0 +1,15 @@
+class ArrayLength < InstanceCall
+  
+  def initialize
+    super
+  end
+  
+  def write
+    return '.length'
+  end
+  
+  def copy
+    return ArrayLength.new
+  end  
+  
+end

data/lib/core/instance_call/Chop.rb

@@ -0,0 +1,28 @@
+class Chop <InstanceCall
+  
+  def initialize
+    super
+    
+    @use_requirements = [
+      Requirement.new(InstanceCallContainer.new(This.new,ClassCall.new), Equal.new , StringClass.new)
+    ]
+    
+  end
+  
+  def write
+    return '.chop'
+  end
+  
+  def copy
+    return Chop.new
+  end
+  
+  def requirements
+    @use_requirements.each {|req| yield req}
+  end
+  
+  def use(val)
+    return val.chop
+  end
+  
+end

data/lib/core/instance_call/Copy.rb

@@ -0,0 +1,22 @@
+class Copy <InstanceCall
+  
+  def initialize
+    super
+    
+    @use_requirements = []
+    
+  end
+  
+  def write
+    return '.copy'
+  end
+  
+  def copy
+    return Copy.new
+  end
+  
+  def use(val)
+    return val.copy
+  end
+  
+end