cauldron 0.1.0 → 0.1.1

data/spec/cauldron/pot_spec.rb

@@ -2,5 +2,71 @@ require 'spec_helper'
 
 module Cauldron
   
+  describe 'Pot' do 
+    
+    describe '#simmer' do
+      it 'can simmer with demo one' do 
+        pot = Cauldron::Pot.new
+        pot.clear
+        lambda {pot.simmer(demo_one)}.should_not raise_error
+      end
+      it 'can simmer with demo two' do 
+        pot = Cauldron::Pot.new
+        pot.clear
+        lambda {pot.simmer(demo_two)}.should_not raise_error        
+      end
+      it 'can simmer with both demo one and two' do
+        pot = Cauldron::Pot.new
+        pot.clear
+        lambda {pot.simmer(demo_one)}.should_not raise_error
+        lambda {pot.simmer(demo_two)}.should_not raise_error        
+      end
+    end
+    
+    describe '#brew' do
+      it 'can come up with a solution after it has been given demo_one' do
+        pot = Cauldron::Pot.new
+        pot.clear
+        pot.simmer(demo_one)
+        cases = []
+        cases << convert_to_example(separate_values("'sparky','sparky'"))
+        cases << convert_to_example(separate_values("'kel','kel'"))
+        
+        ruby      =  "
+            def method_0(var_0)
+              \treturn var_0
+            end
+          "             
+        parser    = RubyParser.new          
+        sexp      = parser.process(ruby)
+        sexp2cauldron = Sexp2Cauldron.new      
+        pot.brew(cases).reset_ids!.basic_write.should == sexp2cauldron.process(sexp).basic_write  
+      end
+      
+      it 'can come up with a solution that fits demo two' do
+        pot = Cauldron::Pot.new
+        pot.clear
+        pot.simmer(demo_two)
+        cases = []
+        cases << convert_to_example(separate_values("'carrot','vegtable'"))
+        cases << convert_to_example(separate_values("'fish','animal'"))
+        
+        ruby      =  "
+                        def method_0(var_0)
+                          \tif(var_0 == 'carrot')
+                          \t\treturn 'vegtable'
+                          \tend
+                          \treturn 'animal'
+                        end        
+                     "
+        parser    = RubyParser.new          
+        sexp      = parser.process(ruby)
+        sexp2cauldron = Sexp2Cauldron.new
+        pot.brew(cases).reset_ids!.basic_write.should == sexp2cauldron.process(sexp).basic_write                     
+      end
+      
+    end
+    
+  end
 
 end

data/spec/cauldron/runtime_method_spec.rb

@@ -7,10 +7,8 @@ def fetch_runtime
       return var_2
     end
   !
-  puts basic_runtime
   res = eval(basic_runtime)
   sexp = RubyParser.new.process(basic_runtime)  
-  p Ruby2Ruby.new.process(sexp)
   
 end
 
@@ -20,15 +18,59 @@ module Cauldron
    describe 'RuntimeMethod' do
      
     describe '#basic_write' do
-      
       # => TODO I need a factory or better way to write the runtime methods
       it 'should return a string of the built method without comment information' do 
         method_param = MethodParameter.new
         temporary_runtime_method = RuntimeMethod.new(MethodUsage.new(method_param))
         temporary_runtime_method << Statement.new(Return.new,method_param)
-        temporary_runtime_method.basic_write.should == "def method_2(var_4)\n\treturn var_4\nend\n"
+        temporary_runtime_method.reset_ids!.basic_write.should == "def method_0(var_0)\n\treturn var_0\nend\n"
+      end
+    end
+    
+    describe '#reset_ids!' do
+      context 'runtime method is empty' do
+        it 'should return a new runtime method with the method id and variables starting from 0(this is for comparision)' do 
+          parser    = RubyParser.new
+          ruby      =  "
+            def method_8
+            end
+          "
+          sexp      = parser.process(ruby)
+          sexp2cauldron = Sexp2Cauldron.new
+          unprocessed_runtime_method = sexp2cauldron.process(sexp)
+          reset_runtime_method = unprocessed_runtime_method.reset_ids!        
+          reset_runtime_method.method_id.should == '0'  
+        end
+      end
+      context 'using runtime method with if statement' do
+        it 'it should reset all the ids to 0 and count up' do
+          parser    = RubyParser.new
+          ruby      =  "
+            def method_3(var_8)
+              \tif(var_8 == 'apple')
+              \t\treturn 'fruit'
+              \tend
+              \treturn 'vegetable'
+            end
+          "        
+          sexp      = parser.process(ruby)
+          sexp2cauldron = Sexp2Cauldron.new                  
+          unprocessed_runtime_method = sexp2cauldron.process(sexp)  
+          reset_runtime_method = unprocessed_runtime_method.reset_ids!
+          reset_runtime_method.method_id.should == '0'
+          reset_runtime_method.variables.length.should == 1
+          
+          ruby_reset      =  "
+            def method_0(var_0)
+              \tif(var_0 == 'apple')
+              \t\treturn 'fruit'
+              \tend
+              \treturn 'vegetable'
+            end
+          "          
+          reset_runtime_method.basic_write.should == strip_whitespace(ruby_reset)+"\n"
+        end
       end
-      
     end
      
    end

data/spec/cauldron/sexp_2_cauldron_spec.rb

@@ -20,6 +20,98 @@ module Cauldron
         sexp2cauldron.process(sexp).write.should == Statement.new(Unknown.new(4),Equal.new,Literal.new(9)).write        
       end
       
+      it 'generates a basic if container' do 
+        parser    = RubyParser.new
+        ruby      =  %q!
+          if(var5 == 6)
+          end
+        !
+        sexp      = parser.process(ruby)
+        sexp2cauldron = Sexp2Cauldron.new
+        sexp      = parser.process(ruby)
+        sexp2cauldron.process(sexp).write.should == "if(var_5 == 6)\nend"        
+      end
+      
+      it 'generates an empty runtime method' do
+        parser    = RubyParser.new
+        ruby      =  %q!
+          def method_4
+          end
+        !
+        sexp      = parser.process(ruby)
+        sexp2cauldron = Sexp2Cauldron.new
+        sexp2cauldron.process(sexp).basic_write.should == strip_whitespace(ruby)+"\n"        
+      end
+      
+      it 'generates a method with a simple statement' do 
+        parser    = RubyParser.new
+        ruby      =  "
+          def method_3
+            \tvar_8 = 9
+          end
+        "
+        sexp      = parser.process(ruby)
+        sexp2cauldron = Sexp2Cauldron.new
+        a = sexp2cauldron.process(sexp)
+        a.basic_write.should == strip_whitespace(ruby)+"\n"
+      end
+      
+      it 'generates a method with a simple if statement' do
+        parser    = RubyParser.new
+        ruby      =  "
+          def method_6
+            \tif(var_8 == 9)
+            \t\treturn var_8
+            \tend
+          end
+        "
+        sexp2cauldron = Sexp2Cauldron.new        
+        sexp      = parser.process(ruby)
+        sexp2cauldron.process(sexp).basic_write.should == strip_whitespace(ruby)+"\n"        
+      end
+      
+      it 'generates a method with an if statement and two exit points' do 
+        parser    = RubyParser.new
+        ruby      =  "
+          def method_3(var_0)
+            \tif(var_0 == 'apple')
+            \t\treturn 'fruit'
+            \tend
+            \treturn 'vegetable'
+          end
+        "
+        sexp2cauldron = Sexp2Cauldron.new        
+        sexp      = parser.process(ruby)
+        sexp2cauldron.process(sexp).basic_write.should == strip_whitespace(ruby)+"\n"        
+      end
+      
+      it 'generates the solution to demo 1' do
+        parser    = RubyParser.new
+        ruby      =  "
+          def method_0(var_0)
+            \treturn var_0
+          end
+        "
+        sexp2cauldron = Sexp2Cauldron.new        
+        sexp      = parser.process(ruby)
+        sexp2cauldron.process(sexp).basic_write.should == strip_whitespace(ruby)+"\n"         
+      end
+      
+      it 'can parse the solution to demo 2' do
+        parser    = RubyParser.new
+        ruby      =  "
+          def method_0(var_0)
+            \tif(var_0 == 'fish')
+            \t\treturn 'animal'
+            \tend
+            \treturn 'vegtable'
+          end
+        "
+        sexp2cauldron = Sexp2Cauldron.new        
+        sexp      = parser.process(ruby)
+        sexp2cauldron.process(sexp).basic_write.should == strip_whitespace(ruby)+"\n"         
+      end
+      
     end
   end
   

data/spec/cauldron/terminal_spec.rb

@@ -21,7 +21,7 @@ module Cauldron
       end
     end
     
-    describe 'submit' do
+    describe '#submit' do
       context "with example case \"'sparky', 'sparky'\"" do
         subject do
           terminal.submit "'sparky','sparky'"

data/spec/cauldron/theory_action_spec.rb

@@ -2,4 +2,24 @@ require 'spec_helper'
 
 module Cauldron
   
+  describe 'TheoryAction' do
+    
+    describe '#statements_with_variable' do
+      
+      it 'should return two statements for the action "Statement.new(Return.new, var0.params[var2]),var0.statement_id"' do
+        link_one_action = TheoryAction.new(
+          TheoryStatement.new(StringToTheory.run('Statement.new(Return.new,var1.params[var3])')),
+          StringToTheory.run('var1.statement_id')
+        )
+        link_one_action.statements_with_variable(1).length.should == 3
+        res = link_one_action.statements_with_variable(1).collect {|x| x.write }
+        res.should include('var1.statement_id')
+        res.should include('var1.params') 
+        
+      end
+      
+    end
+    
+  end
+  
 end

data/spec/cauldron/theory_connector_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+StandardLogger.instance.level = Logger::FATAL
+
+module Cauldron
+  
+  describe TheoryConnector do
+    
+    describe '#generate_chains' do
+      context 'when it has demo 1 theories' do
+        it 'will generate just one chain' do
+          theories = demo_one[:chain].collect {|x| x}
+          runtime_method = demo_one[:initial_method]
+          test_cases = demo_one[:test_cases]
+          
+          connector = TheoryConnector.new(demo_one[:values])
+          connector.generate_chains(runtime_method,test_cases,theories).length.should == 1
+        end
+      end
+      context "when it has demo two's theories" do
+        it 'will generate just one chain' do
+          theories = demo_two[:chain].collect {|x| x}
+          runtime_method = demo_two[:initial_method]
+          test_cases = demo_two[:test_cases]
+          
+          connector = TheoryConnector.new(demo_two[:values])
+          connector.generate_chains(runtime_method,test_cases,theories).length.should == 1          
+        end
+      end
+      context "when it has both demo one and two's theories" do
+        it 'will generate just one chain' do
+          @theories = demo_one[:chain].collect {|x| x} + demo_two[:chain].collect {|x| x}
+          runtime_method = demo_one[:initial_method]
+          test_cases = demo_one[:test_cases]
+          
+          connector = TheoryConnector.new(demo_one[:values])
+          connector.generate_chains(runtime_method,test_cases,@theories).length.should == 1          
+        end
+        it 'will generate two chains when given demo two test cases' do
+          @theories = demo_one[:chain].collect {|x| x} + demo_two[:chain].collect {|x| x}
+          runtime_method = demo_two[:initial_method]
+          test_cases = demo_two[:test_cases]
+          
+          connector = TheoryConnector.new(demo_one[:values])
+          connector.generate_chains(runtime_method,test_cases,@theories).length.should == 1          
+        end
+      end
+    end
+    
+  end
+  
+end

data/spec/cauldron/theory_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+module Cauldron
+  
+  describe 'Theory' do 
+    
+    describe '#map_to' do
+      it 'can map a simple theory to new values' do
+        link_one_action = TheoryAction.new(
+          TheoryStatement.new(StringToTheory.run('Statement.new(Return.new,var2.params[var3])')),
+          StringToTheory.run('var1.statement_id')
+        )
+        link_one_result = TheoryResult.new(StringToTheory.run("if(var1.all_pass?(var2))\nreturn true\nend"))
+        theory = Theory.new([],link_one_action,[link_one_result])        
+        
+        # Create the mapping for the theory
+        mapping = Mapping.new({
+          1=>IntrinsicRuntimeMethod.new,
+          2=>IntrinsicTestCases.new,
+          3=>IntrinsicLiteral.new(0)
+        })
+        # => TODO Why doesn't the tab character appear - or appear as a space
+        result = " 
+if: 
+
+action: 
+\truntime_method.add_statement_at(Statement.new(Return.new, test_cases.params[0]),runtime_method.statement_id)
+result: 
+\tif(runtime_method.all_pass?(test_cases))
+\t\treturn true
+\tend
+"
+        theory.map_to(mapping).write.strip.should == result.strip
+        
+      end
+      it 'can map a theory with an if statement' do 
+        
+        link_one_action = TheoryAction.new(
+          TheoryStatement.new(StringToTheory.run(
+            'OpenStatement.new(If.new,Container.new(var1.params[var3],Equivalent.new,var2[var4][:params][var5]))')
+          ),
+          StringToTheory.run('var1.statement_id')
+        )
+        theory = Theory.new([],link_one_action,[])
+        mapping = Mapping.new({
+          1=>IntrinsicRuntimeMethod.new,
+          2=>IntrinsicTestCases.new,
+          3=>IntrinsicLiteral.new(0),
+          4=>IntrinsicLiteral.new(0),
+          5=>IntrinsicLiteral.new(0)
+        })        
+        puts theory.map_to(mapping).describe        
+        
+      end
+    end
+    
+  end
+
+end

data/spec/cauldron/unified_chain_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+module Cauldron
+  
+  describe 'UnifiedChain' do 
+    
+    describe '#theory_variables' do
+      it 'gets the correct number of variables for demo 1' do
+        temp = Object.new
+        temp.extend(Cauldron::Demos)
+        demo = temp.demo_one
+        # => TODO Demos should probably only save unified chains
+        unified_chain = demo[:chain].unify_chain
+        unified_chain.theory_variables.length.should == 3           
+      end
+      it 'gets the correct number of variables for demo 2' do
+        temp = Object.new
+        temp.extend(Cauldron::Demos)
+        demo = temp.demo_two
+        unified_chain = demo[:chain].unify_chain
+        unified_chain.theory_variables.length.should == 6       
+        unified_chain.theory_variables.collect {|x| x.theory_variable_id}.uniq.length.should == 6 
+      end
+    end
+    
+    describe '#implementation_permuatations' do
+      context 'when using demo one chain' do
+        
+        it 'creates just one implementation permutation' do
+          temp = Object.new
+          temp.extend(Cauldron::Demos)
+          demo = temp.demo_one
+          unified_chain = demo[:chain].unify_chain
+          test_cases = demo[:test_cases]   
+          
+          unified_chain.implementation_permuatations(
+            RuntimeMethod.new(MethodUsage.new(MethodParameter.new)),
+            test_cases,
+            Mapping.new
+          ).length.should == 1
+        end
+        
+        it 'is a unified chain' do 
+          temp = Object.new
+          temp.extend(Cauldron::Demos)
+          demo = temp.demo_one
+          unified_chain = demo[:chain].unify_chain
+          test_cases = demo[:test_cases]   
+                    
+          unified_chain.implementation_permuatations(
+            RuntimeMethod.new(MethodUsage.new(MethodParameter.new)),
+            test_cases,
+            Mapping.new
+          )[0].should be_kind_of(ImplementedChain)          
+          
+          unified_chain.implementation_permuatations(
+            RuntimeMethod.new(MethodUsage.new(MethodParameter.new)),
+            test_cases,
+            Mapping.new
+          )[0].write.should_not include('var')          
+          
+        end
+        context 'when using demo two' do
+          it 'creates just one implementation permutation' do
+            temp = Object.new
+            temp.extend(Cauldron::Demos)
+            demo = temp.demo_two
+            unified_chain = demo[:chain].unify_chain   
+            test_cases = demo[:test_cases]   
+          
+            unified_chain.implementation_permuatations(
+              RuntimeMethod.new(MethodUsage.new(MethodParameter.new)),
+              test_cases,
+              Mapping.new
+            ).each {|chain| chain.write.should_not include('var')}          
+                                       
+          end
+        end
+      end
+      
+      describe '#mapping_permutations' do
+        before(:each) {
+          temp = Object.new
+          temp.extend(Cauldron::Demos)
+          demo = temp.demo_one
+          @unified_chain = demo[:chain].unify_chain          
+        }
+        it 'should create four permutations with one variable id and four values' do
+          values = [IntrinsicRuntimeMethod.new,IntrinsicTestCases.new,IntrinsicLiteral.new(0),IntrinsicLiteral.new(1)]
+          @unified_chain.mapping_permutations([0],values).length.should == 4
+        end
+        it 'should create 9 permutations with three variable id and three values' do
+          values = [IntrinsicRuntimeMethod.new,IntrinsicTestCases.new,IntrinsicLiteral.new(1)]
+          @unified_chain.mapping_permutations([0,1,2],values).length.should == 6
+        end
+      end
+      
+    end
+    
+  end
+
+end