cauldron 0.1.1 → 0.1.2

data/Gemfile

@@ -10,6 +10,7 @@ group :development do
   gem "bundler", "~> 1.0.15"
   gem "jeweler", "~> 1.6.2"
   gem "rcov", ">= 0"
-  gem "ruby2ruby", "~>1.2.5"
   gem "ruby_parser", "~>2.0.6"
 end
+
+gem "ruby2ruby", "~>1.2.5"

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.2

data/features/cauldron_generates_runtime_method.feature

@@ -9,5 +9,5 @@ Feature: Cauldron generates a runtime method
 
 		Scenarios: example with only one parameter
 			|      cases   	   	   				         				|     							runtime_method   						|		demo_num  |
-			|  "'sparky','sparky'*'kel','kel'"      			| "def method_3(var_6)\n\treturn var_6\nend\n"  |     1       |
-			|	 "'fish','animal'*'carrot','vegatable'"			|	"def method_3(var_0)\n\tif(var_0 == 'fish')\n\t\treturn 'animal'\n\tend\n\treturn 'vegetable'\nend\n" | 2 |	
+			|  "'sparky','sparky'*'kel','kel'"      			| "def method_0(var_0)\n\treturn var_0\nend\n"  |     1       |
+			|	 "'fish','animal'*'carrot','vegetable'"			|	"def method_0(var_0)\n\tif(var_0 == 'fish')\n\t\treturn 'animal'\n\tend\n\treturn 'vegetable'\nend\n" | 2 |	

data/lib/Chain.rb

@@ -3,6 +3,7 @@ class Chain
   # TODO  This access is proably temporary
   attr_reader :chain_mapping
 
+  @@default_tail_theory = nil
   # 
   # @param  nodes     An array of theories in order
   # 
@@ -13,13 +14,10 @@ class Chain
     @uniq_theory_instance_ids = ('A'...'Z').to_a 
     
     # Create a result version of 'finish'
-    finish = Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend")
-    tail_theory = finish.write
-    tail_theory.gsub!('runtime_method','var1')
-    tail_theory.gsub!('test_cases','var2')
-    tail_dependent = TheoryDependent.new(StringToTheory.run(tail_theory))
+
     # TODO  Drop @tail_theory as a instance variable
-    @tail_theory = Theory.new([tail_dependent],nil,[])
+    #@tail_theory = Theory.new([tail_dependent],nil,[])
+    @tail_theory = Chain.default_tail_theory
     
     # NOTE: Now the head and tail are using the same ids for their variables
     @chain_mapping = ChainMapping.new()
@@ -34,6 +32,20 @@ class Chain
     
   end
   
+  def self.default_tail_theory
+    if @@default_tail_theory.nil?
+      finish = Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend")
+      tail_theory = finish.write
+      tail_theory.gsub!('runtime_method','var1')
+      tail_theory.gsub!('test_cases','var2')
+      tail_dependent = TheoryDependent.new(StringToTheory.run(tail_theory))
+      @@default_tail_theory = Theory.new([tail_dependent],nil,[])
+      @@default_tail_theory.copy
+    else
+      @@default_tail_theory.copy
+    end    
+  end
+  
   # TODO  I want to drop allot of these quick methods
   def <<(node)
     @nodes << node
@@ -111,6 +123,10 @@ class Chain
     end
   end  
   
+  def theories_sequence
+    @nodes.collect {|x| x.theory_id}
+  end
+  
   # Returns a new chain where they are all using the same respective theory
   # variables.
   #

data/lib/UnifiedChain.rb

@@ -58,7 +58,7 @@ class UnifiedChain < Chain
     valid_mappings = [Mapping.new]
     
     #itteration_limit = 6
-    itteration_limit = 8
+    itteration_limit = 9
     
     @nodes.each_with_index do |node,index|
 
@@ -87,7 +87,8 @@ class UnifiedChain < Chain
           limit += 1
         end
         if limit > itteration_limit  
-          raise StandardError.new('Unable to resolve action: '+node.action.write)
+          pp missing_variables(node.action,valid_mappings)
+          raise StandardError.new('Unable to resolve action: '+"\n"+node.action.write)
         end        
       end
       
@@ -116,12 +117,26 @@ class UnifiedChain < Chain
     return true
   end
   
+  def missing_variables(component,mappings)
+    results = []
+    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
+      end
+    end
+    return results    
+  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))

data/lib/cauldron.rb

@@ -1,3 +1,6 @@
+require 'rubygems'
+require 'tempfile'
+
 require 'required'
 
 require 'cauldron/sexp2cauldron'

data/lib/cauldron/pot.rb

@@ -3,70 +3,76 @@ module Cauldron
   class Pot
     include ContainsTheories  
     
-    VERSION = '0-01'
+    VERSION = '0-1-1'
     
     def initialize()
-      #StandardLogger.instance.level = Logger::FATAL
+      StandardLogger.instance.level = Logger::FATAL
     end
     
     def brew(test_cases)
       
-      chains = complete_chains(test_cases)
-      if chains.empty?
+      exclude = []
+      chain = next_chain(test_cases,exclude)  
+      if chain.nil?
         raise StandardError.new('Failed to generate a chain for this problem')
       end       
       
-      # => TODO This probably shouldn't be needed
-      written_chains = chains.collect {|x| x.write}
-      unique_written_chains = written_chains.uniq
-      unique_chains = []
-      chains.each do |x|
-        unless unique_chains.any? {|y| y.write == x.write}
-          unique_chains << x
-        end
-      end
-      chains = unique_chains
-      
       runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
-      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)
-        
-        # Go through each of the permutations and create the runtime method for the chain
-        validator = TheoryChainValidator.new
-        begin 
-          result = validator.build(runtime_method.copy,test_cases.copy,implementation_permutations)
-        rescue StandardError => e
-          StandardLogger.instance.warning e
-          next 
-        end
-        return result      
+        return validator.build(runtime_method.copy,test_cases.copy,implementation_permutations)
+      else
+        exclude << chain.theories_sequence
+        chain = next_chain(test_cases,exclude)
+        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
       return nil
       
     end
     
+    def chain_valid?(chain,test_cases)
+      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)
+      
+      # Go through each of the permutations and create the runtime method for the chain
+      validator = TheoryChainValidator.new
+      begin 
+        result = validator.build(runtime_method.copy,test_cases.copy,implementation_permutations)
+      rescue StandardError => e
+        StandardLogger.instance.warning e 
+        return false
+      end
+      return true      
+    end
+    
     def complete_chains(test_cases)
+      return [next_chain(test_cases)]
+    end
+    
+    def next_chain(test_cases,exclude=[])
       
       theories = saved_theories 
       
+      res = theories.collect {|x| x.theory_id }
+
       runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))    
-      tc = Parser.run('test_cases')
-      tc_index_0 = IntrinsicLiteral.new(0)
-      tc_index_1 = IntrinsicLiteral.new(1)
-      param_0 = IntrinsicLiteral.new(0)
-      real_method = Parser.run('runtime_method')     
-      
-      # Create the thoery connector and the values available 
-      # TODO  These values should actually be retreived progressively
-      potential_values = MappingValues.new([tc,tc_index_0,tc_index_1,param_0,real_method])
+
+      potential_values = MappingValues.new([])
       connector = TheoryConnector.new(potential_values)        
       
       # Attempt to generate a complete chain for the solution
-      chains = connector.generate_chains(runtime_method,test_cases,theories)      
-      return chains
-    end
+      chains = connector.generate_chains(runtime_method,test_cases,theories,exclude)      
+      return chains.first
+            
+    end    
     
     def saved_theories
       saved_theory_file_paths = Dir.glob(File.join(theory_repository_path,'*','dump'))
@@ -133,7 +139,11 @@ module Cauldron
       
       # Define the theory's directory
       theory_path = File.join(repository,theory.theory_id.to_s)
-      raise StandardError.new('Directory already exists - how as this happened?') if File.exists?(theory_path)
+      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)
+        return
+      end
       
       # Save a file containing the theory
       FileUtils.mkdir_p(theory_path)

data/lib/cauldron/terminal.rb

@@ -16,7 +16,7 @@ module Cauldron
       @pot = Cauldron::Pot.new
       @pot.clear
       @output.puts '* Adding example case'      
-      #@pot.simmer(demo('1'))
+      @pot.simmer(demo_one)
       @pot.simmer(demo_two)
       
       @output.puts "Thanks for trying Cauldron - it's at really early stage right now"
@@ -40,7 +40,7 @@ module Cauldron
     
     def submit(input)
       if input =~ /^RUN$/
-         @output.puts @pot.brew(@cases).basic_write
+         @output.puts @pot.brew(@cases).reset_ids!.basic_write
       else
         @cases << convert_to_example(separate_values(input))
       end

data/lib/core/ClassMethodCallContainer.rb

@@ -28,7 +28,6 @@ class ClassMethodCallContainer < CallContainer
     return @class_name.write+'.'+@method_call.to_literal_string
   end  
   
-  # TODO  Write tests
   # Returns true if the supplied argument is the same class, has the equivalent subjects
   # and parameters. 
   #

data/lib/core/MethodUsage.rb

@@ -46,7 +46,6 @@ class MethodUsage < Array
     return MethodUsageVariable.new(*self.collect {|x| x.copy}) {{:variable_id => id,:uniq_id=>uniq_id}}
   end
   
-  # TODO  Test this 
   def copy
     return MethodUsage.new(*self.collect {|x| x.copy})
   end

data/lib/core/TheoryGenerator.rb

@@ -232,10 +232,6 @@ class TheoryGenerator
         )
       end
     end
-    # Add the 'if(var1 == var2)' statement
-    # TODO  Might only allow values in the action at this point
-    # 'IfStatement.new(var2[var3][:params][var6],Equivalent.new,var2[var3][:output])'
-    # TODO  Should the values be equal at this point??
     
     # Exclude the runtime method from being included as a value (.write method becomes messy)
     # also excludes the orginal test_cases.

data/lib/core/runtime_method/RuntimeMethod.rb

@@ -206,7 +206,7 @@ class RuntimeMethod < StatementGroup
     
     # Confirms that supplied statement is a statement
     unless statement.kind_of? Statement or statement.kind_of?(StatementGroup)
-      raise StandardError.new('Only statements can be included in a runtime method')
+      raise StandardError.new('Only statements can be included in a runtime method not '+statement.class.to_s)
     end
     
     # Check if the statement creates a new variable - and add it the available variables

data/lib/core/statement/ActsAsStatement.rb

@@ -21,7 +21,7 @@ module ActsAsStatement
   #
   def classes_match?(*classes)
     return false unless classes.length == self.length
-    self.zip(classes) do |x,y|  
+    @nodes.zip(classes) do |x,y|  
       return false unless x.instance_of?(y)
     end
     return true

data/lib/core/statement/Statement.rb

@@ -1,4 +1,4 @@
-class Statement < Array
+class Statement
   include PrintVariables
   include ActsAsStatement
   include ActsAsCode
@@ -7,7 +7,9 @@ class Statement < Array
   # 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  
+  #alias :array_push :push
+  
+    
   
   @@statement_id = 0
   
@@ -27,9 +29,12 @@ class Statement < Array
     # Sets the flag that indicates the structure of the statement
     @structure = nil
     
+    @nodes = []
+    
     # Add the parameters to the array 
     parameters.each do |code|
-      self.push(code.copy)
+    #  self.push(code.copy)
+      @nodes.push(code.copy)
     end
     
     # TODO  I might change the statement_id to be determined by the structure
@@ -63,7 +68,7 @@ class Statement < Array
   # as not.
   #
   def identify_overriding_statements(already_declared=[])
-    [BaseVariable,Equal].zip(self) do |x,y|
+    [BaseVariable,Equal].zip(@nodes) do |x,y|
       return unless y.kind_of?(x)
     end
     already_declared.each do |x|
@@ -268,7 +273,8 @@ class Statement < Array
   def push(code)
     
     # Add the new piece of code to the statement
-    array_push(code)   
+    #array_push(code)
+    @nodes << code   
     
     # Update the requirements to reflect the change
     update
@@ -279,6 +285,48 @@ class Statement < Array
     push(element)
   end
   
+  def select_all(results=[],&block)
+    return @nodes.select_all(results,&block)
+  end
+  
+  def each
+    @nodes.each {|x| yield x}
+  end
+  
+  def last
+    return @nodes.last
+  end
+  
+  def each_with_index
+    @nodes.each_with_index do |x,i|
+      yield x, i
+    end  
+  end
+  
+  def []=(index,value)
+    @nodes[index] = value
+  end
+  
+  def [](index)
+    return @nodes[index]
+  end  
+  
+  def length
+    return @nodes.length
+  end
+  
+  def select_all(results=[],&block)
+    return @nodes.select_all(results,&block)
+  end
+  
+  def first
+    @nodes.first
+  end
+  
+  def clear
+    @nodes.clear
+  end
+  
   # Indicates whether the statement is one that assigns
   # a value to another.  Essential "Does the statement
   # contain an equals sign?"
@@ -432,8 +480,8 @@ class Statement < Array
   # @param  var   The variable to replace any elements that match the block.
   #
   def replace_variable_if(var,&block)
-    container = self.copy.clear
-    self.each do |x|
+    container = []
+    @nodes.each do |x|
       if x.kind_of?(Variable)
         if block.call(x)
           container.push(var)
@@ -446,7 +494,10 @@ class Statement < Array
       end
       container.push(x.copy)
     end
-    return container
+    #return self.copy(*container)
+    copied = self.copy().clear
+    container.each {|x| copied.push(x) }
+    return copied
       
   end
   
@@ -470,29 +521,12 @@ class Statement < Array
   # TODO  Write test to retrieve declarared variable in a statement with two variables
   #       e.g. varA = varB-varC
   # 
-  # TODO  Write tests for this  
-  #
   def find_variable(id)
-    
-    # Go through each element of code in the statement and find instance calls and variables
-    self.each do |code|
-      next unless code.kind_of? Variable or code.kind_of? InstanceCallContainer
-      
-      # Determine if the variable matches the id 
-      if code.variable_id == id
-                
-        # Does the statement declare a new variable?     
-        if decalares_variable?
-          return find_variable_in_declaration_statement(code)
-        else
-          return code.copy
-        end
-        
-      end
-      
+    results = variables.select() {|x| x.variable_id == id}
+    if results.empty?
+      raise FailedToFindVariableError.new('Couldn\'t find variable with id = '+id.to_s+' in "'+self.write+'"')
     end
-
-    raise FailedToFindVariableError.new('Couldn\'t find variable with id = '+id.to_s+' in "'+self.write+'"')
+    return results.first
   end        
   
   # Returns the variable in this statement with uniq_id specified.  In
@@ -616,7 +650,7 @@ class Statement < Array
   #       and come up with a solution then.
   #
   def to_literal_string
-    return self.inject('') do |complete,part|
+    return @nodes.inject('') do |complete,part|
       complete += part.to_literal_string
     end
   end  
@@ -736,7 +770,7 @@ class Statement < Array
   # statement.  In all likelyhood there will no more than one.
   #
   def find_all_required_runtime_methods
-    defcalls = self.find_all {|x| x.kind_of?(DefCall)} 
+    defcalls = @nodes.find_all {|x| x.kind_of?(DefCall)} 
     return defcalls.collect {|x| x.runtime_method}
   end  
   
@@ -900,121 +934,6 @@ class Statement < Array
   end    
         
 protected
-
-  # Presumes this is a declaration statement and attempts to return
-  # specified variable in the context of the method.
-  #
-  def find_variable_in_declaration_statement(var)
-
-    # Duplicate the variable
-    # TODo  I think I want to get rid of this "copy_contextual_variable"and just use copy
-    copied_variable = var.copy_contextual_variable
-
-    # Is the variable declared in this statement?
-    if(self[0].variable_id == copied_variable.variable_id)
-
-      # Create a requirement reflecting the declaration statement
-      # e.g varA = 'test'.chop becomes self = 'test'.chop          
-      # statement_requirement = declared_variable_requirement
-
-      # Add this requirement to the variable and return it
-      # copied_variable.push(statement_requirement)
-      
-      # TODO  I think determining the value of variables at this point should
-      #       be removed or re-thought.  I think the typify method is more useful.
-      #       The problem is that each statement is dependent on other statements
-      #       or method calls.        
-        
-#      # NOTE  I have included the untyped_variables call becuase it was continually throwing
-#      #       since so many statements include method calls.
-#      if self.untyped_variables.length == 0 && !contains_method_call?
-#        # Convert the variable to be typed (if possible)
-#        if copied_variable.kind_of?(Unknown)
-#          begin
-#            return copied_variable.classify(CodeEvaluation.new.evaluate_code(literalise))
-#            # TODO  I shouldn't use NameError - since I want to catch badly formed syntax - I 
-#            #       should have a custom error for bad syntax that will occu
-#          rescue NameError => e
-#            StandardLogger.log(' -- Statement: find_variable_in_declaration_statement'+e)          
-#          end
-#        end
-#      end
-      
-      return copied_variable
-        
-    else
-      
-      # The variable isn't declared in this statement
-      # So if varB is the declared variriable we might have
-      # varB = varA.chop
-      # 
-      # This would create the requirement self.chop = varB
-      #
-      # Declare the statement requirement to be created
-      statement_requirement = nil
-      
-      # Does the statement only have three elements
-      if(self.length == 3)
-        
-        # Create a requirement for the variable in the statement
-        if(self[2].kind_of?(InstanceCallContainer))
-          
-          # Create the matching requirement
-          statement_requirement = Requirement.new(InstanceCallContainer.new(This.new,self[2].method_call.class.new),Equal.new,self[0].copy)
-          
-        elsif(self[2].kind_of?(Variable))
-        
-          # Create the requirement reflecting the statement
-          statement_requirement = Requirement.new(This.new,Equal.new,self[0].copy)  
-        
-        else
-          raise StandardError.new('Unexpected class type '+self[2].class.to_s)          
-        end
-        
-      else
-        
-        raise StandardError.new('Unexpected statement length'+self.length.to_s+' for requirement re-write') unless self.length == 5
-        
-        # Handle the case were we have varA = varB-varC and we want varB's requirement
-        # e.g. we need varB = varA+varC
-        
-        # TODO  This can probably be re-written to be more abstract
-        # Case varA = varB-varC 
-        if( self[2].kind_of?(Variable) and self[3].kind_of?(Subtract) and self[4].kind_of?(Variable) )
-          
-          # where varB is the subject -> this = varA + varC
-          if(self[2].variable_id == var.variable_id)
-            statement_requirement = Requirement.new(This.new,Equal.new,self[0].copy,Addition.new,self[4].copy)
-          end
-          
-          # where varC is the subject -> this = varB-varA
-          if(self[4].variable_id == var.variable_id)
-            statement_requirement = Requirement.new(This.new,Equal.new,self[2].copy,Subtract.new,self[0].copy)
-          end
-          
-        elsif(self[2].kind_of?(Variable) and self[3].kind_of?(Addition) and self[4].kind_of?(Variable) )
-        
-          if(self[2].variable_id == var.variable_id)
-            statement_requirement = Requirement.new(This.new,Equal.new,self[0].copy,Subtract.new,self[4].copy)
-          end
-          
-          if(self[4].variable_id == var.variable_id)
-            statement_requirement = Requirement.new(This.new,Equal.new,self[2].copy,Addition.new,self[0].copy)
-          end                
-          
-        else
-          raise StandardError.new('Unknown statement structure "'+self.write+'"')
-       end
-     
-      end
-   
-        # Adding the new requirement to the variable
-      copied_variable.push(statement_requirement)
-      return copied_variable                
-  
-    end
-    
-  end  
   
   # @param  var       The subsitute variable 
   # @param  id        The id of the substitee