cauldron 0.1.0 → 0.1.1

data/lib/theory/TheoryChainValidator.rb

@@ -12,12 +12,13 @@ class TheoryChainValidator
   def build(runtime_method,test_cases,theory_implementation_chains,potential_values=[])
       validated_chains = []
       theory_implementation_chains.each do |chain|
-        validate_next_chain_link(validated_chains,chain,runtime_method.copy,test_cases,0)
+        validate_next_chain_link(validated_chains,chain,runtime_method.copy,test_cases.copy,0)
       end  
       raise StandardError.new('Failed to generate a valid runtime method') if validated_chains.length == 0
       
       # Select the first chain and return the runtime method it generates
-      return build_method_from_chain(validated_chains.first,runtime_method.copy,test_cases)
+      results =  build_method_from_chain(validated_chains.first,runtime_method.copy,test_cases.copy)
+      return results
       
   end 
   
@@ -27,6 +28,7 @@ class TheoryChainValidator
   # to the validated chain array.
   # 
   def validate_next_chain_link(validated_chains,chain,runtime_method,test_cases,position)
+    
     # Check that current link in the chain meets in dependencies 
     # if its dependents are met it isn't suppose to work
     unless chain[position].meets_dependencies?(runtime_method.copy,test_cases.copy)
@@ -63,12 +65,12 @@ class TheoryChainValidator
       end
     else
       # Theory was wrong
-      chain[position].results.each do |x|
-        unless x.validates?(result,test_cases)
-          StandardLogger.instance.info('The following result failed to be met')
-          StandardLogger.instance.info(x.write)
-        end
-      end
+      # chain[position].results.each do |x|
+        # unless x.validates?(result,test_cases)
+          # StandardLogger.instance.info('The following result failed to be met')
+          # StandardLogger.instance.info(x.write)
+        # end
+      # end
       return nil
     end    
     

data/lib/theory/TheoryComponent.rb

@@ -24,6 +24,23 @@ module TheoryComponent
     return @statement.tokens
   end
   
+  def statements_with_variable(variable_id)
+    
+    # Duplicate the current statement before it is rewritten
+    rewritten_statement = @statement.copy
+    
+    # Find all containers of VariableDeclarations that declare a TheoryVariable
+    containers = [rewritten_statement].select_all {|x| x.respond_to?(:has?)}
+    theory_variable_containers = containers.select {|x| x.has? {|y| y.kind_of?(TheoryVariable)}}
+    
+    results = theory_variable_containers.select do |x|
+      reg = eval '/var'+variable_id.to_s+'/'
+      x.write.match(reg)
+    end
+    return results
+    
+  end  
+  
   # Returns an array of any of the accessors in the statement.  An accessor
   # is the chain to access a property e.g. in the following statement =>
   #

data/lib/theory/TheoryConnector.rb

@@ -38,6 +38,8 @@ class TheoryConnector
   #
   def generate_chains(runtime_method,test_cases,theories)
     
+    theories = remove_irrelevant_theories(theories)
+
     # Create the inital chain (with the head and tail)
     intial_chain = Chain.new
     
@@ -47,39 +49,104 @@ class TheoryConnector
     # Create the initial chains
     possible_chains = []
     possible_head_theories.each do |x|
-      possible_chains += intial_chain.copy.add_link(x)
+      possible_chains += intial_chain.copy.extension_permutaions(x)
     end
-    
+        
     # Check the initial chains incase they're complete
     complete_chains = []
     if possible_chains.any? {|x| x.complete? }
       complete_chains += possible_chains.select {|x| x.complete?}
       possible_chains.delete_if {|x| x.complete?}
-    end        
+    end       
+    return complete_chains unless complete_chains.empty?
     
-    # Continue to add theories to the chains until they are complete or the theories are exhausted
-    possible_chains.each do |x|
-      complete_chains += extend_chain(x,theories)
+    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
     
   end
   
-  # TODO  Need to watch out here for infinite chain connections
+  def complete_chain(chain,theories)
+    chains = converge_chain(chain,theories)
+    return chains 
+    
+  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
+    end    
+    
+    # Are any of the chains complete
+    if extended_chains.any? {|x| x.complete? }
+      return extended_chains.select {|x| x.complete?}      
+    end
+    
+    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    
+    end
+    
+    unless closer_chains.empty?
+      closer_chains.each do |x|
+        complete_chains += converge_chain(x,theories,step+1)
+      end
+    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
+      end
+    end
+    
+    return complete_chains
+  end
+  
   def extend_chain(chain,theories)
+    
     complete_chains = []
     theories.each do |x|
-      extended_chains = chain.copy.add_link(x)
+      extended_chains = chain.copy.extension_permutaions(x)
       next if extended_chains.empty?
+      
+      # Don't allow the same theory to be added twice - for now
+      updated_theories = theories.copy
+      updated_theories.delete_if {|theory| theory.theory_id == x.theory_id}
+      
       complete_chains += extended_chains.select {|y| y.complete?}
       extended_chains.delete_if {|y| y.complete?}
       extended_chains.each do |y|
-        complete_chains += extend_chain(y,theories)
+        complete_chains += extend_chain(y,updated_theories)
       end
     end
     return complete_chains
   end
 
+  def remove_irrelevant_theories(theories)
+    theories.delete_if {|theory| theory.irrelevant? }
+  end
+
   def create_possible_chains(runtime_method,test_cases,finish,theories)
     
     # Generate the head theory - this is the starting point and doesn't have any dependents

data/lib/theory/TheoryDependent.rb

@@ -56,10 +56,10 @@ class TheoryDependent
   # the values in the mapping hash. 
   # 
   def map_to(mapping)
-    
+
     # Duplicate the current statement before it is rewritten
     rewritten_statement = @statement.copy
-    
+
     # Find all the containers that contain TheoryVariables
     # NOTE  The statement is put in an array because select all doesn't include the array itself
     containers = [rewritten_statement].select_all {|x| x.respond_to?(:has?)}

data/lib/theory/TheoryImplementation.rb

@@ -63,12 +63,12 @@ class TheoryImplementation < Theory
     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
+  # # 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

data/lib/util/ClassEvaluation.rb

@@ -4,10 +4,7 @@ class ClassEvaluation
   #include WriteParameters
   @@count = 0
   
-  # TODO  What is original_method about - can I get rid of it.  I need to 
-  #       pass through parameters. 
-  #
-  def evaluate_class(runtime_class,runtime_call,original_method=nil)
+  def evaluate_class(runtime_class,runtime_call)
     
     # Create file to include the test method
     #filepath = $LOC+File.join(['tmp','runtime_class_evaluation.rb'])    
@@ -24,7 +21,6 @@ class ClassEvaluation
     begin 
       return eval("#{runtime_class.class_name}.new.#{runtime_call}")
     rescue NameError => e
-      StandardLogger.instance.error(original_method.write()) unless original_method.nil?
       StandardLogger.instance.info(runtime_class.write)
       raise e
     end
@@ -43,7 +39,7 @@ class ClassEvaluation
     # 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 
@@ -57,7 +53,6 @@ class ClassEvaluation
         raise StandardError.new('Can only handle one parameter right now')
       end
     rescue NameError => e
-      StandardLogger.instance.error(original_method.write()) unless original_method.nil?
       StandardLogger.instance.info(runtime_class.write)
       raise e
     end    

data/lib/util/MethodValidation.rb

@@ -118,20 +118,24 @@ class MethodValidation
       )
     )
     # 5.  return true if var_3.evaluate_class(var_2,var_1.method_name)<condition>
-    test_method.push(
-      Statement.new(
-        Return.new,
-        True.new,
-        If.new,
+    s = Statement.new(
+      If.new,
+      Container.new(
         InstanceCallContainer.new(
           var_3,
           EvaluateClassCall.new,
           var_2,
           InstanceCallContainer.new(var_1,MethodNameCall.new)
         ),
-        Raw.new(condition)
+        Raw.new(condition)      
       )
     )
+    os = OpenStatement.new(s)
+    os << Statement.new(Return.new,True.new)
+    test_method.push(os)
+    
+    #test_method.push(s)
+    
     # 6.  return false  
     test_method.push(
       Statement.new(

data/lib/util/Parser.rb

@@ -119,25 +119,7 @@ class Parser
     end
     
     if sexp[0] == :if
-      # TODO  Look into the change in the nil position
-      # 
-      # "if(var2 == var3)\nreturn true\nend"
-      # s(:if, s(:call, s(:call, nil, :var2, s(:arglist)), :==, s(:arglist, s(:call, nil, :var3, s(:arglist)))), s(:return, s(:true)), nil)
-      #
-      # "if(var2 != var3)\nreturn true\nend"
-      # s(:if, s(:call, s(:call, nil, :var2, s(:arglist)), :==, s(:arglist, s(:call, nil, :var3, s(:arglist)))), nil, s(:return, s(:true)))
-      #      
-      internal_statements = (2...sexp.length).inject([]) do |total,x| 
-        total << sexp[x] unless sexp[x].nil?
-        total
-      end 
-      return OpenStatement.new(
-        IfContainer.new(
-          parse_token(sexp[1])
-        ),
-        *internal_statements.collect {|x| parse_token(x)}
-      )  
-      
+      return self.parse_if(sexp)
     end
     
     if sexp[0] == :attrasgn
@@ -182,6 +164,29 @@ class Parser
     raise StandardError.new("Could not find sexp '#{sexp[0].to_s}'")
   end  
   
+  def self.parse_if(sexp)
+    # TODO  Look into the change in the nil position
+    # 
+    # "if(var2 == var3)\nreturn true\nend"
+    # s(:if, s(:call, s(:call, nil, :var2, s(:arglist)), :==, s(:arglist, s(:call, nil, :var3, s(:arglist)))), s(:return, s(:true)), nil)
+    #
+    # "if(var2 != var3)\nreturn true\nend"
+    # s(:if, s(:call, s(:call, nil, :var2, s(:arglist)), :==, s(:arglist, s(:call, nil, :var3, s(:arglist)))), nil, s(:return, s(:true)))
+    #      
+    internal_statements = (2...sexp.length).inject([]) do |total,x| 
+      total << sexp[x] unless sexp[x].nil?
+      total
+    end 
+    return OpenStatement.new(
+      Statement.new(
+        If.new,
+        Container.new(parse_token(sexp[1]))
+      ),
+      *internal_statements.collect {|x| parse_token(x)}
+    )      
+    
+  end
+  
   def self.parse_simple_token(token)
     if token.to_s.match(/^var(\d+)$/)
       id = token.to_s.match(/^var(\d+)$/)[1].to_i
@@ -284,7 +289,8 @@ class Parser
       'statement_id' => 'StatementID',
       'last' => 'Last',
       'select' => 'Select',
-      '-' => 'Subtract'
+      '-' => 'Subtract',
+      'first' => 'First'
     }
     # TODO  Need to re-structure code to better suit the parser and how it handles != statements
     if not affirmative

data/lib/util/StringToTheory.rb

@@ -41,7 +41,7 @@ class StringToTheory < Parser
   def self.run(statement_string)
     statement_string.gsub!(/<runtime_method>/,'runtime_method')
     return super(statement_string)
-
+    
   end
   
   # TODO  This method is very similar to the Parser
@@ -69,17 +69,18 @@ class StringToTheory < Parser
       'Unknown'=>'UnknownClass',
       'Addition'=>'AdditionClass',
       'Equal'=>'EqualClass',
+      'If'=>'IfClass',
       'RuntimeMethod'=>'RuntimeMethodClass',
       'CTestCase'=>'CTestCaseClass',
       'Fixnum'=>'FixnumClass',
       'Equivalent'=>'EquivalentClass',
       'OpenStatement'=>'OpenStatementClass',
-      'IfContainer'=>'IfContainerClass',
       'BlockStatement'=> 'BlockStatementClass',
       'Container'=> 'ContainerClass',
       'Subtract'=> 'SubtractClass',
       'Times'=> 'TimesClass',
-      'Chop'=> 'ChopClass'
+      'Chop'=> 'ChopClass',
+      'TheoryStatement'=> 'TheoryStatementClass'
     }
     raise StandardError.new('Unkown constant '+token.to_s) unless constants.has_key?(token.to_s)
     eval(constants[token.to_s]+'.new')
@@ -98,6 +99,29 @@ class StringToTheory < Parser
     end    
   end
   
+  def self.parse_if(sexp)
+    # TODO  Look into the change in the nil position
+    # 
+    # "if(var2 == var3)\nreturn true\nend"
+    # s(:if, s(:call, s(:call, nil, :var2, s(:arglist)), :==, s(:arglist, s(:call, nil, :var3, s(:arglist)))), s(:return, s(:true)), nil)
+    #
+    # "if(var2 != var3)\nreturn true\nend"
+    # s(:if, s(:call, s(:call, nil, :var2, s(:arglist)), :==, s(:arglist, s(:call, nil, :var3, s(:arglist)))), nil, s(:return, s(:true)))
+    #      
+    internal_statements = (2...sexp.length).inject([]) do |total,x| 
+      total << sexp[x] unless sexp[x].nil?
+      total
+    end 
+    return OpenStatement.new(
+      TheoryStatement.new(
+        If.new,
+        Container.new(parse_token(sexp[1]))
+      ),
+      *internal_statements.collect {|x| parse_token(x)}
+    )      
+    
+  end  
+  
   def self.parse_return(sexp)
     return TheoryStatement.new(
       *[sexp[0],sexp[1]].collect {|x| parse_token(x)}

data/spec/cauldron/chain_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+module Cauldron
+  
+  describe 'Chain' do 
+    
+    describe '#complete?' do
+      it 'chain is complete with just "return param1"' do        
+        temp = Object.new
+        temp.extend(Cauldron::Demos)
+        demo = temp.demo_one
+        demo[:chain].complete?.should == true
+      end
+      it 'chain is complete with "if param1 == \'carrot\'"' do        
+        temp = Object.new
+        temp.extend(Cauldron::Demos)
+        demo = temp.demo_two
+        demo[:chain].complete?.should == true        
+      end
+    end
+    
+  end
+
+end

data/spec/cauldron/demos_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+module Cauldron
+  
+  describe 'Demos' do 
+    
+    describe '#demo_one' do
+      it 'can generate a demo that can generate a simple runtime method' do
+        temp = Object.new
+        temp.extend(Cauldron::Demos)
+        demo = temp.demo_one
+        
+        # => TODO Don't like this coupling
+        Cauldron::Pot.new.demo_works?(demo).should == true
+      end
+    end
+
+    describe '#demo_two' do
+      it 'generates a demo that can return two different values' do
+        temp = Object.new
+        temp.extend(Cauldron::Demos)
+        demo = temp.demo_two
+        
+        Cauldron::Pot.new.demo_works?(demo).should == true        
+      end
+    end
+    
+  end
+
+end