cauldron 0.1.3 → 0.1.5

data/lib/core/variable/StatementVariable.rb

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

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

data/lib/core/variable/StringVariable.rb

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

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

@@ -1,102 +0,0 @@
-
-# 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
-  
-  # 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  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|        
-      desc = x.describe(context)
-      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')
-    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

data/lib/core/variable/UnknownVariable.rb

@@ -1,29 +0,0 @@
-# NOTE FROM VARIABLE REFERENCE
-# I'm not sure if this is the way to go, but I need some way
-# to handle the case where variables reference variables. 
-#
-# For example:
-#
-#  #
-#  #
-#  def method_8
-#    var_12 = Statement.new(Unknown.new,Equal.new,8.to_declaration) 
-#    var_570 = var_12.declared_variable 
-#  end
-#
-# In this case it is difficult to realise var_570 since it references an 
-# unrealised variable.  I should maybe have created an Unknown class, but
-# it is still an Unknown.
-# 
-class UnknownVariable < TypeVariable
-  
-  def initialize(val,id=nil)
-    super(val,id)
-  end
-  
-  #
-  def destructive_instance_calls(available=[])
-    return [] 
-  end  
-  
-end

data/lib/core/variable/Variable.rb

@@ -1,70 +0,0 @@
-# This class represents any variable object used to help generate 
-# a method.
-#
-
-module Variable 
-  
-  include VariableIncluded
-  
-  @@variable_id = 0
-  
-  # The unique id is used to identify actually different variables.  This essentially occurs 
-  # when a destructive method call is used.  For example an two array variables might have the
-  # same variable_id say '2' so would both be written as 'var_2' but one of them might have had
-  # another element pushed into it e.g. 'var_2.push(6)'.  The changed variable would then 
-  # receive a different uniq_id. 
-  @@uniq_id = 0
-  
-  #CONST_TEST = 'test'
-  # 331 Constants are in capitals and accesses Variable::CONST_TEST class variables use @@    
-  
-  # Create the declaration for a unique variable id.  The unique_variable_id reflects the different
-  # values a variable might have.  For example if a variable is overwritten it will have the same
-  # name as it's predisessor but not the same value.
-  attr_reader :uniq_id, :scope_id
-  attr_writer :scope_id
-  
-  def self.reset_global_id
-    #http://www.zenspider.com/Languages/Ruby/QuickRef.html
-    unless $".include?('test/unit.rb')
-     StandardLogger.instance.log 'WARNING: Resetting variable id, this should only be done for tests'
-    end
-    @@variable_id = 0
-    @@uniq_id = 0    
-  end  
-  
-  def self.variable_id
-    return @@variable_id
-  end  
-  
-  # TODO  This is not a permenant method it is a temporary fix
-  #       as I migrate away from requirements.
-  #
-  def meets_requirements? of    
-    return true if of.literalise.value == self.value
-    return false
-  end
-  
-  # Change the value of the variables uniq_id
-  #
-  # @param  The new value for the variables uniq_id 
-  #
-  def uniq_id=(value)
-    @uniq_id = value
-    raise StandardError.new('Should be fixnum') unless value.kind_of?(Fixnum)
-  end
-  
-  # Updates the uniq_id for this variable so it can be regarded
-  # differently.  Uniq_ids are used in the CodeHandler to allow
-  # the inclusion of the correct statements to recreate a variable.
-  #
-  def increament_uniq_id!
-    @uniq_id = @@uniq_id    
-    @@uniq_id += 1
-  end
-  
-  def to_var(id=nil)
-    raise StandardError.new(self.class.to_s+' is already a Variable - should not call to_var')  
-  end
-  
-end

data/lib/core/variable/VariableContainer.rb

@@ -1,28 +0,0 @@
-class VariableContainer < BaseVariable
-  
-  attr_writer :realised
-  
-  def initialize
-    super()
-    
-    @realised = false
-  end  
-  
-  # Returns a duplicate of this variable container.  
-  # 
-  def copy
-    result = VariableContainer.new(){{:variable_id => self.variable_id,:uniq_id=>@uniq_id, :uniq_id_history=>@uniq_id_history.copy}}
-    result.instance_variable = @instance_variable    
-    self.each do |x|
-      result.push(x)
-    end
-    result.realised = @realised
-    return result        
-  end
-  
-  # TODO  Write description - hack for instance calls
-  def variable
-    return self
-  end
-  
-end

data/lib/core/variable/VariableIncluded.rb

@@ -1,27 +0,0 @@
-# Classes that include this module are presumeed to include a variable,
-# this is is used in the following classes.
-#
-# Variable
-# InstanceCallContainer
-# ArrayAccess
-#
-module VariableIncluded
-  
-  # Should have the following methods
-  # variable
-  
-  # Returns the variable.  This call also exists in the InstanceCallContainer class.  It is
-  # included to allow access of the variable with the need to disgiush whether it
-  # is variable or an instance call.
-  #
-  def variable
-    return self
-  end    
-  
-  # Returns the actual variable with the specified id. 
-  #
-  def find_actual_variable(id)
-    raise StandardError.new('Method needs defined in class')  
-  end
-  
-end