cauldron 0.1.3 → 0.1.5

data/lib/core/tracking/History.rb

@@ -1,167 +0,0 @@
-# Contains the usage history of a method, or a statement group etc. The current structure is
-# something like the following:
-#
-# [0] = {line:1,available_variables:[var_0,var_1],action:"'test'"}
-# [1] = {line:2,available_variables:[var_0,var_1,var_2],action:"'test'.chop"}
-#
-# Actually the history object should probably save what happens to variables at
-# each line aswell.  Although I should frame this in a example so I rember.
-# 
-# One of the purposes of the history object is to refactor code.  So
-# if I have three chop statements.
-# 
-# var_0 = 'test'
-# var_1 = var_0.chop
-# var_2 = var_1.chop
-# var_3 = var_2.chop (ending with var_3 = 't')
-#
-# Now I'm to abstract that process so I come up with the method
-# 
-# var_0 = 'test'
-# 3.times do |i|
-#   var_0 = var_0.chop
-# end
-# 
-# In both cases they end up with a value of 't' but how can we be sure that 
-# replacing one process with the other is equivalent?  Well of course they're 
-# not identical and I am tempted to just use there final value but I would
-# be concerned with the likes of numbers for example the number 2.
-#
-# What about if I consider them as literal values.  Then their history can be
-# expressed.
-#
-# 'test' -> 'test'.chop -> 'tes'.chop -> 'te'.chop -> 't'
-#
-class History < Array
-  
-  def initialize(*paramaters)
-    super()
-    self.each do |x|
-      self.push(x)
-    end
-  end
-  
-  # Create a copy of the history instance.
-  #
-  def copy
-    return History.new(*self.collect {|x| x.copy} )  
-  end
-  
-  def cauldron_method_calls
-    result = ['.length','.any?']
-    return result
-  end  
-  
-  # Returns an array of steps that include the variable 
-  # specified.
-  #
-  # @param  id      The id of the variable that should be included in all the 
-  #                 returned steps.
-  #
-  def find_steps_with_variable(id)
-    results = []
-    self.each do |x|
-      results.push(x) if x['variables'].any? {|y| y['id'] == id}
-    end
-    return results
-  end
-  
-  # Returns the values for the unique variable id specified.  NOTE
-  # it is important to use the unique variable id to avoid any
-  # mistaken interpretation.
-  #
-  # TODO  This should be using unique_variable id to avoid the risk of 
-  #       miss interpretation
-  #
-  def find_value_for(variable_id)
-    results = []
-    
-    # Find all the values for the particular id
-    self.each do |x|
-      results += x['variables'].find_all {|y| y['id']==variable_id}
-    end
-    return results.first['value']
-
-  end
-  
-  # Returns a realised variable reflecting the id supplied.  It 
-  # can be either a VariableContainer, TypedVariable and BlockVariable.
-  #
-  # TODO  I still havn't properly worked how to distinguish between types of variables
-  #
-  # @param  variable_id     The variable id that should be realised and returned
-  # @param  variable_type   A string indicating the type of variable that is being 
-  #                         realised.  This is basically used to distinguish between
-  #                         block variables and variable containers.  NOTE if the variable
-  #                         doesn't have multiple values it won't be VariableContainer - just
-  #                         a type variable.
-  # 
-  def find_realised_variable(variable_id,uniq_id,variable_type='VariableContainer')
-        
-    raise StandardError.new('Expecting Fixnum') unless uniq_id.kind_of?(Fixnum)
-
-    # Find all the values for the particular id
-    # TODO  Because there is a step class I could use more custom methods
-    results = self.inject([]) do |total,x|
-      total += x['variables'].select {|y| y['uniq_id'] == uniq_id}
-      total
-    end
-    
-    # If all values have the same absolute id return a type variable.
-    # (this means the value of the variable doesn't change through the method)
-    if results.all? {|x| x['abs_id']==results.first['abs_id']}     
-      raise StandardError.new('Unable to find variable with id '+variable_id.to_s+' and uniq_id '+uniq_id.to_s) if results.empty?
-      
-      # TODO  I don't know how to handle the situation where I have a reference to 
-      #       a variable.  So the value of var_570 points to the UnkownVariable.  In
-      #       which case we have a UnknownVariable - which is just getting
-      #       a bit rediculous.
-      #  #
-      #  #    
-      #  def method_8
-      #    var_12 = Statement.new(Unknown.new,Equal.new,8.to_declaration) 
-      #    var_570 = var_12.declared_variable 
-      #  end
-      # TODO  This better track mulitple values - I should at least indicate them
-      return results.first['value'].to_var(variable_id,uniq_id)
-
-    end
-    
-    raise StandardError.new('variable '+variable_id.to_s+' has multiple values but no variable_type was supplied') if variable_type.nil?
-
-    case variable_type
-      when 'BlockVariable'
-
-        # Find all the unique variable ids
-        unique_results = []
-        results.each do |x| 
-          unique_results.push(x) unless unique_results.any? {|y| y[:abs_id] == x[:abs_id]}
-        end
-        
-        # Convert each result into a variable and return a new block variable
-        new_block_variable = BlockVariable.new() {{:variable_id=>variable_id,:uniq_id=>uniq_id}}
-        unique_results.each do |x|
-          new_block_variable.push(x[:value].to_var(variable_id))
-        end
-        return new_block_variable
-        
-      when 'VariableContainer'
-        
-        # Find all the unique variable ids
-        unique_results = []
-        results.each do |x| 
-          unique_results.push(x) unless unique_results.any? {|y| y[:abs_id] == x[:abs_id]}
-        end
-        
-        # Convert each result into a variable and return a new block variable
-        # TODO  This should probable include the uniq_id as well
-        new_container_variable = VariableContainer.new() {{:variable_id=>variable_id,:uniq_id=>uniq_id}}
-        unique_results.each do |x|
-          new_container_variable.push(x[:value].to_var(variable_id))
-        end
-        return new_container_variable
-     end
-    raise StandardError.new('Method not able to handle different type of variables') 
-  end
-  
-end

data/lib/core/tracking/RuntimeTrackingMethod.rb

@@ -1,32 +0,0 @@
-# This is a special runtime method that is used to track changes in a method
-# as it is being run. 
-# 
-# The call to the tracking method looks something like this:
-#
-# tracking_method(line,action,variables=[])
-#
-class RuntimeTrackingMethod < RuntimeMethod
-  
-  #
-  # @param  instance_tracking_variable   The instance variable that contains each tracked event.
-  #
-  def initialize(instance_tracking_variable)
-    @line = MethodParameter.new
-    @statement_id = MethodParameter.new    
-    @variables = MethodParameter.new
-    @action = MethodParameter.new
-    super( MethodUsage.new(@line,@statement_id,@variables,@action) )
-
-    # Add the statements that are used in the tracking method    
-    self.push HackStatement.new(instance_tracking_variable.write+' = History.new if '+instance_tracking_variable.write+'.nil?')
-    x = instance_tracking_variable.write+".push(Step.new(
-      #{@line.write},    
-      #{@statement_id.write},      
-      #{@variables.write},         
-      #{@action.write}
-     ))"
-    self.push HackStatement.new(x)
-     
-  end
-  
-end

data/lib/core/tracking/Step.rb

@@ -1,52 +0,0 @@
-# This class represents one of the steps inside a history object.  It will look something 
-# like the following:
-# 
-# {
-#   "variables"=>[
-#     {"id"=>3, "value"=>"Grim Fandang", "abs_id"=>-606538658, :uniq_id=>3}, 
-#     {"id"=>1, "value"=>"Grim Fandango", "abs_id"=>-606538498, :uniq_id=>2}
-#   ], 
-#   "line"=>1, 
-#   "statement_id"=>625, 
-#   "action"=>"var='Grim Fandango'.chop"}
-#
-class Step < Hash
-  
-  # 
-  # @param  variables     TODO  I'm not sure whether this should be the variables that have changed or just
-  #                             the ones available on this line.  I think it is only the variables that change value.
-  #
-  def initialize(line,statement_id,variables,action)
-    super()
-    self['variables'] = variables
-    self['line'] = line
-    self['statement_id'] = statement_id
-    # TODO  action can proably be dropped - or just replaced with statement.write - I don't
-    #       think to_literal_string is useful.
-    self['action'] = action
-  end
-  
-  # Returns the data for the variable thats id was specified.
-  #
-  # @param  id    The id of the variable thats id should be returned
-  #  
-  def find_data_for_variable(id)
-    missing_variable = lambda { raise StandardError.new('Couldn\'t find information on variable '+id.to_s) }
-    return self['variables'].detect(missing_variable) {|x| x['id']==id} 
-  end
-  
-  def to_var(id=nil,uniq_id=nil)
-    # TODO  I don't know if the the block is used anymore
-    return StepVariable.new(self,id) {{:variable_id => id,:uniq_id=>uniq_id}}
-  end 
-  
-  def copy
-    # TODO  Don't use Marshal - do it properly
-    return Marshal.load(Marshal.dump(self))
-  end
-  
-  def cauldron_method_calls
-    return ["['statement_id']"]
-  end
-  
-end

data/lib/core/variable/ArrayVariable.rb

@@ -1,76 +0,0 @@
-
-class ArrayVariable < TypeVariable
-  attr_reader :variable_id  
-  
-  # TODO  Presumes that all parameters extends TypeVariable some are literals
-  def initialize(*parameters)
-    super(parameters)  
-    parameters.each { |x| self.push(x) }
-  end
-  
-  # TODO  Temporary overwrite - I'm not sure how to apply select_all for array variables.  
-  #       When you write the variable it's var5 but it still contains addition variables.  
-  def select_all(results=[],&block)
-    #results.push(self) if block.call(self)
-    return results
-  end
-  
-    #TODO  Write tests for all variables to maintain uniq_id_history
-  def copy
-    result = ArrayVariable.new(*self.collect {|x| x.copy} ) {{:variable_id => self.variable_id,:uniq_id=>@uniq_id,:uniq_id_history=>@uniq_id_history.copy}}
-    #result.variable_id = variable_id
-    result.instance_variable = @instance_variable
-    # TODO  I need to check uniq_id for 'copy' accross all the variables
-    #result.uniq_id = @uniq_id
-    return result
-  end
-  
-  def to_declaration  
-    return VariableDeclaration.new('ArrayVariable',*@value.collect {|x| x.to_declaration})
-  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'
-      unless caller.first.split(':')[0]==__FILE__ or caller.first.split(':')[0]=='./lib/ruby_code/Array.rb'
-        raise StandardError.new('Illegal attempt to set variable_id')
-      end
-    end
-    @variable_id = 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
-    results = []    
-    results.push InstanceCallContainer.new(self.copy,ArrayLength.new)
-
-    # Attempt to create access calls - firstly with index
-    self.length.times do |i|
-        results.push ArrayAccess.new(self.copy,Literal.new(i))
-    end
-
-    return results
-    
-  end    
-  
-  def to_literal_string
-    l = '['
-    self.each do |x|
-      l += x.to_literal_string
-      unless x.object_id == self.last.object_id
-        l += ','
-      end
-    end
-    l += ']'
-  end
-      
-end

data/lib/core/variable/BaseVariable.rb

@@ -1,152 +0,0 @@
-#require "set"
-# This was introduced so I could maintain the use of the class variable
-# @@variable_id with the ArrayVarialble without having to include 
-# requirements with the array.  
-#
-class BaseVariable < Array
-  attr_reader :variable_id , :instance_variable, :value, :uniq_id_history
-  attr_writer :instance_variable, :uniq_id_history
-  
-  include Variable
-  include Token
-  
-  # TODO  I think I'll get rid of the id parameter and just use blocks
-  # 
-  #  NOTE:  You can set the variable ids by passing it in a block
-  #         e.g. BaseVariable.new {[8,9]}
-  #         where 8 is the variable_id and unique_id is 9
-  #
-  def initialize(id=nil)  
-    super()
-    
-    # TODO  I should maybe include a check on all .copy methods to ensure a block is provided
-    # Set the variable id for the newly created variable    
-    if block_given?
-      # TEMP
-      if yield.kind_of?(Fixnum)
-        raise StandardError.new('Expecting array')
-      end
-      unless yield[:variable_id].nil?      
-        @variable_id = yield[:variable_id]      
-      else
-        @variable_id = @@variable_id
-        @@variable_id += 1
-        # TODO  Should have a separate call that returns @@variable_id and increaments @@variable_id
-      end
-      unless yield[:uniq_id].nil? 
-        raise StandardError.new('Expecting Fixnum') unless yield[:uniq_id].kind_of?(Fixnum)
-        @uniq_id = yield[:uniq_id]
-      else  
-        @uniq_id = @@uniq_id
-        @@uniq_id += 1
-      end
-      
-      @uniq_id_history = yield[:uniq_id_history] unless yield[:uniq_id_history].nil? 
-      
-    else
-      if id.nil?
-        @variable_id = @@variable_id
-        @@variable_id += 1      
-      else
-        @variable_id = id
-      end
-      
-    end
-    
-    # Give the variable an unique id
-    if @uniq_id.nil?
-      @uniq_id = @@uniq_id 
-      #raise StandardError.new('Uniq id change point') if (@uniq_id+1) == 86
-      @@uniq_id += 1      
-    end
-    
-    @uniq_id_history ||= []
-    
-    # Flag indicating if this is a scope variable or a instance variable
-    @instance_variable = false
-    
-  end
-  
-  def self.reset_global_id
-    #http://www.zenspider.com/Languages/Ruby/QuickRef.html
-    unless $".include?('test/unit.rb')
-      StandardLogger.log 'WARNING: Resetting variable id, this should only be done for tests'
-    end
-    @@variable_id = 0
-  end
-  
-  # Returns the variable if the ids matched
-  #
-  # @param  id    The uniq_id of the variable that is being looked for
-  #
-  def find_actual_variable(uniq_id)
-    return self if @uniq_id == uniq_id
-    throw :variable_not_found
-  end  
-  
-  # Returns an array of instance calls that can be created from
-  # this variable.
-  #
-  # NOTE: I checked that instance_calls wasn't a intrinsic method.
-  # 
-  # TODO  Test this (esp with ArrayVariable)
-  #
-  def instance_calls(with=[])
-    return [] unless self.realised? 
-
-    # Attempt to retrieve the literal value for the variable
-    #val = self.literalise.value
-    val = self.value
-    
-    # TODO  I suspect this method is redundant since it is always overwritten
-    
-    # Now retrieve all the possible instance call structures for that value
-    results = []
-    val.instance_call_structures.each do |struct|
-
-      if struct.instance_class != self.class then raise StandardError.new('Unexpected class type: - expecting '+val.class.to_s+' but was '+struct.instance_class.to_s) end
-      
-      # Now create a method call of the instance call
-      inst_call = InstanceCallContainer.new(self.copy,struct.method_call.copy) 
-      results.push inst_call
-
-    end
-    return results    
-  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(with=[])
-    raise StandardError.new(" 'destructive_instance_calls' method should be overridden for "+self.class.to_s)
-  end
-  
-  #
-  # 
-  #
-  def write()
-    if (@instance_variable)
-      return '@var_'+variable_id.to_s    
-    end
-    return 'var_'+variable_id.to_s    
-  end  
-  
-  def write_with_uniq_id
-    if (@instance_variable)
-      return '@var_'+variable_id.to_s+'_u'+uniq_id.to_s    
-    end
-    return 'var_'+variable_id.to_s+'_u'+uniq_id.to_s            
-  end
-  
-  # Always returns true since realised variables should extend this class
-  # but overwrite this method.
-  #
-  def realised? 
-    return false  
-  end
-  
-end