cauldron 0.1.0

data/lib/core/variable/MethodUsageVariable.rb

@@ -0,0 +1,60 @@
+class MethodUsageVariable < BaseVariable
+  
+  def initialize(*parameters)
+    super()
+    raise StandardError.new('Only submit the paramaters on the usage variable') if parameters.first.kind_of?(MethodUsage)
+    # Go through each paramater in the method usage instance
+    parameters.each do |x|
+      self.push x.copy
+    end
+    
+  end
+  
+  def to_declaration
+    return VariableDeclaration.new('MethodUsageVariable',*self.collect {|x| x.to_declaration})
+  end
+  
+  def copy
+    result = MethodUsageVariable.new(*self.collect {|x| x.copy}) {{:variable_id => self.variable_id,:uniq_id=>@uniq_id, :uniq_id_history=>@uniq_id_history.copy}}
+    return result
+  end
+  
+#  # Only let this method be called from fellow Fixnum classes or Unknowns
+#  def variable_id=(id)
+#    # TODO  This would be nicer if it wasn't so hard coded ./lib/core/variable/Unknown.rb
+#    unless caller.first.split(':')[0]==__FILE__ or caller.first.split(':')[0]=='./lib/core/variable/Unknown.rb'
+#      raise StandardError.new('Illegal attempt to set variable_id')
+#    end
+#    @variable_id = id
+#  end
+  
+  # TODO  Test this
+  def to_literal_string
+    l = 'MethodUsage.new('
+    self.each do |x|
+      l += x.to_literal_string
+      unless x.object_id == self.last.object_id
+        l += ','
+      end
+    end
+    l += ')'    
+    return l
+  end      
+  
+  # TODO  Write tests
+  # Compares the passed argument and returns true if they are 
+  # the same class and contains the same values.
+  #
+  def equivalent?(to)
+    return false if to.class != self.class
+    to.zip(self) do |x,y|
+      return false unless x.equivalent?(y)
+    end
+    return true
+  end   
+  
+  def destructive_instance_calls(with=[])
+    return []  
+  end
+  
+end

data/lib/core/variable/NilVariable.rb

@@ -0,0 +1,29 @@
+class NilVariable < TypeVariable
+  
+  def initialize(id=nil)
+    super(nil)
+  end  
+  
+  def copy
+    copied = NilVariable.new {{:variable_id => self.variable_id,:uniq_id=>@uniq_id, :uniq_id_history=>@uniq_id_history.copy}}
+    #copied.variable_id = self.variable_id
+    return copied
+  end    
+  
+  # Only let this method be called from fellow NilVariable classes  
+  def variable_id=(id)
+    unless caller.first.split(':')[0]==__FILE__
+      raise StandardError.new('Illegal attempt to set variable_id')
+    end
+    @variable_id = id
+  end      
+  
+  def realised?
+    return true
+  end  
+  
+  def to_declaration
+    return VariableDeclaration.new(self.class.to_s,nil.to_declaration)
+  end
+  
+end

data/lib/core/variable/RuntimeMethodParameter.rb

@@ -0,0 +1,67 @@
+class RuntimeMethodParameter < TypeVariable
+  
+  def initialize(val)
+    super(val)
+  end
+  
+#  def copy
+#    copied = self.class.new(@value)
+#    copied.variable_id = self.variable_id
+#    return copied
+#  end  
+#  
+  # Only let this method be called from fellow Fixnum classes or Unknowns
+  def variable_id=(id)
+    # TODO  I need a better way to restrict access to this
+    # TODO  This would be nicer if it wasn't so hard coded ./lib/core/variable/Unknown.rb
+    #unless caller.first.split(':')[0]==__FILE__ or caller.first.split(':')[0]=='./lib/core/variable/Unknown.rb'
+    #  raise StandardError.new('Illegal attempt to set variable_id')
+    #end
+    @variable_id = id
+  end
+  
+  # Returns an array of instance calls that are possible given the 
+  # provided variables.
+  # 
+  # @param  available   
+  #
+  def instance_calls(available=[],used_in_declaration_statement=false)
+    results = []
+
+    # Create runtime_method.push(runtime_value)                 
+    ##  Find all the statement variables
+    available.find_all {|x| x.kind_of?(StatementVariable)}.each do |y|
+      #results.push(InstanceCallContainer.new(self.copy,PushStatement.new,y.copy))    
+      # TODO  What is PushStatement for
+      results.push(InstanceCallContainer.new(self.copy,Push.new,y.copy))    
+    end
+    return results             
+  end
+  
+  # Returns an array of instances calls that return a value and are 
+  # therefore approriate for declaration statements. 
+  # 
+  # NOTE  Although .push does return a value I have excluded it because 
+  #       I want to limit the number of variables declared.
+  #
+  def returning_instance_calls(available)
+    return []  
+  end
+  
+  # Returns an array of desctructive instance calls given the available
+  # variables.
+  # 
+  # @param  available     An array of other variables that can be used as
+  #                       parameters. 
+  #
+  def destructive_instance_calls(available=[])
+    return instance_calls(available)
+  end
+  
+#  # Returns a declaration variable for this runtime method variable. 
+#  #
+#  def to_declaration
+#    return VariableDeclaration.new(RuntimeMethodParameter)
+#  end  
+  
+end

data/lib/core/variable/StatementVariable.rb

@@ -0,0 +1,72 @@
+class StatementVariable < TypeVariable
+  
+  def initialize(val)
+    super(val)
+  end
+  
+  def copy
+    copied = self.class.new(@value.copy) {{:variable_id => self.variable_id,:uniq_id=>@uniq_id, :uniq_id_history=>@uniq_id_history.copy}}
+    copied.variable_id = self.variable_id
+    return copied
+  end  
+  
+  # Only let this method be called from fellow Fixnum classes or Unknowns
+  def variable_id=(id)
+    # TODO  This would be nicer if it wasn't so hard coded ./lib/core/variable/Unknown.rb
+    unless caller.first.split(':')[0]==__FILE__ or caller.first.split(':')[0]=='./lib/core/statement/Statement.rb'
+      raise StandardError.new('Illegal attempt to set variable_id')
+    end
+    @variable_id = id
+  end     
+  
+  # Returns a copy of the variable, this method exists in the
+  # instance call class.  It avoids distinguishing the two.  
+  # Since variale is lowest level context doesn't matter.
+  #
+  def copy_contextual_variable
+    return copy
+  end    
+  
+  # Returns an array of instance calls the Statement instances can call.  Some
+  # method calls require parameters.  These parameters are in the available
+  # array.
+  # 
+  # @param  available     An array of variables to be included in the creation 
+  #                       of the InstanceCallContainer.
+  #
+  def instance_calls(available=[])
+    declared_variable_call = InstanceCallContainer.new(self.copy,DeclaredVariable.new)
+    return [declared_variable_call]
+  end
+  
+  # Returns an array of instances calls that return a value and are 
+  # therefore approriate for declaration statements. 
+  #
+  def returning_instance_calls(available=[])
+    return instance_calls(available)  
+  end  
+  
+  #
+  def destructive_instance_calls(available=[])
+    return [] 
+  end
+  
+  # Compares the passed argument and returns true if it is a unknown 
+  # variable which is treated as a wild card or a variable with
+  # the same value.  
+  # 
+  # TODO  I'm not sure I like UnkownVariables being treated as wild cards
+  #
+  def equivalent?(to)
+    return true if to.kind_of?(Unknown)
+    return false if to.class != self.class
+    # TODO  I don't know if this is an equivalent comparision
+    return false unless to.value.write == @value.write
+    return true
+  end      
+  
+#  def to_var
+#    raise StandardError.new('Already a variable')
+#  end
+  
+end

data/lib/core/variable/StepVariable.rb

@@ -0,0 +1,7 @@
+class StepVariable < TypeVariable
+  
+  def initialize(val,id=nil)
+    super(val,id)
+  end
+  
+end

data/lib/core/variable/StringVariable.rb

@@ -0,0 +1,46 @@
+class StringVariable < TypeVariable
+  
+  def initialize(val,id=nil)
+    super(val,id)
+  end  
+  
+  # Returns an array of instance calls for the particular type
+  # variable.  For example:
+  #
+  # StringVariable.new('test').instance_calls
+  #
+  # might return [var.chop,var.length]
+  #
+  def instance_calls(available=[])
+    
+    # Add the chop instance call
+    chop_call = InstanceCallContainer.new(self.copy,Chop.new)
+    length_call = InstanceCallContainer.new(self.copy,StringLength.new)
+    return [chop_call,length_call]
+    
+  end  
+  
+  def to_declaration
+    return VariableDeclaration.new(self.class.to_s,@value.to_declaration)
+  end
+  
+  def to_literal_string
+    return @value.to_literal_string
+  end
+  
+  # TODO  I wan't to get rid of this call entirly
+  def copy_contextual_variable
+    return copy
+  end  
+  
+  # Returns an array of desctructive instance calls given the available
+  # variables.
+  # 
+  # @param  available     An array of other variables that can be used as
+  #                       parameters. 
+  #
+  def destructive_instance_calls(available=[])
+    return []
+  end    
+  
+end

data/lib/core/variable/TypeVariable.rb

@@ -0,0 +1,72 @@
+# This variable doesn't represent a specific data type it is merely the parent
+# of all the other typed variables e.g. FixnumVariable, StringVariable etc.
+#
+class TypeVariable < BaseVariable
+  attr_reader :value
+  
+  def initialize(val,id=nil)
+    @value = val
+    super(id)
+  end
+  
+  def copy
+    copied = self.class.new(@value.copy) {{:variable_id => self.variable_id,:uniq_id=>@uniq_id, :uniq_id_history=>@uniq_id_history.copy}}
+    copied.instance_variable = @instance_variable
+    return copied
+  end  
+  
+  # Only let this method be called from fellow Fixnum classes or Unknowns
+  # NOTE  I have allowed variable ids to be set to allow runtime methods to change 
+  #       the id of passed variables.  
+  def variable_id=(id)
+    # TODO  This would be nicer if it wasn't so hard coded ./lib/core/variable/Unknown.rb
+#    unless caller.first.split(':')[0]==__FILE__ or caller.first.split(':')[0]=='./lib/core/variable/Unknown.rb'
+#      raise StandardError.new('Illegal attempt to set variable_id')
+#    end
+    @variable_id = id
+  end    
+  
+  def literalisable?
+    return true
+  end
+  
+  def literalise
+    return Literal.new(@value.copy)
+  end
+  
+  def realised?
+    return true unless @value.nil?
+    return false
+  end
+  
+  def to_literal_string
+    return @value.to_literal_string
+  end    
+  
+  def describe(tab=0)
+    l = ''
+    tab.times {|x| l += "/t" }
+    l += '['+self.class.to_s+'] '+@value.write
+    l += "\n"
+    return l
+  end  
+  
+  
+  def cauldron_method_calls
+    return ['.value']
+  end      
+  
+  # Compares the passed argument and returns true if it is a unknown 
+  # variable which is treated as a wild card or a variable with
+  # the same value.  
+  # 
+  # TODO  I'm not sure I like UnkownVariables being treated as wild cards
+  #
+  def equivalent?(to)
+    return true if to.kind_of?(Unknown)
+    return false if to.class != self.class
+    return false unless to.value == @value
+    return true
+  end    
+  
+end

data/lib/core/variable/Unknown.rb

@@ -0,0 +1,116 @@
+#require $LOC+File.join(['lib','core','variable','Variable'])
+# TODO  This is not strickly a Variable - it is a data type of it's own
+
+class Unknown < BaseVariable
+  alias :variable_push :push
+  
+  # TODO  I think requirements here can be dropped
+  def initialize(*requirements)
+    super(*requirements)
+  end
+  
+  # Adds a new requirement to the unknown variable.  Unlike
+  # variables requirements can be added from outside the
+  # instance.
+  #
+  def push requirement
+    variable_push requirement
+  end
+  
+  # Returns a typed version of the variable with the correct
+  # variable id.  This occurs when an Unknown variable is 
+  # used in a statement and its value can be determined.
+  #
+  def classify(value)
+    case value.class.to_s
+      when 'String'
+        var = StringVariable.new(value)
+        var.variable_id = variable_id
+        return var
+      when 'Fixnum'
+        var = FixnumVariable.new(value)
+        var.variable_id = variable_id
+        return var
+    else
+      raise StandardError.new('Unknown data type '+value.class.to_s)
+    end
+  end
+  
+  # TODO  Test this
+  # TODO  Should 'Unknown' have a variable id
+  def copy  
+    result = self.class.new(*self) {{:variable_id => variable_id,:uniq_id=>@uniq_id,:uniq_id_history=>@uniq_id_history.copy}}
+    result.instance_variable = @instance_variable
+    return result
+  end  
+  
+#
+  def describe(tab=0,context=self)
+    
+    # Create a temporay copy of the variable
+    copied_var = self.copy
+
+    unless context == self
+      
+      # Return a duplicate variable with the requirements in the context indicated
+      copied_var = context.contextual_variable(copied_var.variable_id)
+      
+    end
+    
+    # Print the name of the variable
+    line = ''    
+    line += write
+    
+    # Print out each of the requirements
+    copied_var.each do |x|  
+      
+      #tmp = gets      
+      desc = x.describe(context)
+
+      #tmp = gets
+      desc.each_line do |l|
+        line += "\t"+l
+      end      
+      line += "\n" unless x == copied_var.last      
+    end
+    line += "\n"
+    
+    return line
+    
+  end  
+  
+  # Returns a copy of the variable, this method exists in the
+  # instance call class.  It avoids distinguishing the two.  
+  # Since variale is lowest level context doesn't matter.
+  #
+  def copy_contextual_variable
+    return copy
+  end  
+  
+  def to_literal_string
+    return 'var'  
+  end
+  
+  def realised?
+    return false
+  end
+  
+  def to_declaration
+    return VariableDeclaration.new('Unknown')
+  end
+  
+  def to_var(id=nil,uniq_id=nil)
+    StandardLogger.instance.warning('"Unknown" is NOT a variable - it is a data type')
+    #super(id)
+    return UnknownVariable.new(self) {{:variable_id => id,:uniq_id=>uniq_id}}
+  end
+  
+  # Unknown variables are evaluated are runtime so as along as it is
+  # a variable it is probably fine.
+  #
+  def equivalent?(to)
+    return true if to.kind_of?(BaseVariable)
+    return false
+  end
+  
+end