cauldron 0.1.3 → 0.1.5

data/spec/cauldron/terminal_spec.rb

@@ -2,46 +2,8 @@ require 'spec_helper'
 
 module Cauldron
   
-  describe "Terminal" do
+  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   
-      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/examples/adding_if_statement.yml

@@ -0,0 +1,13 @@
+dependents:
+  - 'var1.kind_of?(RuntimeMethod)'
+  - 'var2.length == 2'
+action:
+  statement: if x == y
+  position: var1.statement_id
+  values: 
+    x: var1.params[var3]
+    y: var2[var4][:params][var5]
+results:
+  - var1.kind_of?(RuntimeMethod)
+  - var2.length == 2    
+  - var4.kind_of?(Fixnum)

data/spec/examples/simple_head_theory.txt

@@ -0,0 +1,13 @@
+dependent:
+
+action:
+
+result: 
+  var1.kind_of?(RuntimeMethod)
+  var2.length == 2
+ 
+dependents:
+action:
+results:
+  - var1.kind_of?(RuntimeMethod)
+  - var2.length == 2

data/spec/spec_helper.rb

@@ -1,15 +1,2 @@
 require 'cauldron'
-
-# TODO  I would rather use the module:: Cauldron structure
-require 'required'
-
-def strip_whitespace(ruby_code)
-  #res = ruby_code.strip.gsub(/\t{1,}/,'\t').gsub(/\s{2,}/,'\n')
-  res = ruby_code.strip.gsub(/\t/,'\t').gsub(/\s{2,}/,'\n')
-  #res = ruby_code.strip.gsub(/\s{2,}/,'\n')
-  #return res.gsub('\t',"\t").gsub('\n',"\n")
-  return res.gsub('\t',"  ").gsub('\n',"\n")
-end
-
-include Cauldron::Demos
-include Cauldron::Conversion
+require 'pry'

data/tasks/theory_tasks.rake

@@ -1,270 +1,270 @@
-# http://rake.rubyforge.org/
-# http://rake.rubyforge.org/files/doc/rakefile_rdoc.html
+# # http://rake.rubyforge.org/
+# # http://rake.rubyforge.org/files/doc/rakefile_rdoc.html
 
-namespace :cauldren do
+# namespace :cauldren do
   
-  namespace :implementations do
+#   namespace :implementations do
     
-    desc 'Rebuild the implementations'
-    task :rebuild do
-      Rake::Task["cauldren:theories:rebuild"].execute
+#     desc 'Rebuild the implementations'
+#     task :rebuild do
+#       Rake::Task["cauldren:theories:rebuild"].execute
       
-      file_list = FileList.new('test/fixtures/theory_implementations/*')
-      file_list.each do |folder_path|
+#       file_list = FileList.new('test/fixtures/theory_implementations/*')
+#       file_list.each do |folder_path|
 
-        implementation_id = folder_path.match(/\d+$/)[0].to_i
-        declaration = File.open(File.join(folder_path,'declaration.txt'),'r').read
-        theory_implementation = eval declaration
+#         implementation_id = folder_path.match(/\d+$/)[0].to_i
+#         declaration = File.open(File.join(folder_path,'declaration.txt'),'r').read
+#         theory_implementation = eval declaration
         
-        dump_file = File.open(File.join(folder_path,'dump'),'w')
-        data = Marshal.dump(theory_implementation)
-        dump_file << data
-        dump_file.close          
+#         dump_file = File.open(File.join(folder_path,'dump'),'w')
+#         data = Marshal.dump(theory_implementation)
+#         dump_file << data
+#         dump_file.close          
         
-      end
+#       end
       
-    end
+#     end
     
-    desc 'Creates a new theory implementation'
-    task :create do
-      implementation_id = 0
+#     desc 'Creates a new theory implementation'
+#     task :create do
+#       implementation_id = 0
       
-      StandardLogger.instance.warning("Caution: Creating new theory implementation #{implementation_id}")
-      directory_path = $LOC+File.join('test','fixtures','theory_implementations',implementation_id.to_s)
-      if(File.exists?(directory_path))
-        StandardLogger.instance.warning("Theory Implementation ficture already exists #{implementation_id} -cancelling")
-        exit
-      else
-        FileUtils.mkdir_p(directory_path)
-      end       
+#       StandardLogger.instance.warning("Caution: Creating new theory implementation #{implementation_id}")
+#       directory_path = $LOC+File.join('test','fixtures','theory_implementations',implementation_id.to_s)
+#       if(File.exists?(directory_path))
+#         StandardLogger.instance.warning("Theory Implementation ficture already exists #{implementation_id} -cancelling")
+#         exit
+#       else
+#         FileUtils.mkdir_p(directory_path)
+#       end       
 
-      # This is just updated here - nothing fancy
-      declaration = %q!
-        theory = Theory.load_theory(1)
-        potential_values = [
-            Parser.run('0'),
-            Parser.run('test_cases'),
-            Parser.run('runtime_method')
-        ]
-        results = theory.rewrite_permutations(potential_values)
-        # NOTE: Rember use grep -A and -B to match particular cases
-        results[5]         
-      !     
-      theory_implementation = eval declaration
+#       # This is just updated here - nothing fancy
+#       declaration = %q!
+#         theory = Theory.load_theory(1)
+#         potential_values = [
+#             Parser.run('0'),
+#             Parser.run('test_cases'),
+#             Parser.run('runtime_method')
+#         ]
+#         results = theory.rewrite_permutations(potential_values)
+#         # NOTE: Rember use grep -A and -B to match particular cases
+#         results[5]         
+#       !     
+#       theory_implementation = eval declaration
       
-      # Save the declaration (incase the theory needs modified
-      declaration_file = File.open(File.join(directory_path,'declaration.txt'),'w+')
-      declaration_file << declaration
-      declaration_file.close     
+#       # Save the declaration (incase the theory needs modified
+#       declaration_file = File.open(File.join(directory_path,'declaration.txt'),'w+')
+#       declaration_file << declaration
+#       declaration_file.close     
       
-      dump_file = File.open(File.join(directory_path,'dump'),'w')
-      data = Marshal.dump(theory_implementation)
-      dump_file << data
-      dump_file.close      
+#       dump_file = File.open(File.join(directory_path,'dump'),'w')
+#       data = Marshal.dump(theory_implementation)
+#       dump_file << data
+#       dump_file.close      
       
-    end
+#     end
     
-    namespace :results do
+#     namespace :results do
       
-      desc "Creates a new theory result implementation with the supplied id"
-      task :create, :arg1 do |t,args|
+#       desc "Creates a new theory result implementation with the supplied id"
+#       task :create, :arg1 do |t,args|
         
-        # Create the directory to save the implementation result
-        directory_path = File.join('test','fixtures','implementation_results',args[:arg1])
-        if(File.exists?(directory_path))
-          StandardLogger.instance.warning("Implementation Result already exists #{args[:arg1]} -cancelling")
-          return
-        else
-          FileUtils.mkdir_p(directory_path)
-        end
+#         # Create the directory to save the implementation result
+#         directory_path = File.join('test','fixtures','implementation_results',args[:arg1])
+#         if(File.exists?(directory_path))
+#           StandardLogger.instance.warning("Implementation Result already exists #{args[:arg1]} -cancelling")
+#           return
+#         else
+#           FileUtils.mkdir_p(directory_path)
+#         end
         
-        declaration = 
-        %q!
-          TheoryResult.new(Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend"))
-        !
+#         declaration = 
+#         %q!
+#           TheoryResult.new(Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend"))
+#         !
         
-        # Save the declaration (incase it needs rebuilt)
-        declaration_file = File.open(File.join(directory_path,'declaration.txt'),'w+')
-        declaration_file << declaration
-        declaration_file.close 
+#         # Save the declaration (incase it needs rebuilt)
+#         declaration_file = File.open(File.join(directory_path,'declaration.txt'),'w+')
+#         declaration_file << declaration
+#         declaration_file.close 
         
-        result = eval declaration
-        data = Marshal.dump(result)
+#         result = eval declaration
+#         data = Marshal.dump(result)
         
-        dump_file = File.open(File.join(directory_path,'dump'),'w+')
-        dump_file << data
-        dump_file.close        
+#         dump_file = File.open(File.join(directory_path,'dump'),'w+')
+#         dump_file << data
+#         dump_file.close        
         
-      end
+#       end
       
-    end
+#     end
     
-  end
+#   end
   
-  namespace :chain do
+#   namespace :chain do
     
-    desc "Create a new initial chain"
-    task :create, :chain_id do |task,args| 
+#     desc "Create a new initial chain"
+#     task :create, :chain_id do |task,args| 
       
-      # Create the directory to save the initial chains into 
-      directory_path = $LOC+File.join('test','fixtures','chains',args[:chain_id])
-      if(File.exists?(directory_path))
-        StandardLogger.instance.warning("A chain with the id #{args[:chain_id]} already exists")
-        return
-      else
-        FileUtils.mkdir_p(directory_path)
-      end      
+#       # Create the directory to save the initial chains into 
+#       directory_path = $LOC+File.join('test','fixtures','chains',args[:chain_id])
+#       if(File.exists?(directory_path))
+#         StandardLogger.instance.warning("A chain with the id #{args[:chain_id]} already exists")
+#         return
+#       else
+#         FileUtils.mkdir_p(directory_path)
+#       end      
       
-      # Create the declaration that creates the chain
-      declaration = 
-      %q!
-        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")
+#       # Create the declaration that creates the chain
+#       declaration = 
+#       %q!
+#         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 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)
+#         # * 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)        
+#         # * 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
-      !      
+#         intial_chain = Chain.new
+#         intial_chain.form_chain(head_theory,finish,mapping)
+#         intial_chain
+#       !      
       
-      # Save the declaration (incase it needs rebuilt)
-      declaration_file = File.open(File.join(directory_path,'declaration.txt'),'w+')
-      declaration_file << declaration
-      declaration_file.close 
+#       # Save the declaration (incase it needs rebuilt)
+#       declaration_file = File.open(File.join(directory_path,'declaration.txt'),'w+')
+#       declaration_file << declaration
+#       declaration_file.close 
       
-      result = eval declaration
-      data = Marshal.dump(result)
+#       result = eval declaration
+#       data = Marshal.dump(result)
       
-      dump_file = File.open(File.join(directory_path,'dump'),'w+')
-      dump_file << data
-      dump_file.close            
+#       dump_file = File.open(File.join(directory_path,'dump'),'w+')
+#       dump_file << data
+#       dump_file.close            
       
-    end
+#     end
     
-    desc "Load the specified chain"
-    task :load_chain, :chain_id do |task,args|
+#     desc "Load the specified chain"
+#     task :load_chain, :chain_id do |task,args|
     
-      # http://stackoverflow.com/questions/825748/how-do-i-pass-command-line-arguments-to-a-rake-task
-      directory_path = $LOC+File.join('test','fixtures','chains',args[:chain_id].to_s)
-      raise StandardError.new("chain #{args[:chain_id].to_s} does not exist") unless(File.exists?(directory_path))
-      dump_file = File.open(File.join(directory_path,'dump'),'r')
+#       # http://stackoverflow.com/questions/825748/how-do-i-pass-command-line-arguments-to-a-rake-task
+#       directory_path = $LOC+File.join('test','fixtures','chains',args[:chain_id].to_s)
+#       raise StandardError.new("chain #{args[:chain_id].to_s} does not exist") unless(File.exists?(directory_path))
+#       dump_file = File.open(File.join(directory_path,'dump'),'r')
            
-      return Marshal.load(dump_file)          
+#       return Marshal.load(dump_file)          
       
-    end
+#     end
     
-  end
+#   end
   
-  namespace :theories do
+#   namespace :theories do
     
-    desc "Create a new theory"
-    task :create do 
+#     desc "Create a new theory"
+#     task :create do 
       
-      theory_id = "20"
+#       theory_id = "20"
    
-      StandardLogger.instance.info("NOTE: Creating new theory fixture #{theory_id.to_s}")
-      # Does a directory for this theory fixture already exist.
-      directory_path = $LOC+File.join('test','fixtures','theories',theory_id.to_s)
-      if(File.exists?(directory_path))
-        StandardLogger.instance.warning("Theory ficture already exists #{theory_id.to_s} -cancelling")
-        exit
-      else
+#       StandardLogger.instance.info("NOTE: Creating new theory fixture #{theory_id.to_s}")
+#       # Does a directory for this theory fixture already exist.
+#       directory_path = $LOC+File.join('test','fixtures','theories',theory_id.to_s)
+#       if(File.exists?(directory_path))
+#         StandardLogger.instance.warning("Theory ficture already exists #{theory_id.to_s} -cancelling")
+#         exit
+#       else
         
-        # Create the directory
-        FileUtils.mkdir_p(directory_path)
+#         # Create the directory
+#         FileUtils.mkdir_p(directory_path)
         
-      end
+#       end
       
-      # This is just updated here - nothing fancy
-      declaration = %q!
-    dependent_one = TheoryDependent.new(StringToTheory.run("if(var2[var3].kind_of?(CTestCase))\nreturn true\nend"))
-    dependent_two = 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(Statement.new(If.new,Container.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],
-      action,
-      [result_one,result_two]
-    )  
-      !
+#       # This is just updated here - nothing fancy
+#       declaration = %q!
+#     dependent_one = TheoryDependent.new(StringToTheory.run("if(var2[var3].kind_of?(CTestCase))\nreturn true\nend"))
+#     dependent_two = 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(Statement.new(If.new,Container.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],
+#       action,
+#       [result_one,result_two]
+#     )  
+#       !
       
-      # Save the declaration (incase the theory needs modified
-      declaration_file = File.open(File.join(directory_path,'declaration.txt'),'w+')
-      declaration_file << declaration
-      declaration_file.close    
+#       # Save the declaration (incase the theory needs modified
+#       declaration_file = File.open(File.join(directory_path,'declaration.txt'),'w+')
+#       declaration_file << declaration
+#       declaration_file.close    
       
-      theory = eval declaration
-      data = Marshal.dump(theory)
+#       theory = eval declaration
+#       data = Marshal.dump(theory)
   
-      # TODO  Shouldn't include colours for this description
-      desc_file = File.open(File.join(directory_path,'desc'),'w+')
-      desc_file << theory.describe
-      desc_file.close
+#       # TODO  Shouldn't include colours for this description
+#       desc_file = File.open(File.join(directory_path,'desc'),'w+')
+#       desc_file << theory.describe
+#       desc_file.close
       
-      dump_file = File.open(File.join(directory_path,'dump'),'w+')
-      dump_file << data
-      dump_file.close 
+#       dump_file = File.open(File.join(directory_path,'dump'),'w+')
+#       dump_file << data
+#       dump_file.close 
       
-    end
+#     end
     
-    desc "Re create the current theories and update their Marshal dump"
-    task :rebuild do
+#     desc "Re create the current theories and update their Marshal dump"
+#     task :rebuild do
       
-      file_list = FileList.new('test/fixtures/theories/*')
-      file_list.each do |x|
-        theory_id = x.match(/\d+$/)[0].to_i
-        directory_path = File.join('test','fixtures','theories',theory_id.to_s)
-        declaration = File.open(File.join(directory_path,'declaration.txt'),'r').read
+#       file_list = FileList.new('test/fixtures/theories/*')
+#       file_list.each do |x|
+#         theory_id = x.match(/\d+$/)[0].to_i
+#         directory_path = File.join('test','fixtures','theories',theory_id.to_s)
+#         declaration = File.open(File.join(directory_path,'declaration.txt'),'r').read
     
-        # Save the declaration (incase the theory needs modified
-        declaration_file = File.open(File.join(directory_path,'declaration.txt'),'w+')
-        declaration_file << declaration
-        declaration_file.close    
+#         # Save the declaration (incase the theory needs modified
+#         declaration_file = File.open(File.join(directory_path,'declaration.txt'),'w+')
+#         declaration_file << declaration
+#         declaration_file.close    
         
-        theory = eval declaration
-        data = Marshal.dump(theory)
+#         theory = eval declaration
+#         data = Marshal.dump(theory)
     
-        desc_file = File.open(File.join(directory_path,'desc'),'w+')
-        desc_file << theory.write
-        desc_file.close
+#         desc_file = File.open(File.join(directory_path,'desc'),'w+')
+#         desc_file << theory.write
+#         desc_file.close
         
-        dump_file = File.open(File.join(directory_path,'dump'),'w+')
-        dump_file << data
-        dump_file.close        
+#         dump_file = File.open(File.join(directory_path,'dump'),'w+')
+#         dump_file << data
+#         dump_file.close        
         
-      end        
+#       end        
       
-    end
+#     end
     
-  end
+#   end
   
-end
+# end