cauldron 0.1.2 → 0.1.3

data/lib/Theory.rb

@@ -6,15 +6,14 @@ class Theory
   
   attr_accessor :theory_instance_id
     
-  @@theory_id = 0     
+  @@theory_id = nil
   #
   # @param  example_runtime_method      A runtime method instance with this theories action applied to it and
   #                                     which meets the theories dependents with a certain set of test cases.
   #
   def initialize(dependents,action,results,example_runtime_method=nil)
     @dependents, @action, @results, @example_runtime_method = dependents, action, results, example_runtime_method
-    @theory_id = @@theory_id
-    @@theory_id += 1
+    @theory_id = Theory.next_theory_id
   end
   
   def copy
@@ -22,6 +21,31 @@ class Theory
     return Marshal.load(Marshal.dump(self))
   end
   
+  def self.next_theory_id
+    if @@theory_id.nil?
+      FileUtils.mkdir(theories_directory) unless File.exists?(theories_directory)
+      highest_integer = 0
+      Dir.glob(File.join(theories_directory,'*')).each do |filename|
+        if filename.match(/(\d+)/)
+          highest_integer = $1.to_i if $1.to_i > highest_integer     
+        end
+      end      
+      @@theory_id = highest_integer
+    end
+    @@theory_id += 1
+    return @@theory_id
+  end
+  
+  def self.theories_directory
+    # the home directory code is duplicated
+    realHome = ["HOME", "HOMEPATH"].detect {|h| ENV[h] != nil}
+    if not realHome
+      StandardLogger.instance.warning "Couldn't detect a home directory"
+    end
+    # => TODO Should use proper version
+    return File.join(ENV[realHome],'cauldron','0-1-1','theories')    
+  end    
+  
   def irrelevant?
     dependents.empty? and results.empty? and action.nil?
   end
@@ -239,7 +263,7 @@ class Theory
   end
   
   def highlight(component_ids=[])
-    # @log.error("\033[0;31m\ "+msg+"\033[00m\ ")
+    
     # Describe the despendencies
     description = 'if: '+"\n"
     @dependents.inject(description) do |description, x|

data/lib/UnifiedChain.rb

@@ -2,11 +2,19 @@
 # chain there is no mapping, all the theories should have the correct ids if they are 
 # linked.  A unified chain is always complete.
 #
-class UnifiedChain < Chain
-  # TODO  I don't like that extending to Chain exposes the @nodes to public access
-  
-  def initialize(nodes)
+class UnifiedChain
+
+  attr_reader :connections
+
+  def initialize(nodes,connections)
     @nodes = nodes
+    #pp connections
+    
+    @connections = connections
+    @variable_keys = connections.mapping.keys
+    #pp @variable_keys
+    
+    raise StandardError.new('chain is not complete ') unless self.complete?
   end
   
   def write(tab=0)
@@ -17,6 +25,11 @@ class UnifiedChain < Chain
     return @nodes.inject('') {|total,x| total += x.describe}
   end
   
+  def copy
+    #return Chain.new(@nodes.copy)
+    return Marshal.load(Marshal.dump(self))
+  end  
+  
   # Returns an array of all the theory variables in the chain.  All the 
   # theory variables should be global across the chain. 
   #
@@ -48,38 +61,37 @@ class UnifiedChain < Chain
   
   def valid_mapping_permutations(runtime_method,test_cases)
     
+    # puts '-------------------------------'
+    # puts Cauldron::Util::Saver.save(runtime_method)
+    # puts Cauldron::Util::Saver.save(test_cases)
+    # puts '-------------------------------'
     # Get the initially available intrinsic values
     intrinsic_values = [IntrinsicRuntimeMethod.new,IntrinsicTestCases.new]
     
     total_variables = self.theory_variables.length
     
     available_values = [IntrinsicRuntimeMethod.new,IntrinsicTestCases.new]    
+  
+    valid_mappings = [{}]
     
-    valid_mappings = [Mapping.new]
-    
-    #itteration_limit = 6
     itteration_limit = 9
     
     @nodes.each_with_index do |node,index|
-
-      node.dependents.each do |dependent|
-        if index == 0
-          chain = partial_chain(0)
-        else
-          chain = partial_chain(index-1) 
-        end
-        limit = 0
-        until has_all_variables_been_found?(dependent,valid_mappings) or limit > itteration_limit
-          valid_mappings = extend_mapping(valid_mappings,dependent,runtime_method.copy,test_cases.copy,chain,available_values)
-          limit += 1
-        end  
-      end
+      
+      valid_mappings = extend_value_mapping_wtih_dependents(
+                          valid_mappings,
+                          index,
+                          node,
+                          available_values,
+                          test_cases.copy,
+                          runtime_method.copy
+                        )
       
       unless node.action.nil?
         if index == 0
-          chain = partial_chain(0)
+          chain = partial_chain(1..0)
         else
-          chain = partial_chain(index-1) 
+          chain = partial_chain(1..(index-1))  
         end
         limit = 0            
         until has_all_variables_been_found?(node.action,valid_mappings) or limit > itteration_limit
@@ -87,20 +99,13 @@ class UnifiedChain < Chain
           limit += 1
         end
         if limit > itteration_limit  
-          pp missing_variables(node.action,valid_mappings)
+          puts 'Chain saved '+Cauldron::Util::Saver.save(self)
+          puts 'Is chain complete: '+complete?.to_s
           raise StandardError.new('Unable to resolve action: '+"\n"+node.action.write)
         end        
       end
       
-      node.results.each do |result|
-        chain = partial_chain(index)
-        limit = 0            
-        until has_all_variables_been_found?(result,valid_mappings) or limit > itteration_limit
-          valid_mappings = extend_mapping(valid_mappings,result,runtime_method.copy,test_cases.copy,chain,available_values)
-          limit += 1
-        end
-          
-      end
+      valid_mappings = extend_value_mapping_with_result(valid_mappings,index,node,available_values,test_cases.copy,runtime_method.copy)
       
     end
       
@@ -108,37 +113,52 @@ class UnifiedChain < Chain
     
   end
   
-  def has_all_variables_been_found?(component,mappings)
-    component.theory_variables.each do |var|
-      mappings.each do |mapping|
-        return false unless mapping.has_key? var.theory_variable_id
+  def extend_value_mapping_with_result(valid_mappings,index,node,available_values,test_cases,runtime_method)
+    itteration_limit = 3
+    node.results.each do |result|
+      chain = partial_chain(0..index)
+      limit = 0            
+      until has_all_variables_been_found?(result,valid_mappings) or limit > itteration_limit
+        valid_mappings = extend_mapping(valid_mappings,result,runtime_method.copy,test_cases.copy,chain,available_values)
+        limit += 1
       end
-    end
-    return true
+    end    
+    return valid_mappings
   end
   
-  def missing_variables(component,mappings)
-    results = []
+  def extend_value_mapping_wtih_dependents(valid_mappings,index,node,available_values,test_cases,runtime_method)
+    itteration_limit = 6
+    node.dependents.each do |dependent|
+      if index == 0
+        chain = partial_chain(0..0)
+      else
+        chain = partial_chain(1..(index-1)) 
+      end
+      limit = 0
+      until has_all_variables_been_found?(dependent,valid_mappings) or limit > itteration_limit
+        valid_mappings = extend_mapping(valid_mappings,dependent,runtime_method.copy,test_cases.copy,chain,available_values)
+        limit += 1
+      end  
+    end    
+    return valid_mappings
+  end
+  
+  def has_all_variables_been_found?(component,mappings)
     component.theory_variables.each do |var|
-      mappings.each do |mapping|
-        #return false unless mapping.has_key? var.theory_variable_id
-        results << var unless mapping.has_key? var.theory_variable_id
+      mappings.each do |m|
+        return false unless m.has_key?(var.theory_variable_id)
       end
     end
-    return results    
+    return true
   end
   
   def extend_mapping(valid_mappings,component,runtime_method,test_cases,chain,available_values)
     
     new_mappings = [] 
     component.theory_variables.each do |var|
-      next if valid_mappings.first.has_key?(var.theory_variable_id)
-      #next if valid_mappings.any? {|x| x.has_key?(var.theory_variable_id)}
+    
       valid_mappings.each do |mapping|
-        
-        #next if mapping.has_key?(var.theory_variable_id)
 
-        #next if mapping.has_key?(var.theory_variable_id)
         implemented_chain = chain.implement(Mapping.new(mapping))
         implemented_runtime_method = TheoryChainValidator.new.build_method_from_chain(
                                         implemented_chain,runtime_method.copy,test_cases.copy
@@ -146,14 +166,14 @@ class UnifiedChain < Chain
 
         possible_values = available_values-mapping.values   
         begin 
-        values = intrinsic_values_for_variable(
-          var.theory_variable_id,
-          component,
-          mapping,
-          implemented_runtime_method,
-          test_cases.copy,
-          possible_values    
-        )
+          values = intrinsic_values_for_variable(
+            var.theory_variable_id,
+            component,
+            mapping,
+            implemented_runtime_method,
+            test_cases.copy,
+            possible_values    
+          )
         rescue NoMethodError => e
           valid_mappings = valid_mappings-[mapping]
           next
@@ -254,13 +274,6 @@ class UnifiedChain < Chain
       end      
       values += index_values
       
-      #variable_values = []
-      #result.statements_with_variable(var.theory_variable_id).each do |statement|
-      #variable_values += values_for_variable_as_argument(var,statement,mapping,intrinsic_values,implemented_runtime_method.copy,test_cases.copy)
-      #end
-      #values += variable_values
-      
-      #intrinsic_statement = statement.map_to(mapping)
       variable_values = []
       intrinsic_values.each do |value|
         literal = intrinsic_statement.write.gsub(/var(\d)+/,value.write)
@@ -271,19 +284,18 @@ class UnifiedChain < Chain
           next
         end
       end
-      #return results
       values += variable_values      
       
-      
     end
     return values
   end
   
-  def partial_chain(limit)
-    links = @nodes[1..limit].collect {|x| x.copy }
-    UnifiedChain.new(links)    
+  def partial_chain(range)
+    links = @nodes[range].collect {|x| x.copy }
+    PartialChain.new(links)
   end
   
+  # => TODO This might not be need - use cucumber to check
   def mapping_permutations(keys,values)
     values.permutation(keys.length).to_a.inject([]) do |total,value_permutation|
       total << Hash[*keys.zip(value_permutation).flatten]
@@ -316,67 +328,24 @@ class UnifiedChain < Chain
   # @param  test_cases        The test cases instance containing real values.
   #
   def implementation_permuatations(runtime_method,test_cases,mapping)
-    
     return implementation_permuatations2(runtime_method,test_cases,mapping)
-    
-    # Determine the number of variables without intrinsic values
-    theory_variable_ids = theory_variables.collect {|x| x.theory_variable_id}
-    
-    # Collect the theory variables without intrinsic values
-    missing_intrinsic_values = theory_variable_ids-mapping.keys
-    
-    # Take the first theory and identify all the accessors
-    # (need to work out what is the runtime method and what the test cases)
-    
-    # TEMP: Why are these implemented theories
-    # @nodes.first.all_theory_variables
-    
-    # Create the theory generator
-    generator = TheoryGenerator.new()
-    
-    #accessors, temp_mapping = generator.generate_accessors_and_mapping(test_cases,runtime_method,1)
-    accessors, temp_mapping = generator.generate_accessors_and_mapping(test_cases,runtime_method,3)
-
-    if temp_mapping.length > missing_intrinsic_values.length
+  end    
+  
+  # TODO  This is a temporary method while I work out how incomplete? chains are being created
+  def complete?
+    @nodes.each do |node|
 
-      # Now to assign real values to the chain
-      
-      # Apply the values in the various permutaions 
-      # (this is very crude and means that odd calls )
-      #theory_variable_ids = @nodes.first.all_theory_variables.collect {|x| x.theory_variable_id }
+      # Exclude the current node being considered
+      filtered_nodes = TheoryCollection.new(@nodes.copy - [node])
       
-      theory_variable_ids = self.theory_variables.collect {|x| x.theory_variable_id }
-      
-      # Get the posible sets for values in an array so that non of the arrays contain all the same values
-      res = temp_mapping.values.collect {|x| x}
-      
-      # TODO  This is a complete hack but I think I should be using intrinsic values rather than real
-      intrinsic_res = res.collect {|x| x.to_intrinsic}
-      value_permutaions = intrinsic_res.permutation(theory_variable_ids.length).to_a
-      uniq_value_permutations = value_permutaions.collect {|x| x.to_set}.uniq
-      possible_mappings = []
-      
-      theory_variable_id_permutations = theory_variable_ids.permutation(theory_variable_ids.length).to_a
-      
-      possible_mappings = []
-      theory_variable_id_permutations.each do |theory_variable_id_permutation|
-        uniq_value_permutations.each do |value_permutation|
-          m = Mapping.new
-          theory_variable_id_permutation.zip(value_permutation.to_a) do |key,value|
-            m[key] = value
-          end
-          possible_mappings << m
-        end
-        
+      node.dependents.each do |dependent|
+        unless filtered_nodes.results.any? {|result| result.write == dependent.write}
+          return false
+        end        
       end
       
-      # Implemented changes
-      return possible_mappings.inject([]) { |total,mapping| total << self.copy.implement(mapping) }
-      
-    else
-      raise StandardError.new('Could not generate enough real vlaues to test theory - try increasing the itterations')
     end
-    
-  end    
+    return true
+  end
   
 end

data/lib/cauldron.rb

@@ -1,6 +1,9 @@
 require 'rubygems'
 require 'tempfile'
 
+require 'cauldron/util/home'
+require 'cauldron/util/saver'
+
 require 'required'
 
 require 'cauldron/sexp2cauldron'

data/lib/cauldron/demos.rb

@@ -31,7 +31,7 @@ module Cauldron
       
       # Create demo #1 chain
       #   Create the head for the chain
-      head = Theory.new([],nil,[])    
+      head = Theory.new([],nil,[])   
       
       link_one_action = TheoryAction.new(
         TheoryStatement.new(StringToTheory.run('Statement.new(Return.new,var1.params[var3])')),
@@ -58,7 +58,7 @@ module Cauldron
       # TODO  It should generate the values too.(TheoryGenerator)
       return {
         :initial_method=>RuntimeMethod.new(MethodUsage.new(MethodParameter.new)),
-        :test_cases=>@demo_1_test_cases,
+        :test_cases=>@demo_1_test_cases.copy,
         :chain=>chain,
         :values=>{}
       }            
@@ -73,7 +73,7 @@ module Cauldron
           [['carrot'],'vegtable'],
         ]
       )
-      head = Theory.new([],nil,[])
+      # => head = Theory.new([],nil,[])
       
       # Statementents
       # => TODO Need a clear way to format theories
@@ -268,7 +268,7 @@ module Cauldron
       
       return {
         :initial_method=>RuntimeMethod.new(MethodUsage.new(MethodParameter.new)),
-        :test_cases=>@demo_2_test_cases,
+        :test_cases=>@demo_2_test_cases.copy,
         :chain=>chain,
         :values=>{}
       }            

data/lib/cauldron/env.rb

@@ -0,0 +1 @@
+TAB = '  '

data/lib/cauldron/pot.rb

@@ -1,7 +1,10 @@
 module Cauldron
 
   class Pot
-    include ContainsTheories  
+    
+    include Cauldron::Util::Home
+    include ContainsTheories
+      
     
     VERSION = '0-1-1'
     
@@ -9,35 +12,48 @@ module Cauldron
       StandardLogger.instance.level = Logger::FATAL
     end
     
+    # Returns a runtime method that meets the requirements of the test cases.
     def brew(test_cases)
       
       exclude = []
-      chain = next_chain(test_cases,exclude)  
-      if chain.nil?
-        raise StandardError.new('Failed to generate a chain for this problem')
+      chains = next_chains(test_cases,exclude)  
+      if chains.empty?
+        raise StandardError.new('Failed to generate a chain for this problem A')
       end       
       
       runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
-      if chain_valid?(chain,test_cases.copy)
-        validator = TheoryChainValidator.new
-        unified_chain = chain.unify_chain
-        implementation_permutations = unified_chain.implementation_permuatations(runtime_method.copy,test_cases.copy,Mapping.new)
-        return validator.build(runtime_method.copy,test_cases.copy,implementation_permutations)
-      else
-        exclude << chain.theories_sequence
-        chain = next_chain(test_cases,exclude)
+      chains.each do |chain|
         if chain_valid?(chain,test_cases.copy)
           validator = TheoryChainValidator.new
           unified_chain = chain.unify_chain
           implementation_permutations = unified_chain.implementation_permuatations(runtime_method.copy,test_cases.copy,Mapping.new)
           return validator.build(runtime_method.copy,test_cases.copy,implementation_permutations)
-        end        
+        end
+      end    
+      chains.each do |chain|
+        exclude << chain.theories_sequence
       end
-      return nil
+
+      chains = next_chains(test_cases,exclude)  
+      if chains.empty?
+        raise StandardError.new('Failed to generate a chain for this problem')
+      end        
+      chains.each do |chain|
+        if chain_valid?(chain,test_cases.copy)
+          validator = TheoryChainValidator.new
+          unified_chain = chain.unify_chain
+          implementation_permutations = unified_chain.implementation_permuatations(runtime_method.copy,test_cases.copy,Mapping.new)
+          return validator.build(runtime_method.copy,test_cases.copy,implementation_permutations)
+        end
+      end        
+      raise StandardError.new('Failed to generate a valid runtime method C '+chains.length.to_s)
       
     end
     
     def chain_valid?(chain,test_cases)
+      if chain.kind_of?(Array)
+        raise StandardError.new('should be a chain '+chain.first.class.to_s) 
+      end
       runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
       unified_chain = chain.unify_chain
       implementation_permutations = unified_chain.implementation_permuatations(runtime_method.copy,test_cases.copy,Mapping.new)
@@ -53,16 +69,10 @@ module Cauldron
       return true      
     end
     
-    def complete_chains(test_cases)
-      return [next_chain(test_cases)]
-    end
-    
-    def next_chain(test_cases,exclude=[])
-      
-      theories = saved_theories 
+    def next_chains(test_cases,exclude=[])
+      theories = saved_theories
       
       res = theories.collect {|x| x.theory_id }
-
       runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))    
 
       potential_values = MappingValues.new([])
@@ -70,13 +80,16 @@ module Cauldron
       
       # Attempt to generate a complete chain for the solution
       chains = connector.generate_chains(runtime_method,test_cases,theories,exclude)      
-      return chains.first
-            
-    end    
+      return chains
+    end
     
     def saved_theories
-      saved_theory_file_paths = Dir.glob(File.join(theory_repository_path,'*','dump'))
-      saved_theory_file_paths.collect {|x| Marshal.load(File.open(x,'r'))}        
+      # => TODO This needs to cached to prevent error
+      if @cached_saved_theories.nil? 
+        saved_theory_file_paths = Dir.glob(File.join(theory_repository_path,'*','dump'))
+        @cached_saved_theories = saved_theory_file_paths.collect {|x| Marshal.load(File.open(x,'r'))}
+      end
+      @cached_saved_theories
     end
     
     def simmer(demo)
@@ -122,15 +135,6 @@ module Cauldron
     end
     
   private 
-  
-    # Check that the home directory exists  
-    def home
-      realHome = ["HOME", "HOMEPATH"].detect {|h| ENV[h] != nil}
-      if not realHome
-        StandardLogger.instance.warning "Couldn't detect a home directory"
-      end
-      return ENV[realHome]  
-    end
     
     # Saves the generic theory to file.  This theory will have minimal 
     # dependents and results.
@@ -140,8 +144,8 @@ module Cauldron
       # Define the theory's directory
       theory_path = File.join(repository,theory.theory_id.to_s)
       if File.exists?(theory_path)
-        puts theory_path+' already exists'
-        #raise StandardError.new('Directory already exists - how as this happened?') if File.exists?(theory_path)
+        StandardLogger.instance.warning theory_path+' already exists'
+        #raise StandardError.new('Directory already exists - how as this happened? '+theory.theory_id.to_s) if File.exists?(theory_path)
         return
       end