cauldron 0.1.0

data/test/unit/util/tc_string_to_theory.rb

@@ -0,0 +1,299 @@
+require 'required'
+require 'test/unit'
+
+
+class TestStringToTheory < Test::Unit::TestCase
+  
+  def setup
+    
+  end
+  
+  def teardown
+    System.reset
+    RuntimeMethod.reset_global_id
+  end  
+  
+  def test_run_1
+    assert(StringToTheory.run('var6 = 8').kind_of?(Statement))
+    assert_equal("#{TheoryVariable.variable_colour(4)}var4#{TheoryVariable::NORMAL} = 7",StringToTheory.run('var4 = 7').describe)
+    assert_equal(9,StringToTheory.run('var8 = 9')[2].value)
+    assert(StringToTheory.run('var8 = 9')[0].kind_of?(TheoryVariable))
+    assert_equal(8,StringToTheory.run('var8 = 9')[0].theory_variable_id)
+  end
+  
+  def test_run_2
+    assert_equal(
+      "#{TheoryVariable.variable_colour(5)}var5#{TheoryVariable::NORMAL} = 'enterprise'",
+      StringToTheory.run("var5 = 'enterprise'").describe
+    )
+    assert_equal(5,StringToTheory.run("var5 = 'enterprise'")[0].theory_variable_id)
+    assert_equal("'enterprise'",StringToTheory.run("var5 = 'enterprise'")[2].describe)
+    assert_equal(3,StringToTheory.run("var5 = 'enterprise'").length)
+  end
+  
+  def test_run_3
+    assert_raises(StandardError){StringToTheory.run("var4 = sadfasfdsa")}
+  end
+  
+  def test_run_4
+    assert_equal(
+      'runtime_method.params[0].length',
+      StringToTheory.run('runtime_method.params[0].length').write
+    )
+  end
+  
+  def test_run_instance_calls
+    assert_equal(
+      "#{TheoryVariable.variable_colour(8)}var8#{TheoryVariable::NORMAL} = #{TheoryVariable.variable_colour(6)}var9#{TheoryVariable::NORMAL}.chop",
+      StringToTheory.run("var8 = var9.chop").describe
+    )
+    assert_equal(
+      "#{TheoryVariable.variable_colour(8)}var8#{TheoryVariable::NORMAL} = #{TheoryVariable.variable_colour(9)}var9#{TheoryVariable::NORMAL}.length",
+      StringToTheory.run("var8 = var9.length").describe
+    )
+  end
+  
+  # NOTE  I need to create the theories like real statements since I'm 
+  #       using the Racc:Parser.
+  # 
+  def test_run_with_if_statement
+    assert_equal(
+      "#{TheoryVariable.variable_colour(6)}var6#{TheoryVariable::NORMAL}[7]",
+      StringToTheory.run("var6[7]").describe
+    )        
+    assert_equal(
+      "#{TheoryVariable.variable_colour(6)}var6#{TheoryVariable::NORMAL} == 7",
+      StringToTheory.run("var6 == 7").describe
+    )    
+    assert_equal(
+      "if(#{TheoryVariable.variable_colour(6)}var6#{TheoryVariable::NORMAL} == 7)\nend\n",
+      StringToTheory.run("if(var6 == 7)\nend").describe
+    )      
+    assert_equal(
+      "if(#{TheoryVariable.variable_colour(1)}var1#{TheoryVariable::NORMAL} == #{TheoryVariable.variable_colour(2)}var2#{TheoryVariable::NORMAL})\nend\n",
+      StringToTheory.run("if(var1 == var2)\nend").describe
+    )
+    assert_equal(
+      "if(#{TheoryVariable.variable_colour(1)}var1#{TheoryVariable::NORMAL}.length == #{TheoryVariable.variable_colour(2)}var2#{TheoryVariable::NORMAL}.length)\nend\n",
+      StringToTheory.run("if(var1.length == var2.length)\nend").describe
+    )
+    assert(StringToTheory.run("if(var1.length == var2.length)\nend\n").kind_of?(OpenStatement))
+  end
+  
+  def test_run_with_a_return
+    assert_equal(
+      "return #{TheoryVariable.variable_colour(8)}var8#{TheoryVariable::NORMAL}",
+      StringToTheory.run('return var8').describe
+    ) 
+    assert_equal(
+      'TheoryStatement',
+      StringToTheory.run('return var8').class.to_s
+    )
+  end
+  
+  def test_variable_assignment
+    # var1.length = var2.length
+    assert_equal(
+      "#{TheoryVariable.variable_colour(1)}var1#{TheoryVariable::NORMAL}.length = #{TheoryVariable.variable_colour(2)}var2#{TheoryVariable::NORMAL}.length",    
+      StringToTheory.run("var1.length = var2.length").describe
+    )
+  end
+  
+  def test_run_with_action_1
+    assert_equal(
+      "Statement.new(Return.new, #{TheoryVariable.variable_colour(1)}var1#{TheoryVariable::NORMAL}.params[0])",
+      StringToTheory.run('Statement.new(Return.new, var1.params[0])').describe
+    )
+  end
+  
+  def test_run_instance_declaration
+    assert_equal(
+      "Statement.new(Return.new, InstanceCallContainer.new(#{TheoryVariable.variable_colour(1)}var1#{TheoryVariable::NORMAL}.params[0], StringLength.new))",
+      StringToTheory.run('Statement.new(Return.new,InstanceCallContainer.new(var1.params[0], StringLength.new))').describe
+    )
+  end
+  
+  def test_run_with_a_addition_statement
+    assert_equal(
+      'Statement.new(Parser.run)',
+      StringToTheory.run('Statement.new(Parser.run)').write
+    )
+    assert_equal(
+      "Statement.new(Parser.run('var1 = var3'))",
+      StringToTheory.run('Statement.new(Parser.run("var1 = var3"))').write
+    )
+    assert_equal(
+      "Statement.new(Parser.run('var1 = var3 + var4'))",
+      StringToTheory.run("Statement.new(Parser.run(\"var1 = var3 + var4\"))").write
+    )    
+  end
+  
+  def test_run_with_inline_declarations
+    assert_equal(
+      "Parser.run('var = var1 + var2')",
+      StringToTheory.run('Parser.run("var = var1 + var2")').write
+    )
+    assert_equal(
+      true,
+      StringToTheory.run('Parser.run("var = var1 + var2")').kind_of?(ClassMethodCallContainer)
+    )
+    theory_statement = TheoryStatement.new(StringToTheory.run('Parser.run("var = var1 + var2")'))
+    #
+    # TODO  Currently this wouldn't be true because 'var = var1 + var2' is parsed as 
+    #       a single string.  I'm not sure I want to go down that road.
+    #assert_equal(2,theory_statement.select_all?({|x| x.kind_of?(TheoryVariable)})
+  end
+  
+  def test_run_with_addition_statement_declaration
+    assert_equal(    
+      "Statement.new(Unknown.new, Equal.new, #{TheoryVariable.variable_colour(4)}var4#{TheoryVariable::NORMAL}.params[0], Addition.new, #{TheoryVariable.variable_colour(4)}var4#{TheoryVariable::NORMAL}.params[1])",
+      StringToTheory.run('Statement.new(Unknown.new, Equal.new, var4.params[0], Addition.new, var4.params[1])').describe
+    )
+  end
+  
+  def test_run_with_kind_of_statement
+    assert_nothing_raised(){
+      StringToTheory.run("if(var1.kind_of?(RuntimeMethod))\nend")
+    }  
+    assert_equal(
+      "if(#{TheoryVariable.variable_colour(1)}var1#{TheoryVariable::NORMAL}.kind_of?(RuntimeMethod))\nend\n",
+      StringToTheory.run("if(var1.kind_of?(RuntimeMethod))\nend").describe
+    )
+    assert_nothing_raised(){
+      StringToTheory.run("if(var1.kind_of?(Fixnum))\nend")
+    }      
+  end
+  
+  def test_run_with_history_calls
+    # <history>.any? { |var1| var1.include? <statement>.id }
+    assert_nothing_raised(){ StringToTheory.run("var1.any? { |var3| var2.include? var3.statement_id }") }
+  end    
+  
+  def test_run_with_complex_block_statement
+    assert_nothing_raised() {
+      StringToTheory.run("var1.any? do |var3|\nvar2 = var1.chop\nend")
+    }
+    assert_equal(
+      "#{TheoryVariable.variable_colour(1)}var1#{TheoryVariable::NORMAL}.any?{ |#{TheoryVariable.variable_colour(3)}var3#{TheoryVariable::NORMAL}| #{TheoryVariable.variable_colour(2)}var2#{TheoryVariable::NORMAL} = #{TheoryVariable.variable_colour(1)}var1#{TheoryVariable::NORMAL}.chop} ",
+      StringToTheory.run("var1.any? do |var3|\nvar2 = var1.chop\nend").describe
+    )
+  end
+  
+  def test_run_with_kind_of_ctest_case
+    assert_nothing_raised(){
+      StringToTheory.run("var1.kind_of?(CTestCase)")
+    }
+    assert_equal(
+      "#{TheoryVariable.variable_colour(1)}var1#{TheoryVariable::NORMAL}.kind_of?(CTestCase)",
+      StringToTheory.run("var1.kind_of?(CTestCase)").describe
+    )    
+  end
+  
+  def test_statements_are_not_equal
+
+    assert_nothing_raised(){
+      StringToTheory.run("var1 != var2")
+    }    
+    
+    # e.g. <var2>[<var3>][:params][<var6>] != <var2>[<var4>][:params][<var6>]
+    assert_nothing_raised(){
+      StringToTheory.run("var2[var3][:params][var6] != var2[var4][:params][var6]")
+    }
+    assert_equal(
+      "#{TheoryVariable.variable_colour(2)}var2#{TheoryVariable::NORMAL}[#{TheoryVariable.variable_colour(3)}var3#{TheoryVariable::NORMAL}][:params][#{TheoryVariable.variable_colour(6)}var6#{TheoryVariable::NORMAL}] != #{TheoryVariable.variable_colour(2)}var2#{TheoryVariable::NORMAL}[#{TheoryVariable.variable_colour(4)}var4#{TheoryVariable::NORMAL}][:params][#{TheoryVariable.variable_colour(6)}var6#{TheoryVariable::NORMAL}]",      
+      StringToTheory.run("var2[var3][:params][var6] != var2[var4][:params][var6]").describe
+    )
+  end
+  
+  def test_not_pass
+#    assert_equal(
+#      "if(!var1.pass?(var2[var4]))\nend",
+
+      # TODO Doesn't appear to differentiate - is it a problem with the parser
+      # StringToTheory.run("if(!var1.pass?(var2[var4]))\nend").write
+      # StringToTheory.run("if(var1.pass?(var2[var4]))\nend").write
+    #)
+    assert_nothing_raised(){StringToTheory.run("if(var1.pass?(var2[var4])==false)\nend")}
+    assert_equal(
+      "if(var1.pass?(var2[var4]) == false)\nend",
+      StringToTheory.run("if(var1.pass?(var2[var4])==false)\nend").write
+    )
+             
+  end
+  
+  def test_double_negative
+    assert_equal(
+      "if((var2 == var3) == false)\n\treturn true\nend",
+      StringToTheory.run("if((var2 == var3)== false)\nreturn true\nend").write
+    ) 
+    assert_equal(
+     "if((var1.history(var2[var4][:params]).any?{ |x| x.statement_id == var8.statement_id} ) == false)\nend",
+     StringToTheory.run("if((var1.history(var2[var4][:params]).any?{ |x| x.statement_id == var8.statement_id})==false )\nend").write
+    ) 
+    assert_equal(
+      "if(var1.history(var2[var4][:params]).any?{ |x| x.statement_id != var8.statement_id} )\nend",
+      StringToTheory.run("if(var1.history(var2[var4][:params]).any? { |x| x.statement_id != var8.statement_id })\nend").write
+    )    
+  end
+    
+  def test_custom_statements_1
+    # e.g. <var9> == (<var5>[:params][<var6>].length+1)
+    assert_nothing_raised(){
+      StringToTheory.run("var9 == (var5[:params][var6].length+1)")
+    }
+    assert_nothing_raised(){
+      StringToTheory.run("if(var9 == (var5[:params][var6].length+1))\nend")
+    }    
+    assert_nothing_raised(){
+      StringToTheory.run("IfStatement.new(var2[var3][:params][var6],Equivalent.new,var2[var3][:output])")
+    }
+    assert_equal(
+      5,
+      StringToTheory.run("IfStatement.new(var2[var3][:params][var6],Equivalent.new,var2[var3][:output])").select_all {|x| x.kind_of?(ArrayAccess)}.length
+    )
+    # <var1>.history(<var2>[<var3>][:params]).any? { |x| x.statement_id == <var8>.statement_id }
+    assert_nothing_raised(){
+      StringToTheory.run("var1.history(var2[var3][:params]).any? { |x| x.statement_id == var8.statement_id }")
+    }
+    assert_nothing_raised(){
+      StringToTheory.run("if(var1.history(var2[var3][:params]).any? { |x| x.statement_id == var8.statement_id })\nend")
+    }    
+    # <var1>.history(<var2>[<var4>][:params]).any? { |x| x.statement_id != <var8>.statement_id }
+    assert_nothing_raised(){
+      StringToTheory.run("var1.history(var2[var4][:params]).any? { |x| x.statement_id != var8.statement_id }")
+    }
+    assert_nothing_raised(){
+      StringToTheory.run("if(var1.history(var2[var4][:params]).any? { |x| x.statement_id != var8.statement_id })\nend")
+    }     
+    assert_equal(
+      "if(var1.history(var2[var4][:params]).any?{ |x| x.statement_id != var8.statement_id} )\nend",
+      StringToTheory.run("if(var1.history(var2[var4][:params]).any? { |x| x.statement_id != var8.statement_id })\nend").write
+    )
+    assert_equal(
+      "if((var1.history(var2[var4][:params]).any?{ |x| x.statement_id == var8.statement_id} ) == false)\nend",
+      StringToTheory.run("if((var1.history(var2[var4][:params]).any?{ |x| x.statement_id == var8.statement_id})==false )\nend").write
+    )    
+    assert_equal(
+      "Statement.new(Return.new, var2[var3][:output])",
+      StringToTheory.run("Statement.new(Return.new,var2[var3][:output])").write
+    )
+    assert_equal(
+      "var1.pass?(var2[var3])",
+      StringToTheory.run("var1.pass?(var2[var3])").write
+    )
+    assert_not_equal(
+      "var1.pass?(var2[var3])",
+      StringToTheory.run("var1.pass?(var2[var4])").write
+    )
+    # The parser doesn't seem to support the ! syntax here
+    assert_not_equal(
+      "if(!var1.pass?(var2[var4]))\nend",
+      StringToTheory.run("if(!var1.pass?(var2[var4]))\nend").write
+    )    
+    assert_equal(
+        "if((var2[var3] == var2[var4]) == false)\n\treturn true\nend",
+        StringToTheory.run("if((var2[var3] == var2[var4])== false)\nreturn true\nend").write
+    )
+  end
+  
+end

data/test/unit/variable/tc_method_usage_variable.rb

@@ -0,0 +1,25 @@
+require 'required'
+require 'test/unit'
+
+class TestMethodUsageVariable < Test::Unit::TestCase
+  
+  def setup
+    @empty_method_usage = MethodUsage.new.to_var
+  end
+  
+  def teardown
+System.reset
+    RuntimeMethod.reset_global_id
+  end  
+
+  def test_to_declaration
+    assert(@empty_method_usage.to_declaration.kind_of?(VariableDeclaration))
+    assert_not_nil(@empty_method_usage.to_declaration.write,'Should write out command to create array variable')
+    assert_equal('MethodUsageVariable.new()',@empty_method_usage.to_declaration.write)
+  end
+  
+  def test_copy
+    assert_equal(@empty_method_usage.variable_id,@empty_method_usage.copy.variable_id)
+  end
+      
+end

data/tmp/runtime_method_evaluation.rb

@@ -0,0 +1,10 @@
+class RuntimeMethodEvaluation24
+
+	#
+	#	This is the method that is being evaluated using 'RuntimeMethodEvaluation24.new.method_1
+	#
+	def method_1(var_2)
+		return nil
+	end
+
+end

metadata

@@ -0,0 +1,522 @@
+--- !ruby/object:Gem::Specification 
+name: cauldron
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Warren Sangster
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-09 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  requirement: *id001
+  prerelease: false
+  name: shoulda
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 1
+        - 0
+        - 15
+        version: 1.0.15
+  type: :development
+  requirement: *id002
+  prerelease: false
+  name: bundler
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 1
+        - 6
+        - 2
+        version: 1.6.2
+  type: :development
+  requirement: *id003
+  prerelease: false
+  name: jeweler
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  requirement: *id004
+  prerelease: false
+  name: rcov
+description: Cauldron generates a methd from a number of examples that describe the input and the expected output.  It is still at a very early stage of development right now so you're unlikely to get much practical use out of it.
+email: warrensangster@yahoo.com
+executables: 
+- cauldron
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README
+- README.rdoc
+files: 
+- .document
+- Gemfile
+- LICENSE.txt
+- README
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/cauldron
+- cauldron/.autotest
+- cauldron/History.txt
+- cauldron/Manifest.txt
+- cauldron/README.txt
+- cauldron/Rakefile
+- cauldron/bin/cauldron
+- cauldron/lib/cauldron.rb
+- cauldron/test/test_cauldron.rb
+- features/cauldron_example_cases.feature
+- features/cauldron_generates_runtime_method.feature
+- features/cauldron_start_terminal.feature
+- features/step_definitions/cauldron_steps.rb
+- features/step_definitions/terminal_steps.rb
+- features/support/env.rb
+- lib/Chain.rb
+- lib/ChainMapping.rb
+- lib/CodeHandler.rb
+- lib/Mapping.rb
+- lib/MappingValues.rb
+- lib/ScopeDependencies.rb
+- lib/Theory.rb
+- lib/UnifiedChain.rb
+- lib/cauldron.rb
+- lib/cauldron/conversion.rb
+- lib/cauldron/pot.rb
+- lib/cauldron/sexp2cauldron.rb
+- lib/cauldron/terminal.rb
+- lib/cauldron/theory_factory.rb
+- lib/core/ActsAsCode.rb
+- lib/core/BlockToken.rb
+- lib/core/CCall.rb
+- lib/core/CTestCase.rb
+- lib/core/ClassMethodCallContainer.rb
+- lib/core/Container.rb
+- lib/core/InstanceCallContainer.rb
+- lib/core/MethodUsage.rb
+- lib/core/PrintVariables.rb
+- lib/core/TheoryGenerator.rb
+- lib/core/Token.rb
+- lib/core/assignment/Assignment.rb
+- lib/core/assignment/Equal.rb
+- lib/core/assignment/Equivalent.rb
+- lib/core/assignment/NotEqual.rb
+- lib/core/call_container/CallContainer.rb
+- lib/core/class_method_call/New.rb
+- lib/core/class_method_call/RuntimeClassMethodCall.rb
+- lib/core/declaration/Declaration.rb
+- lib/core/declaration/LiteralDeclaration.rb
+- lib/core/declaration/VariableDeclaration.rb
+- lib/core/instance_call/ArrayEach.rb
+- lib/core/instance_call/ArrayLength.rb
+- lib/core/instance_call/Chop.rb
+- lib/core/instance_call/Copy.rb
+- lib/core/instance_call/DeclaredVariable.rb
+- lib/core/instance_call/InstanceCall.rb
+- lib/core/instance_call/Params.rb
+- lib/core/instance_call/Push.rb
+- lib/core/instance_call/StringLength.rb
+- lib/core/instance_call/Times.rb
+- lib/core/instance_call/instance_calls.rb
+- lib/core/instance_call/length_equal.rb
+- lib/core/kernal/EvalCall.rb
+- lib/core/kernal/LocalVariablesCall.rb
+- lib/core/literal/Literal.rb
+- lib/core/literal/Raw.rb
+- lib/core/literal/RuntimeMethodLiteral.rb
+- lib/core/literal/StatementLiteral.rb
+- lib/core/method_call/AvailableVariablesCall.rb
+- lib/core/method_call/ClassCall.rb
+- lib/core/method_call/DefCall.rb
+- lib/core/method_call/EvaluateClassCall.rb
+- lib/core/method_call/MethodNameCall.rb
+- lib/core/method_call/ToDeclarationCall.rb
+- lib/core/requirement/Requirement.rb
+- lib/core/runtime_class/ArrayClass.rb
+- lib/core/runtime_class/ClassCallClass.rb
+- lib/core/runtime_class/ClassEvaluationClass.rb
+- lib/core/runtime_class/ClassName.rb
+- lib/core/runtime_class/DefCallClass.rb
+- lib/core/runtime_class/EqualClass.rb
+- lib/core/runtime_class/FixnumClass.rb
+- lib/core/runtime_class/IfStatementClass.rb
+- lib/core/runtime_class/InstanceCallClass.rb
+- lib/core/runtime_class/InstanceCallContainerClass.rb
+- lib/core/runtime_class/InstanceClassCallClass.rb
+- lib/core/runtime_class/LiteralClass.rb
+- lib/core/runtime_class/MethodParameterClass.rb
+- lib/core/runtime_class/MethodUsageClass.rb
+- lib/core/runtime_class/RequirementClass.rb
+- lib/core/runtime_class/ReturnClass.rb
+- lib/core/runtime_class/RuntimeClass.rb
+- lib/core/runtime_class/RuntimeClassClass.rb
+- lib/core/runtime_class/RuntimeMethodClass.rb
+- lib/core/runtime_class/StatementClass.rb
+- lib/core/runtime_class/StringClass.rb
+- lib/core/runtime_class/StringLengthClass.rb
+- lib/core/runtime_class/StringVariableClass.rb
+- lib/core/runtime_class/ThisClass.rb
+- lib/core/runtime_class/UnknownClass.rb
+- lib/core/runtime_class/class_names.rb
+- lib/core/runtime_class/runtime_class.rb
+- lib/core/runtime_method/ActsAsRuntimeMethod.rb
+- lib/core/runtime_method/ParametersContainer.rb
+- lib/core/runtime_method/RealisedRuntimeMethod.rb
+- lib/core/runtime_method/RuntimeMethod.rb
+- lib/core/runtime_method/WriteParameters.rb
+- lib/core/statement/ActsAsStatement.rb
+- lib/core/statement/ArrayAccess.rb
+- lib/core/statement/BlockStatement.rb
+- lib/core/statement/DeclarationStatement.rb
+- lib/core/statement/HackStatement.rb
+- lib/core/statement/HashAccess.rb
+- lib/core/statement/OpenStatement.rb
+- lib/core/statement/RealisedStatement.rb
+- lib/core/statement/SingleLineBlockStatement.rb
+- lib/core/statement/Statement.rb
+- lib/core/statement/StatementDependencies.rb
+- lib/core/statement/StatementGroup.rb
+- lib/core/statement/StatementStructure2.rb
+- lib/core/statement/TheoryStatement.rb
+- lib/core/statement/TopologicalStatements.rb
+- lib/core/structure/DeclareNewInstanceStructure.rb
+- lib/core/structure/DeclareRuntimeMethodStructure.rb
+- lib/core/structure/DeclareVariableAsLiteralStructure.rb
+- lib/core/structure/DeclareVariableAsVariableStructure.rb
+- lib/core/structure/FixnumAdditionStructure.rb
+- lib/core/structure/InstanceCallContainerStructure.rb
+- lib/core/structure/InstanceCallStructure.rb
+- lib/core/structure/InstanceMethodCallStructure.rb
+- lib/core/structure/ReturnStructure.rb
+- lib/core/structure/StatementStructure.rb
+- lib/core/syntax/Addition.rb
+- lib/core/syntax/BlockContainer.rb
+- lib/core/syntax/Boolean.rb
+- lib/core/syntax/Code.rb
+- lib/core/syntax/Do.rb
+- lib/core/syntax/False.rb
+- lib/core/syntax/If.rb
+- lib/core/syntax/IfContainer.rb
+- lib/core/syntax/Nil.rb
+- lib/core/syntax/Return.rb
+- lib/core/syntax/Subtract.rb
+- lib/core/syntax/This.rb
+- lib/core/syntax/True.rb
+- lib/core/syntax/syntax.rb
+- lib/core/tracking/ActsAsTrackable.rb
+- lib/core/tracking/History.rb
+- lib/core/tracking/RuntimeTrackingMethod.rb
+- lib/core/tracking/Step.rb
+- lib/core/variable/ArrayVariable.rb
+- lib/core/variable/BaseVariable.rb
+- lib/core/variable/BlockVariable.rb
+- lib/core/variable/FixnumVariable.rb
+- lib/core/variable/HistoryVariable.rb
+- lib/core/variable/MethodParameter.rb
+- lib/core/variable/MethodUsageVariable.rb
+- lib/core/variable/NilVariable.rb
+- lib/core/variable/RuntimeMethodParameter.rb
+- lib/core/variable/StatementVariable.rb
+- lib/core/variable/StepVariable.rb
+- lib/core/variable/StringVariable.rb
+- lib/core/variable/TypeVariable.rb
+- lib/core/variable/Unknown.rb
+- lib/core/variable/UnknownVariable.rb
+- lib/core/variable/Variable.rb
+- lib/core/variable/VariableContainer.rb
+- lib/core/variable/VariableIncluded.rb
+- lib/core/variable/VariableReference.rb
+- lib/error/FailedToFindStatementContainerError.rb
+- lib/error/FailedToFindStatementError.rb
+- lib/error/FailedToFindVariableError.rb
+- lib/error/FailedToLiteraliseError.rb
+- lib/error/FailedVariableMatch.rb
+- lib/error/ImproperStatementUsageError.rb
+- lib/error/IncompatiableRequirementsError.rb
+- lib/error/InvalidStatementError.rb
+- lib/error/MethodSizeError.rb
+- lib/error/RuntimeSyntaxError.rb
+- lib/error/UnexpectedStatementTypeError.rb
+- lib/error/UnknownStatementType.rb
+- lib/error/UnliteralisableError.rb
+- lib/implemented_chain.rb
+- lib/intrinsic/IntrinsicLastRuntimeMethod.rb
+- lib/intrinsic/IntrinsicLiteral.rb
+- lib/intrinsic/IntrinsicObject.rb
+- lib/intrinsic/IntrinsicRuntimeMethod.rb
+- lib/intrinsic/IntrinsicTestCases.rb
+- lib/logger/StandardLogger.rb
+- lib/required.rb
+- lib/ruby_code/Array.rb
+- lib/ruby_code/Fixnum.rb
+- lib/ruby_code/Hash.rb
+- lib/ruby_code/NilClass.rb
+- lib/ruby_code/Object.rb
+- lib/ruby_code/String.rb
+- lib/ruby_code/Symbol.rb
+- lib/standard_library/Tasks.rb
+- lib/theories.rb
+- lib/theory/ActionImplementation.rb
+- lib/theory/TheoryAction.rb
+- lib/theory/TheoryChainValidator.rb
+- lib/theory/TheoryComponent.rb
+- lib/theory/TheoryConnector.rb
+- lib/theory/TheoryDependent.rb
+- lib/theory/TheoryImplementation.rb
+- lib/theory/TheoryResult.rb
+- lib/theory/TheoryVariable.rb
+- lib/theory/theory_collection.rb
+- lib/util/ClassEvaluation.rb
+- lib/util/CodeEvaluation.rb
+- lib/util/DeclarationStatementEvaluation.rb
+- lib/util/MethodEvaluation.rb
+- lib/util/MethodTester.rb
+- lib/util/MethodValidation.rb
+- lib/util/MethodWriter.rb
+- lib/util/Parser.rb
+- lib/util/StatementCheck.rb
+- lib/util/StringToTheory.rb
+- lib/util/System.rb
+- spec/cauldron/pot_spec.rb
+- spec/cauldron/runtime_method_spec.rb
+- spec/cauldron/sexp_2_cauldron_spec.rb
+- spec/cauldron/terminal_spec.rb
+- spec/cauldron/theory_action_spec.rb
+- spec/spec_helper.rb
+- test/fixtures/chains/1/declaration.txt
+- test/fixtures/chains/1/dump
+- test/fixtures/chains/2/declaration.txt
+- test/fixtures/chains/2/dump
+- test/fixtures/chains/3/declaration.txt
+- test/fixtures/chains/3/dump
+- test/fixtures/implementation_results/0/declaration.txt
+- test/fixtures/implementation_results/0/dump
+- test/fixtures/theories/0/declaration.txt
+- test/fixtures/theories/0/desc
+- test/fixtures/theories/0/dump
+- test/fixtures/theories/1/declaration.txt
+- test/fixtures/theories/1/desc
+- test/fixtures/theories/1/dump
+- test/fixtures/theories/10/declaration.txt
+- test/fixtures/theories/10/desc
+- test/fixtures/theories/10/dump
+- test/fixtures/theories/11/declaration.txt
+- test/fixtures/theories/11/desc
+- test/fixtures/theories/11/dump
+- test/fixtures/theories/12/declaration.txt
+- test/fixtures/theories/12/desc
+- test/fixtures/theories/12/dump
+- test/fixtures/theories/13/declaration.txt
+- test/fixtures/theories/13/desc
+- test/fixtures/theories/13/dump
+- test/fixtures/theories/14/declaration.txt
+- test/fixtures/theories/14/desc
+- test/fixtures/theories/14/dump
+- test/fixtures/theories/15/declaration.txt
+- test/fixtures/theories/15/desc
+- test/fixtures/theories/15/dump
+- test/fixtures/theories/16/declaration.txt
+- test/fixtures/theories/16/desc
+- test/fixtures/theories/16/dump
+- test/fixtures/theories/17/declaration.txt
+- test/fixtures/theories/17/desc
+- test/fixtures/theories/17/dump
+- test/fixtures/theories/18/declaration.txt
+- test/fixtures/theories/18/desc
+- test/fixtures/theories/18/dump
+- test/fixtures/theories/19/declaration.txt
+- test/fixtures/theories/19/desc
+- test/fixtures/theories/19/dump
+- test/fixtures/theories/2/declaration.txt
+- test/fixtures/theories/2/desc
+- test/fixtures/theories/2/dump
+- test/fixtures/theories/20/declaration.txt
+- test/fixtures/theories/20/desc
+- test/fixtures/theories/20/dump
+- test/fixtures/theories/3/declaration.txt
+- test/fixtures/theories/3/desc
+- test/fixtures/theories/3/dump
+- test/fixtures/theories/4/declaration.txt
+- test/fixtures/theories/4/desc
+- test/fixtures/theories/4/dump
+- test/fixtures/theories/5/declaration.txt
+- test/fixtures/theories/5/desc
+- test/fixtures/theories/5/dump
+- test/fixtures/theories/6/declaration.txt
+- test/fixtures/theories/6/desc
+- test/fixtures/theories/6/dump
+- test/fixtures/theories/7/declaration.txt
+- test/fixtures/theories/7/desc
+- test/fixtures/theories/7/dump
+- test/fixtures/theories/8/declaration.txt
+- test/fixtures/theories/8/desc
+- test/fixtures/theories/8/dump
+- test/fixtures/theories/9/declaration.txt
+- test/fixtures/theories/9/desc
+- test/fixtures/theories/9/dump
+- test/fixtures/theory_implementations/0/declaration.txt
+- test/fixtures/theory_implementations/0/desc.txt
+- test/fixtures/theory_implementations/0/dump
+- test/fixtures/theory_implementations/0/theory_id
+- test/fixtures/theory_implementations/1/desc.txt
+- test/fixtures/theory_implementations/1/dump
+- test/fixtures/theory_implementations/1/theory_id
+- test/fixtures/theory_implementations/2/desc.txt
+- test/fixtures/theory_implementations/2/dump
+- test/fixtures/theory_implementations/2/theory_id
+- test/output/simple_method.txt
+- test/output/test_method/first_possible_method.txt
+- test/output/test_simple_cases/simple_case_01.txt
+- test/output/test_simple_cases/simple_case_02.txt
+- test/output/test_simple_cases/simple_case_03.txt
+- test/output/test_simple_cases/simple_case_04.txt
+- test/output/test_simple_cases/simple_case_05.txt
+- test/output/test_simple_cases/simple_case_06.txt
+- test/output/test_simple_cases/simple_case_07.txt
+- test/output/test_simple_cases/simple_case_08.txt
+- test/tc_contextual_variables.rb
+- test/tc_describe.rb
+- test/tc_method.rb
+- test/tc_requirement.rb
+- test/tc_suite_complete.rb
+- test/tc_variable.rb
+- test/ts_complete.rb
+- test/ts_stable.rb
+- test/unit/core/declaration/tc_literal_declaration.rb
+- test/unit/core/method_call/tc_class_call.rb
+- test/unit/core/runtime_method/tc_realised_runtime_method.rb
+- test/unit/core/runtime_method/tc_runtime_method.rb
+- test/unit/core/statement/tc_array_access.rb
+- test/unit/core/statement/tc_block_statement.rb
+- test/unit/core/statement/tc_hack_statement.rb
+- test/unit/core/statement/tc_open_statement.rb
+- test/unit/core/statement/tc_statement.rb
+- test/unit/core/statement/tc_statement_dependencies.rb
+- test/unit/core/statement/tc_statement_group.rb
+- test/unit/core/statement/tc_statement_replace_variable.rb
+- test/unit/core/statement/tc_theory_statement.rb
+- test/unit/core/structure/tc_declare_new_instance_structure.rb
+- test/unit/core/structure/tc_declare_variable_as_literal_structure.rb
+- test/unit/core/structure/tc_declare_variable_as_variable_structure.rb
+- test/unit/core/structure/tc_instance_call_container_structure.rb
+- test/unit/core/structure/tc_return_structure.rb
+- test/unit/core/syntax/tc_block_container.rb
+- test/unit/core/syntax/tc_if_container.rb
+- test/unit/core/tc_class_method_call.rb
+- test/unit/core/tc_container.rb
+- test/unit/core/tc_ctest_case.rb
+- test/unit/core/tc_instance_call_container.rb
+- test/unit/core/tc_literal.rb
+- test/unit/core/tc_theory_generator.rb
+- test/unit/core/tc_theory_generator_heavy.rb
+- test/unit/core/tracking/tc_history.rb
+- test/unit/core/tracking/tc_step.rb
+- test/unit/core/variable/tc_array_variable.rb
+- test/unit/core/variable/tc_block_variable.rb
+- test/unit/core/variable/tc_fixnum_variable.rb
+- test/unit/core/variable/tc_method_parameter_variable.rb
+- test/unit/core/variable/tc_runtime_method_variable.rb
+- test/unit/core/variable/tc_string_variable.rb
+- test/unit/core/variable/tc_unknown.rb
+- test/unit/core/variable/tc_variable_reference.rb
+- test/unit/ruby_code/tc_array.rb
+- test/unit/ruby_code/tc_fixnum.rb
+- test/unit/ruby_code/tc_hash.rb
+- test/unit/ruby_code/tc_string.rb
+- test/unit/tc_chain.rb
+- test/unit/tc_chain_mapping.rb
+- test/unit/tc_chain_with_case_1.rb
+- test/unit/tc_instance_call.rb
+- test/unit/tc_instance_call_structure.rb
+- test/unit/tc_method_usage.rb
+- test/unit/tc_pot.rb
+- test/unit/tc_runtime_tracking_method.rb
+- test/unit/tc_statement_structure_2.rb
+- test/unit/tc_theory.rb
+- test/unit/tc_variable_declaration.rb
+- test/unit/theory/tc_theory_action.rb
+- test/unit/theory/tc_theory_action_implementation.rb
+- test/unit/theory/tc_theory_chain_validator.rb
+- test/unit/theory/tc_theory_connector.rb
+- test/unit/theory/tc_theory_dependent.rb
+- test/unit/theory/tc_theory_implementation.rb
+- test/unit/theory/tc_theory_result.rb
+- test/unit/theory/tc_theory_variable.rb
+- test/unit/util/tc_method_validation.rb
+- test/unit/util/tc_parser.rb
+- test/unit/util/tc_string_to_theory.rb
+- test/unit/variable/tc_method_usage_variable.rb
+- tmp/runtime_method_evaluation.rb
+homepage: http://github.com/theinbetweens/cauldron
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: Generate simple ruby methods from the input(s) and expected output
+test_files: []
+