cauldron 0.1.3 → 0.1.5

data/lib/util/System.rb

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

data/spec/cauldron/chain_spec.rb

@@ -1,24 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

data/spec/cauldron/runtime_method_spec.rb

@@ -1,92 +0,0 @@
-require 'spec_helper'
-
-def fetch_runtime
-  
-  basic_runtime = %q!
-    def method_1(var_2)
-      return var_2
-    end
-  !
-  res = eval(basic_runtime)
-  sexp = RubyParser.new.process(basic_runtime)  
-  
-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.reset_ids!.basic_write.should == "def method_0(var_0)\n  return 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 'should reset all the ids to 0 and count up' do
-          parser    = RubyParser.new
-          ruby      =  %q{
-            def method_3(var_8)
-              if(var_8 == 'apple')
-                return 'fruit'
-              end
-              return '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      =  
-%q{def method_0(var_0)
-  if(var_0 == 'apple')
-    return 'fruit'
-  end
-  return 'vegetable'
-end}
-          reset_runtime_method.basic_write.should == ruby_reset+"\n"
-        end
-      end
-    end
-    
-    describe '#realise2' do
-      it 'should be able to realise a very simple runtime method' do
-        parser    = RubyParser.new
-        ruby      =   "
-                      def method_3
-                        var_13 = 8
-                      end
-                      " 
-        sexp      = parser.process(ruby)   
-        sexp2cauldron = Sexp2Cauldron.new
-        runtime_method = sexp2cauldron.process(sexp)
-        runtime_method.realise2(ParametersContainer.new).class.should == RealisedRuntimeMethod           
-      end  
-    end
-     
-   end
-   
-end

data/spec/cauldron/saver_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-module Cauldron
-  
-  module Util
-  
-    describe Saver do 
-      
-      describe '.save' do
-        it 'can save a string object without raising an exception' do
-          lambda {Cauldron::Util::Saver.save('geth')}.should_not raise_error        
-        end
-        it 'will return the path to saved string object after saving it' do
-          Cauldron::Util::Saver.save('Normandy').should match(/cauldron\/debug/)
-        end
-      end
-      
-      describe '.debug_directory' do
-        it 'should return the path to the debug directory' do
-          Cauldron::Util::Saver.debug_directory.should include("/cauldron/debug")
-        end
-      end
-      
-      describe '.next_directory' do
-        it "should return the path to a directory that doesn't exist" do
-          Cauldron::Util::Saver.next_directory.should match(/cauldron\/debug\/\d+/)
-        end
-        it 'should not return the path to an existing directory' do
-          File.exists?(Cauldron::Util::Saver.next_directory).should_not == true
-        end
-      end
-      
-      describe '.load' do 
-        it 'can load a saved obj' do
-          path = Cauldron::Util::Saver.save('Adele & Kirk')
-          path_id = path.match(/(\d+)/)[0].to_i
-          Cauldron::Util::Saver.load(path_id).should == 'Adele & Kirk' 
-        end
-      end
-      
-    end
-  
-  end
-
-end

data/spec/cauldron/sexp_2_cauldron_spec.rb

@@ -1,118 +0,0 @@
-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
-      
-      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
-  
-end

data/spec/cauldron/theory_action_spec.rb

@@ -1,25 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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: 
-  runtime_method.add_statement_at(Statement.new(Return.new, test_cases.params[0]),runtime_method.statement_id)
-result: 
-  if(runtime_method.all_pass?(test_cases))
-    return true
-  end
-"
-        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