cauldron 0.1.3 → 0.1.5

data/lib/core/statement/TopologicalStatements.rb

@@ -1,34 +0,0 @@
-
-#class TopologicalStatements
-#  include TSort
-#   
-#  def initialize
-#    @dependencies = {}
-#  end
-#  
-#  def add_dependency(task,*relies_on)
-#    @dependencies[task] = relies_on
-#  end
-#  
-#  def tsort_each_node(&block)
-#    @dependencies.each_key(&block)
-#  end
-#  
-#  def tsort_each_child(node,&block)
-#    deps = @dependencies[node]
-#    deps.each(&block) if deps
-#  end
-#  
-#end
-
-# See http://www.ruby-doc.org/stdlib/libdoc/tsort/rdoc/classes/TSort.html#M009366
-class TopologicalStatements < Hash
-  include TSort
-   
-  alias tsort_each_node each_key
-  def tsort_each_child(node, &block)
-    fetch(node).each(&block)
-  end
-
-  
-end

data/lib/core/syntax/Addition.rb

@@ -1,26 +0,0 @@
-# TODO  Move to InstanceCall
-
-class Addition < InstanceCall
-  
-  def initialize
-    
-  end
-  
-  def copy
-    return self.class.new
-  end
-  
-  def write
-    return ' + '
-  end
-  
-  def to_literal_string
-    return write
-  end
-
-  def closure
-    #return [' ','']
-    return ['','']
-  end       
-    
-end

data/lib/core/syntax/BlockContainer.rb

@@ -1,102 +0,0 @@
-class BlockContainer < Array
-  
-  def initialize(*parameters)
-    super()
-    
-    parameters.each { |x| self.push(x) }
-  end
-  
-  def write
-    l = '|'
-    self.each do |x|
-      l += x.write
-      l += ', ' unless x.object_id == self.last.object_id
-    end
-    l += '|'
-    return l
-  end
-  
-  def describe
-    l = '|'
-    self.each do |x|
-      l += x.describe
-      l += ', ' unless x.object_id == self.last.object_id
-    end
-    l += '|'
-    return l    
-  end
-    
-  def write_with_uniq_id
-    l = '|'
-    self.each do |x|
-      (x.respond_to?('write_with_uniq_id')) ? l += x.write_with_uniq_id : l += x.write
-      l += ', ' unless x.object_id == self.last.object_id
-    end
-    l += '|'
-    return l
-  end  
-  
-  # Returns the block variables but with their values next to them.  This
-  # presumes that the block container has been realised.
-  #
-  def write_with_value
-    l = '|'
-    self.each do |x|
-      l += x.write_with_value
-      l += ', ' unless x.object_id == self.last.object_id
-    end
-    l += '|'
-    return l     
-  end
-  
-  # TODO  Write tests for this
-  def copy
-    return BlockContainer.new(*self.collect {|x| x.copy})
-  end
-  
-  # Returns true if all the block variables returned true.
-  def realised?
-    
-    # Go through each of the block variables and determine if they're realised
-    return false if self.any? {|x| x.realised? == false }      
-    return true
-      
-  end
-  
-  # Returns an updated block container where all the values for the block
-  # have been realised through the method map.
-  #
-  # @param  method_map    The history of the method that the block container
-  #                       is used in.
-  #
-  def realise2(method_map)
-    return self.copy if realised?
-    result = BlockContainer.new
-    self.each do |x|
-      result.push(x.realise(method_map))
-    end
-    return result
-  end
-  
-  # Returns an array of all the unrealised variables within the 
-  # block container.
-  #
-  def unrealised_variables
-    return variables.find_all {|x| x.realised? == false}
-  end
-  
-  # Returns an array of all the variables within this block container.
-  #
-  def variables
-    return self.collect {|x| x.copy}      
-  end
-  
-  # Returns each variable used within the block in turn.
-  #
-  def each_variable
-    variables.each do |x|        
-      yield x
-    end
-  end
-  
-end

data/lib/core/syntax/Boolean.rb

@@ -1,15 +0,0 @@
-class Boolean
-  
-  def initialize
-    
-  end
-  
-  def copy
-    return self.class.new
-  end
-  
-  def describe
-    write
-  end
-  
-end

data/lib/core/syntax/Code.rb

@@ -1,11 +0,0 @@
-module Code
-  
-  def initialize
-    
-  end
-  
-  def write(method_context=nil)
-    raise StandardError.new('write method needs defined for '+self.class.to_s)
-  end
-  
-end

data/lib/core/syntax/Do.rb

@@ -1,20 +0,0 @@
-class Do
-  include Code 
-  
-  def initialize
-    super  
-  end
-  
-  def write(method_context=nil)
-    return 'do'
-  end  
-  
-  def copy
-    return Do.new
-  end
-  
-  def creation
-    return 'Do.new'
-  end  
-  
-end

data/lib/core/syntax/False.rb

@@ -1,12 +0,0 @@
-class False < Boolean
-  
-  def initialize
-    super
-  end
-  
-  def write(context=nil)
-    return 'false'
-  end
-  
-  
-end

data/lib/core/syntax/If.rb

@@ -1,36 +0,0 @@
-class If
-  include Code 
-  
-  def initialize
-    super  
-  end
-  
-  def write(tab=0)
-    return ("\t"*tab)+'if'
-  end  
-  
-  def describe(tab=0)
-    return write(tab) 
-  end
-  
-  def copy
-    return If.new
-  end
-  
-  def creation
-    return 'If.new'
-  end    
-  
-  def to_literal_string
-    return write
-  end
-  
-end
-
-# TODO  I need to go over my "if statement" construction
-
-#  t = OpenStatement.new(
-#    Statement.new(
-#      If.new,test_cases[0][:params][0], Equivalent.new, test_cases[0][:output]
-#    )
-#  )

data/lib/core/syntax/Nil.rb

@@ -1,15 +0,0 @@
-class Nil
-  
-  def initialize  
-  end
-  
-  def copy
-    return self.class.new
-  end
-  
-  def write
-    return 'nil'
-  end
-    
-  
-end

data/lib/core/syntax/Return.rb

@@ -1,33 +0,0 @@
-
-class Return 
-  include Code
-  
-  def initialize
-    super
-  end
-  
-  def write(method_context=nil)
-    return 'return '
-  end
-  
-  def describe
-    return write
-  end
- 
-  def copy
-    return Return.new
-  end
-  
-  def creation
-    return 'Return.new'
-  end
-  
-  def to_declaration
-    return VariableDeclaration.new(self.class.to_s)
-  end
-  
-  def to_literal_string
-    return write
-  end
-    
-end

data/lib/core/syntax/Subtract.rb

@@ -1,19 +0,0 @@
-class Subtract  < InstanceCall
-  
-  def initialize
-    
-  end
-  
-  def copy
-    return self.class.new
-  end
-  
-  def write
-    return ' -'
-  end
-  
-  def closure
-    return [' ','']
-  end     
-  
-end

data/lib/core/syntax/This.rb

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

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

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

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