cauldron 0.1.0

data/lib/core/structure/ReturnStructure.rb

@@ -0,0 +1,20 @@
+# Returns statements that return values 
+#
+# Example:
+#   return 7
+#   return var
+#
+class ReturnStructure < StatementStructure
+  
+  def initialize()
+    super()
+  end
+  
+  def statements(available=[])
+    
+    # Create return statements using the passed variables
+    return available.collect {|x| Statement.new(Return.new,x.copy)}      
+      
+  end 
+  
+end

data/lib/core/structure/StatementStructure.rb

@@ -0,0 +1,11 @@
+class StatementStructure < Array
+  
+  DECLARATION_STATEMENT = 'declaration_statement'
+  MODIFYING_STATEMENT = 'modifying_statement'
+  RETURN_STATEMENT = 'return_statement'
+  USAGE_STATEMENT = 'usage_statement'  
+  MISC_STATEMENT = 'misc_statement'
+  BLANK_STATEMENT = 'blank_statement'
+  IF_STATEMENT = 'if_statement'  
+  
+end

data/lib/core/syntax/Addition.rb

@@ -0,0 +1,25 @@
+# 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 [' ','']
+  end       
+    
+end

data/lib/core/syntax/BlockContainer.rb

@@ -0,0 +1,130 @@
+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 a block container where all the block variables
+  # have been realised.
+  #
+  # I had previously intended to just work out the values for the block
+  # but this would create problems when I have blocks within blocks.
+  # 
+  # NOTE  I have copied code here from the history call in RuntimeMethod
+  # 
+  def realise(statement,containing_method)
+    
+    # Create the method to track the change in values of the block variable
+    # TODO  I shouldn't need to redeclare this runtime method each time
+    #tracking_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new)) 
+    # Create the method that block values are logged to
+    instance_tracking_variable = ArrayVariable.new
+    instance_tracking_variable.instance_variable = true
+    tracking_method = RuntimeTrackingMethod.new(instance_tracking_variable)
+    
+    raise StandardError.new('This should not be used')
+    # Create a method to call the method and return the results
+    #process_method = RuntimeMethod.new(MethodUsage.new)
+    #process_method << Statement.new( DefCall.new(NilVariable.new) )
+    #process_method << Statement.new( Return.new,instance_tracking_variable )    
+    
+    # CONTINUE Look up the tracking method
+    #exit
+  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

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

data/lib/core/syntax/Code.rb

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

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

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

data/lib/core/syntax/If.rb

@@ -0,0 +1,28 @@
+class If
+  include Code 
+  
+  def initialize
+    super  
+  end
+  
+  def write(tab=0)
+    return ("\t"*tab)+'if'
+  end  
+  
+  def copy
+    return If.new
+  end
+  
+  def creation
+    return 'If.new'
+  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/IfContainer.rb

@@ -0,0 +1,100 @@
+# TODO  I'm not sure whether to keep the IfContainer class or just drop it
+#       and use Statement.new(If.new,Liter.new(9) etc..)
+#       if I don't change it IfContainer should probably become a type of Statement
+
+class IfContainer < Statement
+  
+  def initialize(*parameters)
+    # TODO  It would be better to use super here
+    #super(*parameters)
+    # TODO  i think this is just passed a statement - so it only ever has one parameter - I prefer it that way
+    #parameters.each { |x| self.push(x) }
+    parameters.each do |code|
+      self.push(code.copy)
+    end
+    
+    # TODO  I might change the statement_id to be determined by the structure
+    #       of the statement.
+    @statement_id = @@statement_id
+    @@statement_id += 1    
+    
+  end
+  
+  # Retunrs the contents of the if_container instance as string contained
+  # within paraenthesis e.g. 
+  # 
+  # if(var_a == var_b)
+  #
+  def write(indent=0)
+    line = If.new.write(indent)
+    line += '('
+    self.each do |x|
+      line += x.write
+      line += ' ' unless x.object_id == last.object_id
+    end
+    line += ')'
+    return line
+  end
+  
+  def describe(indent=0)
+    line = If.new.write(indent)
+    line += '('
+    self.each do |x|
+      line += x.describe
+      line += ' ' unless x.object_id == last.object_id
+    end
+    line += ')'
+    return line
+  end  
+  
+  def replace_theory_variables!(mapping)
+    self.each_with_index do |x,i|
+      if x.kind_of?(TheoryVariable) && mapping.has_key?(x.theory_variable_id)
+        self[i] = mapping[x.theory_variable_id].copy
+        next
+      end
+      self[i].replace_theory_variables!(mapping)
+    end
+  end        
+  
+  # TODO  Doesn't need to be here(duplicated results)
+  def select_all(results=[],&block)
+    results.push self if block.call(self)
+    self.each do |x|
+      if block.call(x)
+        results.push(x)
+      else
+      end
+      if x.respond_to?(:select_all) 
+        x.select_all(results,&block)  
+      end
+    end
+    return results
+  end
+  
+  # Returns a duplicate of this IfContainer instance
+  #
+  def copy 
+    a = IfContainer.new(*self.collect {|x| x.copy})
+    a.statement_id = @statement_id
+    return a 
+  end
+  
+  # TODO  Write tests for this
+  # Returns a string containing the syntax for the container but where
+  # all the values are literals e.g. 
+  #
+  # if(var_a == var_b) whould become "if(6 == 7)"
+  #
+  def to_literal_string
+    line = If.new.write
+    line += '('
+    self.each do |x|
+      line += x.to_literal_string
+      line += ' ' unless x.object_id == last.object_id
+    end
+    line += ')'
+    return line    
+  end
+  
+end

data/lib/core/syntax/Nil.rb

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

data/lib/core/syntax/Return.rb

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

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