cauldron 0.1.0 → 0.1.1

data/spec/spec_helper.rb

@@ -1,4 +1,13 @@
 require 'cauldron'
 
 # TODO  I would rather use the module:: Cauldron structure
-require 'required'
+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')
+  return res.gsub('\t',"\t").gsub('\n',"\n")
+end
+
+include Cauldron::Demos
+include Cauldron::Conversion

data/tasks/theory_tasks.rake

@@ -0,0 +1,274 @@
+# http://rake.rubyforge.org/
+# http://rake.rubyforge.org/files/doc/rakefile_rdoc.html
+
+# TODO  Need a test for the rake tasks as well
+
+namespace :cauldren do
+  
+  namespace :implementations do
+    
+    desc "Re-build the theory implementations"
+    task :rebuild do 
+    
+      file_list = FileList.new('test/fixtures/theory_implementations/*')
+      file_list.each do |x|
+        implementation_id = x.match(/\d+$/)[0].to_i
+    
+        directory_path = $LOC+File.join('test','fixtures','theories',theory_id.to_s)
+        
+      end                
+    
+      # TODO  The current approach to saving the implementations - I'd like to be able
+      #       to right the declarations to file.
+      
+      puts 'Does not do anything'
+      
+    end
+    
+    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       
+
+      # 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     
+      
+      dump_file = File.open(File.join(directory_path,'dump'),'w')
+      data = Marshal.dump(theory_implementation)
+      dump_file << data
+      dump_file.close      
+      
+    end
+    
+    namespace :results do
+      
+      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
+        
+        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 
+        
+        result = eval declaration
+        data = Marshal.dump(result)
+        
+        dump_file = File.open(File.join(directory_path,'dump'),'w+')
+        dump_file << data
+        dump_file.close        
+        
+      end
+      
+    end
+    
+  end
+  
+  namespace :chain do
+    
+    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 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 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
+      !      
+      
+      # 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)
+      
+      dump_file = File.open(File.join(directory_path,'dump'),'w+')
+      dump_file << data
+      dump_file.close            
+      
+    end
+    
+    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')
+           
+      return Marshal.load(dump_file)          
+      
+    end
+    
+  end
+  
+  namespace :theories do
+    
+    desc "Create a new theory"
+    task :create do 
+      
+      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
+        
+        # Create the directory
+        FileUtils.mkdir_p(directory_path)
+        
+      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]
+    )  
+      !
+      
+      # 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)
+  
+      # 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 
+      
+    end
+    
+    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
+        puts '* theory_id: '+theory_id.to_s    
+        puts File.join('test','fixtures','theories',theory_id.to_s)
+        directory_path = File.join('test','fixtures','theories',theory_id.to_s)
+        puts directory_path
+        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    
+        
+        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
+        
+        dump_file = File.open(File.join(directory_path,'dump'),'w+')
+        dump_file << data
+        dump_file.close        
+        
+      end        
+      
+    end
+    
+  end
+  
+end

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

@@ -6,7 +6,7 @@
     )
     action = TheoryAction.new(
       TheoryStatement.new(StringToTheory.run(
-        'OpenStatement.new(IfContainer.new(var1.params[var6],Equivalent.new,var2[var3][:params][var6]))'
+        'OpenStatement.new(Statement.new(If.new,Container.new(var1.params[var6],Equivalent.new,var2[var3][:params][var6])))'
       )),
       StringToTheory.run('var1.statement_id')
     )

data/test/fixtures/theories/13/desc

@@ -10,7 +10,7 @@ if:
 	end
 
 action: 
-	<runtime_method>.add_statement_at(OpenStatement.new(IfContainer.new(var1.params[var6], Equivalent.new, var2[var3][:params][var6])),var1.statement_id)
+	<runtime_method>.add_statement_at(OpenStatement.new(Statement.new(If.new, Container.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

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

@@ -5,7 +5,7 @@
     )
     action = TheoryAction.new(
       TheoryStatement.new(StringToTheory.run(
-        'OpenStatement.new(IfContainer.new(var1.params[var6],Equivalent.new,var2[var3][:params][var6]))'
+        'OpenStatement.new(Statement.new(If.new,Container.new(var1.params[var6],Equivalent.new,var2[var3][:params][var6])))'
       )),
       StringToTheory.run('var1.statement_id')
     )

data/test/fixtures/theories/20/desc

@@ -7,7 +7,7 @@ if:
 	end
 
 action: 
-	<runtime_method>.add_statement_at(OpenStatement.new(IfContainer.new(var1.params[var6], Equivalent.new, var2[var3][:params][var6])),var1.statement_id)
+	<runtime_method>.add_statement_at(OpenStatement.new(Statement.new(If.new, Container.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

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

@@ -7,5 +7,5 @@
         ]
         results = theory.rewrite_permutations(potential_values)
         # NOTE: Rember use grep -A and -B to match particular cases
-        results[5]       
+        results[5]         
       

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

@@ -0,0 +1,11 @@
+
+        theory = Theory.load_theory(8)
+        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[0]        
+      

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

@@ -0,0 +1,11 @@
+
+        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[4]       
+      

data/test/output/simple_method.txt

@@ -2,5 +2,4 @@
 #
 #
 def method_0
-
 end

data/test/tc_contextual_variables.rb

@@ -2,6 +2,8 @@
 # the context they are accessed.
 #
 
+# TODO  This can go!
+
 require 'required'
 require 'test/unit'
 
@@ -16,47 +18,6 @@ class TestContextualVariable < Test::Unit::TestCase
     RuntimeMethod.reset_global_id
   end  
   
-  # This test checks that variables taken on the appropriate requirements
-  # based on their position within a statement and then method.
-  #
-  # def method_1(param_1)
-  #   var1 = param1.chop
-  #   var2 = var1.length
-  # end
-  # 
-  # where param_1 = 'test'
-  #
-  def test_method_describtion
-    
-    # Create the var1 - this should haven't any requirements individually
-    var1 = Unknown.new()       
-    assert_equal(0,var1.length)
-    
-    # Create the first statement with var1 in it e.g. var2 = var1.chop
-    chop_call = InstanceCallContainer.new(Unknown.new,Chop.new)
-    first_statement = DeclarationStatement.new(var1,Equal.new,chop_call)
-    
-    # Check that the variables inside the first statement don't have any requirements
-    assert_equal(0,first_statement[0].length)
-    assert_equal(0,first_statement[2].subject.length)
-    
-    # Check that the instance call includes a requirement
-    assert_equal(1,chop_call.find_variable(chop_call.variable_id).length)
-    
-    # Check that they have the correct requirements in the context of the statement
-    # TODO  I think the whole Unknown class is redundent
-    assert_equal(2,first_statement.find_variable(chop_call.subject.variable_id).length)
-    
-    # Confirm the length of the variable hasn't changed
-    assert_equal(0,var1.length)
-    
-    # Create the second scope variable
-    var2 = Unknown.new()
-    assert_equal(0,var2.length)
-    assert_not_equal(var1.variable_id,var2.variable_id)
-    
-  end
-  
   # This test checks the the declared variable in the following statement
   #
   # varA = varB-varC