cauldron 0.1.2 → 0.1.3

data/lib/core/statement/BlockStatement.rb

@@ -80,7 +80,7 @@ class BlockStatement < OpenStatement
     self.each do |x|
       l += x.write(tab+1)+"\n"
     end
-    tab.times {l += "\t" }    
+    tab.times {l += "  " }    
     l += 'end'+"\n"
     return l
   end

data/lib/core/statement/OpenStatement.rb

@@ -21,7 +21,7 @@ class OpenStatement < StatementGroup
   def write(tab=0)
     line = @statement.write(tab)+"\n"
     line += super(tab+1)
-    tab.times {line += "\t" }
+    tab.times {line += "  " }
     line += "end"
     return line
   end

data/lib/core/statement/Statement.rb

@@ -6,11 +6,7 @@ class Statement
   attr_reader :statement_id, :scope, :statement_level, :statement_id
   # TODO  scope and statement level are confusing - not sure of the difference (I think it's legacy)
   attr_writer :scope, :statement_level, :overrides, :statement_id
-  
-  #alias :array_push :push
-  
-    
-  
+
   @@statement_id = 0
   
   #
@@ -33,7 +29,6 @@ class Statement
     
     # Add the parameters to the array 
     parameters.each do |code|
-    #  self.push(code.copy)
       @nodes.push(code.copy)
     end
     
@@ -157,7 +152,7 @@ class Statement
     raise StandardError.new('Unexpexted class "'+tab.class.to_s+'" for Fixnum (number of tabs)') unless tab.kind_of? Fixnum
 
     line = ''
-    tab.times {line += "\t" }
+    tab.times {line += "  " }
     self.each do |code|
       line += code.write
       break if code.object_id == self.last.object_id
@@ -209,9 +204,6 @@ class Statement
       if code.kind_of?(Variable)
 
         line += code.write+'('+code.value.write+')'
-        # unless code == self.last
-          # line += ' '
-        # end
         next
       end
 
@@ -475,31 +467,32 @@ class Statement
   end
   
   # TODO  I should have a realised statement class
-  # Finds each element that satisfy the 
-  # 
-  # @param  var   The variable to replace any elements that match the block.
-  #
-  def replace_variable_if(var,&block)
-    container = []
-    @nodes.each do |x|
-      if x.kind_of?(Variable)
-        if block.call(x)
-          container.push(var)
-          next          
-        end
-      end
-      if x.kind_of?(InstanceCallContainer)
-        container.push(x.replace_variable_if(var,&block))
-        next
-      end
-      container.push(x.copy)
-    end
-    #return self.copy(*container)
-    copied = self.copy().clear
-    container.each {|x| copied.push(x) }
-    return copied
-      
-  end
+  
+  # # Finds each element that satisfy the 
+  # # 
+  # # @param  var   The variable to replace any elements that match the block.
+  # #
+  # def replace_variable_if(var,&block)
+    # container = []
+    # @nodes.each do |x|
+      # if x.kind_of?(Variable)
+        # if block.call(x)
+          # container.push(var)
+          # next          
+        # end
+      # end
+      # if x.kind_of?(InstanceCallContainer)
+        # container.push(x.replace_variable_if(var,&block))
+        # next
+      # end
+      # container.push(x.copy)
+    # end
+    # #return self.copy(*container)
+    # copied = self.copy().clear
+    # container.each {|x| copied.push(x) }
+    # return copied
+#       
+  # end
   
   # Returns a variable instance with the contextual requirements for the statement.
   # TODO  Don't really need these contextual_variable calls 
@@ -538,11 +531,11 @@ class Statement
     return target[0] unless target.empty?
     raise FailedToFindVariableError.new('Couldn\'t find a variable with the id '+uniq_id.to_s+' in "'+self.write+'"')    
   end
-
-  def replace_variable!(id,var)
+  
+  def replace_variable!(uniq_id,var)
 
     # Find the variable to be replaced
-    target = self.find_actual_variable(id)  
+    target = self.find_actual_variable(uniq_id)  
  
     #raise StandardError.new('Both target and variable should be the same class('+target.class.to_s+' != '+var.class.to_s+')') unless(target.kind_of?(var.class))
     # TODO  Should check for two variable kinds to two instance call kinds
@@ -582,32 +575,6 @@ class Statement
     self
   end
   
-  # Returns a declaration for this statement.  So it will look something
-  # like - 
-  # Statement.new(StringVariable.new('test'),Equal.new,'test')
-  # 
-  # @param except   An array of variable ids indicating what variables not to convert to 
-  #                 new declarations.  This is useful when you don't want to redclare an
-  #                 exisitng variable.
-  #             
-  #                 e.g.
-  #                 Statement.new(Unknown.new,Equal.new,var_12,Addition.new,Literal.new(9))
-  #
-  def to_declaration(except=[])
-    if except.empty? then return VariableDeclaration.new('Statement',*self.collect {|x| x.to_declaration}) end
-    results = []
-    self.each do |x|
-      if x.kind_of?(Variable)
-        if except.any? {|y| x.variable_id == y}
-          results.push Declaration.new(x.write)
-          next
-        end
-      end
-      results.push x.to_declaration
-    end
-    return VariableDeclaration.new('Statement',*results)
-  end    
-  
   # Returns the id of the variable declared in this statement
   #
   def declared_variable_id
@@ -740,26 +707,26 @@ class Statement
     result = self.copy
     
     # Find value(s) for each unrealised variable.  
-    y = []
+    realised_variables = []
     each_unrealised_variable do |x|
       if x.kind_of?(BlockVariable)
-        y.push(method_map.find_realised_variable(x.variable_id,x.uniq_id,'BlockVariable'))
+        realised_variables.push(method_map.find_realised_variable(x.variable_id,x.uniq_id,'BlockVariable'))
       else
-        y.push(method_map.find_realised_variable(x.variable_id,x.uniq_id))
+        realised_variables.push(method_map.find_realised_variable(x.variable_id,x.uniq_id))
       end
       # TODO  Change to elsif x.kind_of?(Variable)
     end
 
     # Substitue the realised variables for the unrealised ones
-    self.each_unrealised_variable do |x|
+    self.each_unrealised_variable do |var|
       catch(:variable_substituted) do
-        y.each do |z|
-          if z.uniq_id == x.uniq_id
-            result = result.replace_variable_if(z) {|a| a.uniq_id == x.uniq_id}
+        realised_variables.each do |z|
+          if z.uniq_id == var.uniq_id
+            result.replace_variable!(var.uniq_id,z)
             throw :variable_substituted
           end
         end
-        raise StandardError.new('Couldn\'t find realised value for variable with id '+x.variable_id.to_s+' in "'+self.write+'"')
+        raise StandardError.new('Couldn\'t find realised value for variable with id '+var.variable_id.to_s+' in "'+self.write+'"')
       end
     end
     return result
@@ -888,28 +855,6 @@ class Statement
     return false
   end    
   
-  # Returns the statement with the any variables in the conversions 
-  # table replaced with the supplied variables. This is used when 
-  # a runtime method with parameters needs evaluated.
-  #
-  # @param  conversions   A hash that identifies the uniq id's of the variables 
-  #                       that should be replaced.
-  #                       e.g. {:6 => <#Variable>,:8 => <#Variable>} where variables with id 6 would
-  #                       changed to indicated variable.
-  #                   
-  def exchange_variables(conversions)
-    copied_statement = self.copy
-    conversions.each do |x,y|
-      begin 
-        #copied_statement = copied_statement.subst(x.to_s.to_i,y.copy)
-        copied_statement = copied_statement.replace_variable_if(y) {|a| a.uniq_id == x.to_s.to_i}
-      rescue FailedToFindVariableError
-        next
-      end
-    end
-    return copied_statement
-  end
-  
   def cauldron_method_calls
     return ['.statement_id']
   end  

data/lib/core/statement/TheoryStatement.rb

@@ -57,7 +57,7 @@ class TheoryStatement < Statement
   # TODO  Maybe use a opject to handle the output of the statement.
   def describe(tab=0)
     line = ''
-    tab.times {line += "\t" }
+    tab.times {line += "  " }
     self.each do |code|
       line += code.describe
       break if code.object_id == self.last.object_id

data/lib/core/syntax/BlockContainer.rb

@@ -63,34 +63,6 @@ class BlockContainer < Array
       
   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.
   #

data/lib/core/variable/MethodParameter.rb

@@ -64,7 +64,7 @@ class MethodParameter < BaseVariable
     copied_var.each do |x|  
       desc = x.describe(context)
       desc.each_line do |l|
-        line += "\t"+l
+        line += "  "+l
       end      
       line += "\n" unless x == copied_var.last      
     end

data/lib/required.rb

@@ -107,22 +107,9 @@ require $LOC+File.join(['core','statement','HashAccess'])
 require $LOC+File.join(['core','statement','TopologicalStatements'])
 require $LOC+File.join(['core','statement','TheoryStatement'])
 
-require $LOC+File.join(['core','structure','StatementStructure'])
-require $LOC+File.join(['core','structure','FixnumAdditionStructure'])
-require $LOC+File.join(['core','statement','StatementStructure2'])
-require $LOC+File.join(['core','structure','InstanceCallStructure'])
-require $LOC+File.join(['core','structure','InstanceCallContainerStructure'])
-require $LOC+File.join(['core','structure','DeclareRuntimeMethodStructure'])
-require $LOC+File.join(['core','structure','DeclareNewInstanceStructure'])
-require $LOC+File.join(['core','structure','DeclareVariableAsLiteralStructure'])
-require $LOC+File.join(['core','structure','DeclareVariableAsVariableStructure'])
-require $LOC+File.join(['core','structure','ReturnStructure'])
-
-require $LOC+File.join(['ScopeDependencies'])
 require $LOC+File.join(['MappingValues'])
 require $LOC+File.join(['Mapping'])
 
-require $LOC+File.join(['core','statement','StatementDependencies'])
 require $LOC+File.join(['core','statement','BlockStatement'])
 require $LOC+File.join(['core','statement','SingleLineBlockStatement'])
 
@@ -225,10 +212,11 @@ require $LOC+File.join(['core','ClassMethodCallContainer'])
 require $LOC+File.join(['CodeHandler'])
 require $LOC+File.join('Chain')
 require $LOC+File.join('UnifiedChain')
+require $LOC+File.join('PartialChain')
 require $LOC+File.join('implemented_chain')
 require $LOC+File.join('ChainMapping')
 
 # TEST HELPERS
 require $LOC+File.join(['theories'])
-
+require $LOC+File.join(['cauldron','util','home'])
 require $LOC+File.join(['cauldron','pot'])

data/lib/theories.rb

@@ -9,7 +9,6 @@ module ContainsTheories
   def setup
     @theory_1 = Theory.load_theory(1)
     @theory_2 = Theory.load_theory(2)
-    #@theory_3 = Theory.load_theory(3)
     @theory_3 = theory_3    
   end
   

data/lib/theory/ActionImplementation.rb

@@ -11,7 +11,7 @@ class ActionImplementation < TheoryAction
   end
   
   def write(tab=0)
-    return ("\t"*tab)+"runtime_method.add_statement_at(#{@action.write},#{@target_id.write})"
+    return ("  "*tab)+"runtime_method.add_statement_at(#{@action.write},#{@target_id.write})"
   end    
   
 end

data/lib/theory/TheoryAction.rb

@@ -27,11 +27,11 @@ class TheoryAction
   #    
   def describe(tab=0)
     # TODO  That is nicer way to do tabs - I should make the other methods consistent with it
-    return ("\t"*tab)+"<runtime_method>.add_statement_at(#{@action.describe},#{@target_id.describe})"
+    return ("  "*tab)+"<runtime_method>.add_statement_at(#{@action.describe},#{@target_id.describe})"
   end
   
   def write(tab=0)
-    return ("\t"*tab)+"<runtime_method>.add_statement_at(#{@action.write},#{@target_id.write})"
+    return ('  '*tab)+"<runtime_method>.add_statement_at(#{@action.write},#{@target_id.write})"
   end
   
   # Returns all the theory vairables in this theory action 

data/lib/theory/TheoryConnector.rb

@@ -64,13 +64,11 @@ class TheoryConnector
     unless complete_chains.empty? 
       return complete_chains 
     end
-    
     possible_chains.each do |chain|
         
       # Remove the head theory to avoid it being re-used
       head_free_theories = theories.copy
       head_free_theories.delete_if {|theory| theory.theory_id == chain.first.theory_id}      
-
       complete_chains += complete_chain(chain,head_free_theories)
     end
     return complete_chains
@@ -80,9 +78,9 @@ class TheoryConnector
   def complete_chain(chain,theories)
     res = catch(:complete) do
       converge_chain(chain,theories)
+      #raise StandardError.new('Failed to generate a chain')
+      return []
     end
-    
-    #return chains
     return [res] 
     
   end
@@ -94,19 +92,21 @@ class TheoryConnector
   end
   
   def converge_chain(chain,theories,step=0)
-    theories = remove_existing_theories(chain.copy,theories)
     
-    extended_chains = add_to_chain(chain.copy,theories,step)
+    theories = remove_existing_theories(chain.copy,theories.copy)
+    
+    extended_chains = add_to_chain(chain.copy,theories.copy,step)
     
     if extended_chains.any? {|x| x.complete? }
       res2 = extended_chains.select {|x| x.complete?}
-      throw :complete, res2.first      
+      raise StandardError.new('More than one complete chain found') if res2.length > 1
+      throw :complete, res2.first.freeze      
     end
-    closer_chains = closer_chains(chain.copy,extended_chains)
+    closer = closer_chains(chain.copy,extended_chains)
 
     complete_chains = []
-    unless closer_chains.empty?
-      closer_chains.each do |x|
+    unless closer.empty?
+      closer.each do |x|
         complete_chains += converge_chain(x,theories,step+1)
       end
     else 
@@ -265,9 +265,7 @@ class TheoryConnector
   # Returns a new chain so that they all use consistent theory variables ids
   #
   def unify_chain(chain)
-    
-    #return unify_chain2(chain.reverse)
-    
+
     # TODO  Break up this method and write tests for the individual parts
 
     # Find all the ways the theory and results can connected
@@ -398,7 +396,6 @@ class TheoryConnector
   # they should be considered equal.
   #
   def matching_variables(arrangements,uniq_chain)
-    #chains = []
     mappings = []
     arrangements.each do |arrangement|
       map = {}

data/lib/theory/TheoryImplementation.rb

@@ -54,6 +54,7 @@ class TheoryImplementation < Theory
     return true    
 
   end
+  
   # TODO  If I remove the code from this method then tc_theory_implementation.rb still
   #       passes all the tests!
   def evaluate_dependent(dependent,runtime_method,test_cases)
@@ -61,14 +62,14 @@ class TheoryImplementation < Theory
     last_runtime_method = runtime_method.copy
     eval dependent.statement.write 
     return false
-  end    
-
-  # # Returns all the theory vairables in this theory
-  # # dependent. 
-  # #
-  # # TODO  What is the point in this - why only the actions?
-  # def theory_variables
-    # return @action.select_all {|x| x.kind_of?(TheoryVariable)}
-  # end
+  end
 
+  def hash
+    @theory_id
+  end
+  
+  def eql?(value)
+    @theory_id == value.theory_id
+  end
+  
 end