cauldron 0.1.0

data/lib/util/System.rb

@@ -0,0 +1,8 @@
+class System
+  
+  def self.reset
+    Variable.reset_global_id
+    RuntimeMethod.reset_global_id    
+  end
+  
+end

data/spec/cauldron/pot_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+module Cauldron
+  
+
+end

data/spec/cauldron/runtime_method_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+def fetch_runtime
+  
+  basic_runtime = %q!
+    def method_1(var_2)
+      return var_2
+    end
+  !
+  puts basic_runtime
+  res = eval(basic_runtime)
+  sexp = RubyParser.new.process(basic_runtime)  
+  p Ruby2Ruby.new.process(sexp)
+  
+end
+
+
+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"
+      end
+      
+    end
+     
+   end
+   
+end

data/spec/cauldron/sexp_2_cauldron_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module Cauldron
+  
+  describe "Sexp2Cauldron" do
+    describe "#process" do
+      it "Generates a cauldron literal from a sexp literal" do
+        parser    = RubyParser.new
+        ruby      = "8"
+        sexp      = parser.process(ruby)
+        sexp2cauldron = Sexp2Cauldron.new      
+        sexp2cauldron.process(sexp).write.should == Literal.new(8).write        
+      end      
+      
+      it "Generates a basic cauldron statement" do
+        parser    = RubyParser.new
+        ruby      = "var4 = 9"
+        sexp      = parser.process(ruby)
+        sexp2cauldron = Sexp2Cauldron.new
+        sexp2cauldron.process(sexp).write.should == Statement.new(Unknown.new(4),Equal.new,Literal.new(9)).write        
+      end
+      
+    end
+  end
+  
+end

data/spec/cauldron/terminal_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+module Cauldron
+  
+  describe "Terminal" do
+    
+    let(:output) {double('output').as_null_object}
+    let(:terminal) {Terminal.new(output)}
+    
+    describe '#start' do
+      it 'sends an introduction message' do 
+        output.should_receive(:puts).with("Thanks for trying Cauldron - it's at really early stage right now")
+        terminal.start        
+      end
+      it 'sends instruction message' do 
+        output.should_receive(:puts).with("To start enter your first test like this")
+        output.should_receive(:puts).with("input,input,output")
+        output.should_receive(:puts).with("For example ")
+        output.should_receive(:puts).with("and when you're done just type RUN")
+        terminal.start
+      end
+    end
+    
+    describe 'submit' do
+      context "with example case \"'sparky', 'sparky'\"" do
+        subject do
+          terminal.submit "'sparky','sparky'"
+          terminal.submit "'kel','kel'"
+          terminal.cases
+        end
+        its([0]) { should eq({:output=>"sparky", :params=>["sparky"]}) }
+        its([1]) { should eq({:output=>"kel", :params=>["kel"]}) }
+      end     
+    end
+      
+  end
+  
+end

data/spec/cauldron/theory_action_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+module Cauldron
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'cauldron'
+
+# TODO  I would rather use the module:: Cauldron structure
+require 'required'

data/test/fixtures/chains/1/declaration.txt

@@ -0,0 +1,26 @@
+
+        runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
+        sparky = CTestCase.new
+        sparky[:params] = ['sparky']
+        sparky[:output] = 6
+        kel = CTestCase.new
+        kel[:params] = ['kel']
+        kel[:output] = 3
+        test_cases = [
+          sparky,kel
+        ]    
+        finish = Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend")
+        
+        # Generate the head theory - this is the starting point and doesn't have any dependents
+        accessors, mapping = TheoryGenerator.new.generate_accessors_and_mapping(test_cases,runtime_method,7,0)
+        
+        # * Generate all the possible results of this runtime method
+        theory_results = TheoryGenerator.new.get_theory_results(accessors)
+        
+        # * Create the actual head theory
+        head_theory = Theory.new([],nil,theory_results,runtime_method.copy)        
+    
+        intial_chain = Chain.new
+        intial_chain.form_chain(head_theory,finish,mapping)
+        intial_chain
+      

data/test/fixtures/chains/2/declaration.txt

@@ -0,0 +1,26 @@
+
+        runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
+        sparky = CTestCase.new
+        sparky[:params] = ['sparky']
+        sparky[:output] = 6
+        kel = CTestCase.new
+        kel[:params] = ['kel']
+        kel[:output] = 3
+        test_cases = [
+          sparky,kel
+        ]    
+        finish = Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend")
+        
+        # Generate the head theory - this is the starting point and doesn't have any dependents
+        accessors, mapping = TheoryGenerator.new.generate_accessors_and_mapping(test_cases,runtime_method,7,0)
+        
+        # * Generate all the possible results of this runtime method
+        theory_results = TheoryGenerator.new.get_theory_results(accessors)
+        
+        # * Create the actual head theory
+        head_theory = Theory.new([],nil,theory_results,runtime_method.copy)        
+    
+        intial_chain = Chain.new
+        intial_chain.form_chain(head_theory,finish,mapping)
+        intial_chain
+      

data/test/fixtures/chains/3/declaration.txt

@@ -0,0 +1,26 @@
+
+        runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
+        sparky = CTestCase.new
+        sparky[:params] = ['sparky']
+        sparky[:output] = 6
+        kel = CTestCase.new
+        kel[:params] = ['kel']
+        kel[:output] = 3
+        test_cases = [
+          sparky,kel
+        ]    
+        finish = Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend")
+        
+        # Generate the head theory - this is the starting point and doesn't have any dependents
+        accessors, mapping = TheoryGenerator.new.generate_accessors_and_mapping(test_cases,runtime_method,7,0)
+        
+        # * Generate all the possible results of this runtime method
+        theory_results = TheoryGenerator.new.get_theory_results(accessors)
+        
+        # * Create the actual head theory
+        head_theory = Theory.new([],nil,theory_results,runtime_method.copy)        
+    
+        intial_chain = Chain.new
+        intial_chain.form_chain(head_theory,finish,mapping)
+        intial_chain
+      

data/test/fixtures/implementation_results/0/declaration.txt

@@ -0,0 +1,3 @@
+
+          TheoryResult.new(Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend"))
+        

data/test/fixtures/theories/0/declaration.txt

@@ -0,0 +1,9 @@
+
+    dependent_one = TheoryDependent.new(StringToTheory.run("if(var1.realise2(var2).params[0].value.length == var3.length)\nend"))
+    action_one = TheoryAction.new(
+    	TheoryStatement.new(StringToTheory.run('Statement.new(Return.new,var4.params[0])')),
+    	StringToTheory.run('var1.statement_id')
+		)
+    result_one = TheoryResult.new(StringToTheory.run("if(var1.all_pass?(var5))\nreturn true\nend"),true)      
+    Theory.new([dependent_one],action_one,[result_one]) 
+    

data/test/fixtures/theories/0/desc

@@ -0,0 +1,10 @@
+if: 
+	if(var1.realise2(var2).params[0].value.length == var3.length)
+	end
+
+action: 
+	<runtime_method>.add_statement_at(Statement.new(Return.new, var4.params[0]),var1.statement_id)
+result: 
+	if(var1.all_pass?(var5))
+		return true
+	end

data/test/fixtures/theories/1/declaration.txt

@@ -0,0 +1,15 @@
+
+    dependent_one = TheoryDependent.new(
+    	StringToTheory.run(
+    		"if(var1.realise2(var3[var4][:params]).params[0].value.length == var3[var4][:output].length)\nreturn true\nend"
+			)
+		)
+    action_one = TheoryAction.new(
+    	TheoryStatement.new(
+    		StringToTheory.run('Statement.new(Return.new,var1.params[0])')
+			),
+			StringToTheory.run('var1.statement_id')
+		)
+    result_one = TheoryResult.new(StringToTheory.run("if(var1.all_pass?(var3))\nreturn true\nend"))      
+    Theory.new([dependent_one],action_one,[result_one]) 
+    

data/test/fixtures/theories/1/desc

@@ -0,0 +1,11 @@
+if: 
+	if(var1.realise2(var3[var4][:params]).params[0].value.length == var3[var4][:output].length)
+		return true
+	end
+
+action: 
+	<runtime_method>.add_statement_at(Statement.new(Return.new, var1.params[0]),var1.statement_id)
+result: 
+	if(var1.all_pass?(var3))
+		return true
+	end

data/test/fixtures/theories/10/declaration.txt

@@ -0,0 +1,23 @@
+
+    dependent_one = TheoryResult.new(StringToTheory.run(
+      "if(var1.history(var2[var3][:params]).any? { |x| x.statement_id == var1.last.statement_id })\nreturn true\nend"
+    ))
+    dependent_two = TheoryResult.new(StringToTheory.run(
+      "if((var1.history(var2[var4][:params]).any? { |x| x.statement_id == var1.last.statement_id })==false)\nreturn true\nend"
+    ))
+    action = TheoryAction.new(
+      TheoryStatement.new(StringToTheory.run('Statement.new(Return.new,var2[var3][:output])')),
+      StringToTheory.run('var1.last.statement_id')
+    )    
+    result_one = TheoryResult.new(StringToTheory.run(
+      "if(var1.pass?(var2[var3]))\nreturn true\nend"
+    ))
+    result_two = TheoryResult.new(StringToTheory.run(
+      "if(var1.pass?(var2[var4])==false)\nreturn true\nend"
+    ))    
+    Theory.new(
+      [dependent_one,dependent_two],
+      action,
+      [result_one,result_two]
+    )
+    

data/test/fixtures/theories/10/desc

@@ -0,0 +1,17 @@
+if: 
+	if(var1.history(var2[var3][:params]).any?{ |x| x.statement_id == var1.last.statement_id} )
+		return true
+	end
+	if((var1.history(var2[var4][:params]).any?{ |x| x.statement_id == var1.last.statement_id} ) == false)
+		return true
+	end
+
+action: 
+	<runtime_method>.add_statement_at(Statement.new(Return.new, var2[var3][:output]),var1.last.statement_id)
+result: 
+	if(var1.pass?(var2[var3]))
+		return true
+	end
+	if(var1.pass?(var2[var4]) == false)
+		return true
+	end

data/test/fixtures/theories/11/declaration.txt

@@ -0,0 +1,20 @@
+
+    dependent_one = TheoryResult.new(StringToTheory.run(
+      "if(var1.pass?(var2[var3]))\nreturn true\nend"
+    ))
+    dependent_two = TheoryResult.new(StringToTheory.run(
+      "if(var1.pass?(var2[var4]) == false)\nreturn true\nend"
+    ))
+    action = TheoryAction.new(
+      TheoryStatement.new(StringToTheory.run('Statement.new(Return.new,var2[var4][:output])')),
+      StringToTheory.run('var1.statement_id')
+    )
+    result_one = TheoryResult.new(StringToTheory.run(
+      "if(var1.pass?(var2[var4]))\nreturn true\nend"
+    ))    
+    Theory.new(
+      [dependent_one,dependent_two],
+      action,
+      [result_one]
+    )
+    

data/test/fixtures/theories/11/desc

@@ -0,0 +1,14 @@
+if: 
+	if(var1.pass?(var2[var3]))
+		return true
+	end
+	if(var1.pass?(var2[var4]) == false)
+		return true
+	end
+
+action: 
+	<runtime_method>.add_statement_at(Statement.new(Return.new, var2[var4][:output]),var1.statement_id)
+result: 
+	if(var1.pass?(var2[var4]))
+		return true
+	end

data/test/fixtures/theories/12/declaration.txt

@@ -0,0 +1,18 @@
+
+    dependent_one = TheoryDependent.new(StringToTheory.run(
+      "if(var1.pass?(var2[var3]))\nreturn true\nend"
+    ))
+    dependent_two = TheoryDependent.new(StringToTheory.run(
+      "if(var1.pass?(var2[var4]))\nreturn true\nend"
+    ))    
+    
+    result_one = TheoryResult.new(StringToTheory.run(
+      "if(var1.all_pass?(var2))\nreturn true\nend"
+    ))        
+    
+      Theory.new(
+        [dependent_one,dependent_two],
+        nil,
+        [result_one]
+      )        
+    

data/test/fixtures/theories/12/desc

@@ -0,0 +1,12 @@
+if: 
+	if(var1.pass?(var2[var3]))
+		return true
+	end
+	if(var1.pass?(var2[var4]))
+		return true
+	end
+
+result: 
+	if(var1.all_pass?(var2))
+		return true
+	end

data/test/fixtures/theories/13/declaration.txt

@@ -0,0 +1,24 @@
+
+    dependent_one = TheoryDependent.new(StringToTheory.run("if(var2[var3].kind_of?(CTestCase))\nreturn true\nend"))
+    dependent_two = TheoryDependent.new(StringToTheory.run("if(var6.kind_of?(Fixnum))\nreturn true\nend"))
+    dependent_three = TheoryDependent.new(
+      StringToTheory.run("if((var2[var3][:params][var6] == var2[var4][:params][var6])==false)\nreturn true\nend")
+    )
+    action = TheoryAction.new(
+      TheoryStatement.new(StringToTheory.run(
+        'OpenStatement.new(IfContainer.new(var1.params[var6],Equivalent.new,var2[var3][:params][var6]))'
+      )),
+      StringToTheory.run('var1.statement_id')
+    )
+    result_one = TheoryResult.new(StringToTheory.run(
+      "if(var5.history2(var2[var3][:params]).any? { |x| x['statement_id'] == var1.last.statement_id })\nreturn true\nend"
+    ))
+    result_two = TheoryResult.new(StringToTheory.run(
+      "if((var5.history2(var2[var4][:params]).any? { |x| x['statement_id'] == var1.last.statement_id })==false)\nreturn true\nend"
+    ))    
+    Theory.new(
+      [dependent_one,dependent_two,dependent_three],
+      action,
+      [result_one,result_two]
+    )  
+    

data/test/fixtures/theories/13/desc

@@ -0,0 +1,20 @@
+if: 
+	if(var2[var3].kind_of?(CTestCase))
+		return true
+	end
+	if(var6.kind_of?(Fixnum))
+		return true
+	end
+	if((var2[var3][:params][var6] == var2[var4][:params][var6]) == false)
+		return true
+	end
+
+action: 
+	<runtime_method>.add_statement_at(OpenStatement.new(IfContainer.new(var1.params[var6], Equivalent.new, var2[var3][:params][var6])),var1.statement_id)
+result: 
+	if(var5.history2(var2[var3][:params]).any?{ |x| x['statement_id'] == var1.last.statement_id} )
+		return true
+	end
+	if((var5.history2(var2[var4][:params]).any?{ |x| x['statement_id'] == var1.last.statement_id} ) == false)
+		return true
+	end