cauldron 0.1.1 → 0.1.2

data/lib/core/statement/TheoryStatement.rb

@@ -21,6 +21,7 @@ class TheoryStatement < Statement
       end
       self[i].replace_theory_variables!(mapping) if self[i].respond_to?(:replace_theory_variables!)
     end
+    self
   end
   
   # TODO  This method was just nicked from TheoryDependent 

data/lib/core/variable/FixnumVariable.rb

@@ -4,15 +4,14 @@ class FixnumVariable < TypeVariable
     super(val,id)
   end
   
-  # TODO  Write test
   def to_declaration
     return VariableDeclaration.new('FixnumVariable',@value.to_declaration)
   end  
   
-  # TODO  I wan't to get rid of this call entirly
-  def copy_contextual_variable
-    return copy
-  end    
+  # # TODO  I wan't to get rid of this call entirly
+  # def copy_contextual_variable
+    # return copy
+  # end    
   
   # Returns true if the variable type is Fixnum,  this is used 
   # to determine whether a BlockVariable or VariableContainer 

data/lib/core/variable/Unknown.rb

@@ -1,4 +1,4 @@
-#require $LOC+File.join(['lib','core','variable','Variable'])
+
 # TODO  This is not strickly a Variable - it is a data type of it's own
 
 class Unknown < BaseVariable
@@ -9,14 +9,6 @@ class Unknown < BaseVariable
     super(*requirements)
   end
   
-  # Adds a new requirement to the unknown variable.  Unlike
-  # variables requirements can be added from outside the
-  # instance.
-  #
-  def push requirement
-    variable_push requirement
-  end
-  
   # Returns a typed version of the variable with the correct
   # variable id.  This occurs when an Unknown variable is 
   # used in a statement and its value can be determined.
@@ -36,7 +28,6 @@ class Unknown < BaseVariable
     end
   end
   
-  # TODO  Test this
   # TODO  Should 'Unknown' have a variable id
   def copy  
     result = self.class.new(*self) {{:variable_id => variable_id,:uniq_id=>@uniq_id,:uniq_id_history=>@uniq_id_history.copy}}
@@ -97,7 +88,6 @@ class Unknown < BaseVariable
   
   def to_var(id=nil,uniq_id=nil)
     StandardLogger.instance.warning('"Unknown" is NOT a variable - it is a data type')
-    #super(id)
     return UnknownVariable.new(self) {{:variable_id => id,:uniq_id=>uniq_id}}
   end
   

data/lib/core/variable/Variable.rb

@@ -27,7 +27,7 @@ module Variable
   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'
+     StandardLogger.instance.log 'WARNING: Resetting variable id, this should only be done for tests'
     end
     @@variable_id = 0
     @@uniq_id = 0    

data/lib/required.rb

@@ -143,7 +143,6 @@ require $LOC+File.join(['core','runtime_class','RuntimeMethodClass'])
 require $LOC+File.join(['core','runtime_class','MethodUsageClass'])
 require $LOC+File.join(['core','runtime_class','UnknownClass'])
 require $LOC+File.join(['core','runtime_class','StatementClass'])
-require $LOC+File.join(['core','runtime_class','IfStatementClass'])
 require $LOC+File.join(['core','runtime_class','ReturnClass'])
 require $LOC+File.join(['core','runtime_class','RuntimeClassClass'])
 require $LOC+File.join(['core','runtime_class','DefCallClass'])

data/lib/ruby_code/String.rb

@@ -13,7 +13,6 @@ class String
     return '\''+x+'\''
   end
   
-  # TODO  Write tests
   def instance_call_structures
     return [
       InstanceCallContainerStructure.new(StringVariable,Chop.new),
@@ -28,11 +27,6 @@ class String
     return StringVariable.new(self,var_id){{:variable_id => var_id,:uniq_id=>unique_id}}
   end
   
-  # TODO  This might have been superceeded by "to_declaration"
-  def creation
-    return self.write
-  end
-  
   def to_declaration
     return LiteralDeclaration.new(self.clone)
   end

data/lib/theory/TheoryConnector.rb

@@ -36,7 +36,7 @@ class TheoryConnector
   # Returns an array of complete chains that conclude with a valid 
   # runtime method.
   #
-  def generate_chains(runtime_method,test_cases,theories)
+  def generate_chains(runtime_method,test_cases,theories,exclude=[])
     
     theories = remove_irrelevant_theories(theories)
 
@@ -58,10 +58,15 @@ class TheoryConnector
       complete_chains += possible_chains.select {|x| x.complete?}
       possible_chains.delete_if {|x| x.complete?}
     end       
-    return complete_chains unless complete_chains.empty?
+    complete_chains = complete_chains.delete_if do |x|
+      exclude.any? {|y| y == x.theories_sequence}
+    end
+    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}      
@@ -73,56 +78,69 @@ class TheoryConnector
   end
   
   def complete_chain(chain,theories)
-    chains = converge_chain(chain,theories)
-    return chains 
+    res = catch(:complete) do
+      converge_chain(chain,theories)
+    end
+    
+    #return chains
+    return [res] 
     
   end
   
-  def converge_chain(chain,theories,step=0)
-
-    complete_chains = []
-    extended_chains = []
-    theories.each do |theory|
-      last_position = 1
-      chains = chain.add_link_to(theory,last_position,[])
-      next if chains.empty?      
-      extended_chains += chains
+  def remove_existing_theories(chain,theories)
+    theories.delete_if do |theory|
+      chain.theories_sequence.include?(theory.theory_id)
     end    
+  end
+  
+  def converge_chain(chain,theories,step=0)
+    theories = remove_existing_theories(chain.copy,theories)
     
-    # Are any of the chains complete
-    if extended_chains.any? {|x| x.complete? }
-      return extended_chains.select {|x| x.complete?}      
-    end
+    extended_chains = add_to_chain(chain.copy,theories,step)
     
-    closer_chains = []
-    extended_chains.each do |x|
-      if ((chain.unmet_dependents_ids-x.unmet_dependents_ids).length == chain.unmet_dependents_ids.length)
-        closer_chains << x
-      end    
+    if extended_chains.any? {|x| x.complete? }
+      res2 = extended_chains.select {|x| x.complete?}
+      throw :complete, res2.first      
     end
-    
+    closer_chains = closer_chains(chain.copy,extended_chains)
+
+    complete_chains = []
     unless closer_chains.empty?
       closer_chains.each do |x|
         complete_chains += converge_chain(x,theories,step+1)
       end
-    else
+    else 
       extended_chains.each do |x|
-        theories.each do |theory|
-          copied_chain = x.copy
-          last_position = 1
-          chains = copied_chain.add_link_to(theory,last_position,[])
-          chains.each do |z|
-            if ((chain.unmet_dependents_ids-z.unmet_dependents_ids).length == chain.unmet_dependents_ids.length)
-              complete_chains += converge_chain(z.copy,theories,step+1)
-            end            
-          end
-        end
+        complete_chains += converge_chain(x,theories,(step+1))
       end
     end
     
     return complete_chains
   end
   
+  def closer_chains(chain,chains)
+    closer_chains = []
+    chains.each do |x|
+      if ((chain.unmet_dependents_ids-x.unmet_dependents_ids).length == chain.unmet_dependents_ids.length)
+        closer_chains << x
+      end    
+    end    
+    return closer_chains
+  end
+  
+  def add_to_chain(chain,theories,step)
+    extended_chains = []
+    theories.each do |theory|
+      last_position = 1
+      chains = chain.add_link_to(theory,last_position,[])
+      
+      #chains = chain.extension_permutaions(theory,[])
+      next if chains.empty?
+      extended_chains += chains
+    end
+    return extended_chains    
+  end
+  
   def extend_chain(chain,theories)
     
     complete_chains = []
@@ -244,88 +262,6 @@ class TheoryConnector
     
   end
   
-  # Returns a new chain so that they all use consistent theory variables ids
-  #
-  # @param  chain   An array of theories e.g.
-  #                 [<#Theory>,<#Theory>,<#Theory>,<#Theory>]
-  # 
-  #                 The last chain contains the finished theory.
-  #  
-  # It is difficult to generate all the arrangements for the chain as soon as
-  # there start to be a large number of dependents and results.  There is just too
-  # many permutations.  Once any connection is decided upon e.g. this dependent to 
-  # that result then the number of permutations is reduced.  As such they need to 
-  # be updated in parallet.
-  #
-  # 
-  #
-  def unify_chain2(chain)
-    
-    unified_chains = []
-    
-    # Reverse the chain so that the finish is the first theory
-    reversed_chain = chain.reverse
-    
-    # This method needs to map the theory variables used in one theory to the 
-    # rest.  This basically means there is a global theory that has a respective
-    # id in each of the other theories in the chain. e.g.
-    #
-    # +----------+--------+--------+--------+--------+
-    # |Global #ID| link#1 | link#2 | link#3 | link#4 |
-    # +----------+--------+--------+--------+--------+
-    # |    0     |   1    |   1    |   2    |   89   |
-    # +----------+--------+--------+--------+--------+
-    # |    1     |   2    |   4    |   6    |   1    |
-    # +----------+--------+--------+--------+--------+
-    #
-    
-    # {global#ID=> #{link#1=>1,#link#2=>5}
-    
-    # Take the first theory and set the global theory variables to the first link
-    global_theory_variables = {}
-    
-    # * Pop the first link in the chain and set ids of the theory variables
-    link = chain.pop
-    link.all_theory_variables.each do |theory_variable|
-      
-      # For the first link I'm just going to use the same id as the first link
-      global_theory_variables[theory_variable.theory_variable_id] = {link.theory_id=>theory_variable.theory_variable_id}
-      
-    end
-    
-    # 1.  Find all the dependent-> result permutations for the last chain 
-    # 2.  Exclude any that are mutually exclusive
-    
-    #possible_global_theory_variables = extend_global_mapping(global_theory_variables,link,chain)
-    
-    # NOTE: Previously I had normalised the theories by working out all the possible permutations 
-    #       of dependent to result.  Then work out the variable substitution.  This did work but
-    #       the number of permutations for larger theories meant it was completely impractical.  Instead
-    #       now it needs to form one connection "dependent to result" and then update the consequence of
-    #       that. Some of the decisions will be mutually exclusive. 
-    
-    return unified_chains
-    
-  end
-  
-  def extend_global_mapping(global_theory_variables,link,chain,results=[])
-    
-    next_link = chain.pop
-    
-    # Find all the variables in the next link thats global ids have not been determined
-    unidentified_theory_variables = next_link.all_theory_variables.inject([]) do |total,x|
-      total << x if global_theory_variables.any? {|key,value| !value[next_link.theory_id].nil? }
-    end
-    
-    # Link the previous dependents to the this link
-    link.dependents.each do |dependent|
-      
-      # Find the similar 
-      
-    end 
-    
-  end
-  
   # Returns a new chain so that they all use consistent theory variables ids
   #
   def unify_chain(chain)
@@ -337,6 +273,7 @@ class TheoryConnector
     # Find all the ways the theory and results can connected
     # - the same_structure? approach is quite loose
     arrangements = chain_arrangements(chain.copy.reverse)
+    
     # For each theory in the chain give each each variable a unique id
     starting_id = 1
     uniq_chain = chain.inject([]) do |total,x|

data/lib/util/ClassEvaluation.rb

@@ -1,39 +1,17 @@
+
 # Used to make calls to a dynamically written class.
 #
 class ClassEvaluation
-  #include WriteParameters
   @@count = 0
   
-  def evaluate_class(runtime_class,runtime_call)
-    
-    # Create file to include the test method
-    #filepath = $LOC+File.join(['tmp','runtime_class_evaluation.rb'])    
-    filepath = $LOC+File.join(['tmp',runtime_class.class_name+'.rb'])        
-    file = File.open(filepath,'w+')
-    @@count += 1
-    
-    # Include the sytax for the statement in the file
-    file << runtime_class.write
-    file.close
-
-    # Load the newly created class and check the statement
-    load filepath
-    begin 
-      return eval("#{runtime_class.class_name}.new.#{runtime_call}")
-    rescue NameError => e
-      StandardLogger.instance.info(runtime_class.write)
-      raise e
-    end
-    
+  def evaluate_class(runtime_class,runtime_call)    
+    return evaluate_class_2(runtime_class,runtime_call)
   end
   
-  # TODO  This duplicates allot of the code above
   def evaluate_class_2(runtime_class,runtime_call,*params)
     
     # Create file to include the test method
-    #filepath = $LOC+File.join(['tmp','runtime_class_evaluation.rb'])    
-    filepath = $LOC+File.join(['tmp',runtime_class.class_name+'.rb'])        
-    file = File.open(filepath,'w+')
+    file = Tempfile.new(runtime_class.class_name+'.rb')
     @@count += 1
     
     # Include the sytax for the statement in the file
@@ -41,7 +19,7 @@ class ClassEvaluation
     file.close
     
     # Load the newly created class and check the statement
-    load filepath
+    load file.path
     begin 
       # TODO  Make this more generic
       case params.length 
@@ -55,7 +33,10 @@ class ClassEvaluation
     rescue NameError => e
       StandardLogger.instance.info(runtime_class.write)
       raise e
-    end    
+    ensure 
+      file.close
+      file.unlink
+    end  
     
   end
   

data/lib/util/CodeEvaluation.rb

@@ -11,25 +11,29 @@ class CodeEvaluation
   def evaluate_code(code)  
     @@COUNT += 1
     
-    # Create file to include the test method
-    filepath = $LOC+File.join(['tmp',"runtime_code_evaluation_#{@@COUNT}.rb"])
-    file = File.open(filepath,'w+')
-    
-    # Include the sytax for the statement in the file
-    file << "class RuntimeCodeEvaluation#{@@COUNT}"+"\n"
-    file << "\t"+'def check'+"\n"
-    code.each_line do |l|
-      file << "\t\t"+l+"\n"
+    begin
+      
+      # Create file to include the test method 
+      file = Tempfile.new("runtime_code_evaluation_#{@@COUNT}.rb")
+      
+      # Include the sytax for the statement in the file
+      file << "class RuntimeCodeEvaluation#{@@COUNT}"+"\n"
+      file << "\t"+'def check'+"\n"
+      code.each_line do |l|
+        file << "\t\t"+l+"\n"
+      end
+      file << "\t"+'end'+"\n"
+      file << 'end'
+      file.close
+      
+      # Load the newly created class and check the statement
+      load file.path
+  
+      return eval("RuntimeCodeEvaluation#{@@COUNT}.new.check")
+    ensure 
+      file.close
+      file.unlink      
     end
-    file << "\t"+'end'+"\n"
-    file << 'end'
-    file.close
-    
-    # Load the newly created class and check the statement
-    load filepath
-
-    return eval("RuntimeCodeEvaluation#{@@COUNT}.new.check")      
-    
   end
   
 end

data/lib/util/DeclarationStatementEvaluation.rb

@@ -4,8 +4,7 @@ class DeclarationStatementEvaluation
   def evaluate(written_statement,runtime_methods=[])
     
     # Create file to include the test method
-    filepath = $LOC+File.join(['tmp','runtime_declaration_statement_evaluation.rb'])    
-    file = File.open(filepath,'w+')
+    file = Tempfile.new("runtime_declaration_statement_evaluation.rb")   
     
     # Include the sytax for the statement in the file
     file << 'class RuntimeDeclarationStatementEvaluation'+"\n"
@@ -25,7 +24,9 @@ class DeclarationStatementEvaluation
     load filepath
     return RuntimeDeclarationStatementEvaluation.new.check      
         
-    
+  ensure 
+      file.close
+      file.unlink          
   end
   
 end