cauldron 0.1.0

data/lib/core/syntax/This.rb

@@ -0,0 +1,40 @@
+# Not sure how or is this class will be used but it is meant as contextual 
+# reference to a different instance.
+# 
+# TODO  Check whether this needs to be an array
+#
+class This < Array
+  
+  #
+  # @param  method_call     The name of any method call if any.   For example:
+  #                         self.class  
+  #
+  def initialize(*parameters)
+    super()
+    
+    # Save any requirements
+    parameters.collect {|param| self.push param}
+  end
+  
+  # @param  variable    The variable "self" refers to.  This is dependent on
+  #                     where the instance is used.
+  #
+  def write(context=nil,variable=nil)
+    if context.nil? then return 'self' end
+    if variable.nil? then return 'self' end            
+    return context.display_name_for(variable)
+  end
+  
+  def describe(context=nil,variable=nil)
+    return write(context,variable)+"\n"
+  end
+  
+  def copy
+    return This.new
+  end
+  
+  def declaration_statement
+    return ClassMethodCallContainer.new(ThisClass.new,New.new)
+  end
+  
+end

data/lib/core/syntax/True.rb

@@ -0,0 +1,20 @@
+
+class True < Boolean
+  
+  def initialize
+    
+  end
+  
+  def write
+    return 'true'
+  end
+  
+  def describe
+    return write
+  end
+  
+  def copy
+    return True.new
+  end
+  
+end

data/lib/core/syntax/syntax.rb

@@ -0,0 +1,24 @@
+class Next 
+  include Code
+  
+  def initialize
+    super
+  end
+  
+  def write(tab=0)
+    return ("\t"*tab)+'next'
+  end
+ 
+  def copy
+    return Next.new
+  end
+  
+  def to_declaration
+    return VariableDeclaration.new(self.class.to_s)
+  end
+  
+  def to_literal_string
+    return write
+  end
+    
+end

data/lib/core/tracking/ActsAsTrackable.rb

@@ -0,0 +1,65 @@
+module ActsAsTrackable
+  
+  # Returns a tracking statement for the line supplied.  The tracking call 
+  # contains the following values.
+  # 
+  # line                The line the statement occurs on
+  # action              The statement written as a literal string - I'm not sure whether or not this is 
+  #                     important value or not yet.
+  # variables           An array of variables used in the statement - they are saved in the following format
+  #                     {'id'=>4,'value'=>'Project Purity'}.  As such the variables only have literal values.
+  #                     NOTE: Currently I am only saving the variables in the statement but it might be 
+  #                     prudent later to save all the variables available to statement.
+  # local_variables     saves an array with the name of all the variables in scope.
+  #
+  # @param  tracking_method   The runtime method that gets called to retain to tracking information
+  # @param  line              The line the tracking call represents (NOTE Currently the line is represented
+  #                           by the length of an array to keep scope between methods)
+  #                           TODO  I would rather be able to use a single variable.
+  # @param  statement         The statement represented by the tracking call this can be nil if it is 
+  #                           the start of a method.
+  # @param  variables_value   An array of variable values and ids stored in a hash e.g.
+  #                           [{'id'=>4,'value'=>'Project Purity'},..]
+  #
+  def tracking_statement(tracking_method,line,statement_id=nil,variables_value=[],statement=nil) 
+    (statement.nil?) ? action = '' : action = statement.to_literal_string
+    params = [line.length,statement_id,variables_value,action]
+    line.push(1)
+    track_statement = Statement.new(DefCall.new(NilVariable.new,tracking_method,*params))
+    return track_statement
+  end  
+  
+  # Returns an array of variables abstracted from the variable containers in
+  # the format used by the tracking statement.  A variable container includes 
+  # a statement, nested statement, block container and runtime method. This is 
+  # essentially every variable used in the variable container.
+  #
+  # The variables are returned in the following format: 
+  #   [{id'=>4,'value'=>'Project Purity'},
+  #   {id'=>4,'value'=>'Vault 101'},
+  #   {id'=>4,'value'=>'Brotherhood of Steel'}]
+  #
+  # @param  variable_containers   Any number of elements that may contain variables.
+  #
+  def abstract_variables_for_tracking(*variable_containers)
+    results = []
+    variable_containers.each do |x|
+      # NOTE  This breaks on the ParametersContainer
+      #x.each_variable do |y|
+      # NOTE  This breaks on statements
+      #x.each do |y|
+      # NOTE: This breaks histroy
+      #x.select {|z| z.kind_of?(Variable)}.each do |y|
+      x.select_all {|z| z.kind_of?(Variable)}.each do |y|
+        results.push(Hash[
+          'id'=>y.variable_id,
+          'uniq_id'=>y.uniq_id,
+          'value'=>InstanceCallContainer.new(y,Copy.new),
+          'abs_id'=>EvalCall.new("#{y.write}.object_id.to_s")
+         ])
+      end  
+    end
+    return results
+  end
+  
+end

data/lib/core/tracking/History.rb

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

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

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

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