cauldron 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.15"
+  gem "jeweler", "~> 1.6.2"
+  gem "rcov", ">= 0"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 theinbetweens
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1 @@
+#	Comming soon

data/README.rdoc

@@ -0,0 +1,19 @@
+= cauldron
+
+Description goes here.
+
+== Contributing to cauldron
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 theinbetweens. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "cauldron"
+  gem.homepage = "http://github.com/theinbetweens/cauldron"
+  gem.license = "MIT"
+  gem.summary = %Q{Generate simple ruby methods from the input(s) and expected output}
+  gem.description = %Q{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.}
+  gem.email = "warrensangster@yahoo.com"
+  gem.authors = ["Warren Sangster"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+  test.rcov_opts << '--exclude "gems/*"'
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "cauldron #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/cauldron

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('../../lib',__FILE__)
+
+require 'cauldron'
+
+StandardLogger.instance.level = Logger::FATAL
+
+cauldron = Cauldron::Terminal.new(STDOUT,false)
+cauldron.start

data/cauldron/.autotest

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/cauldron/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2011-06-08
+
+* 1 major enhancement
+
+  * Birthday!
+

data/cauldron/Manifest.txt

@@ -0,0 +1,8 @@
+.autotest
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/cauldron
+lib/cauldron.rb
+test/test_cauldron.rb

data/cauldron/README.txt

@@ -0,0 +1,57 @@
+= cauldron
+
+* FIX (url)
+
+== DESCRIPTION:
+
+FIX (describe your package)
+
+== FEATURES/PROBLEMS:
+
+* FIX (list of features or problems)
+
+== SYNOPSIS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* FIX (list of requirements)
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== DEVELOPERS:
+
+After checking out the source, run:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2011 FIX
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/cauldron/Rakefile

@@ -0,0 +1,27 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+# Hoe.plugin :compiler
+# Hoe.plugin :compiler
+# Hoe.plugin :gem_prelude_sucks
+# Hoe.plugin :gem_prelude_sucks
+# Hoe.plugin :inline
+# Hoe.plugin :inline
+# Hoe.plugin :racc
+# Hoe.plugin :racc
+# Hoe.plugin :rubyforge
+# Hoe.plugin :rubyforge
+
+Hoe.spec 'cauldron' do
+  # HEY! If you fill these out in ~/.hoe_template/Rakefile.erb then
+  # you'll never have to touch them again!
+  # (delete this comment too, of course)
+
+  # developer('FIX', 'FIX@example.com')
+
+  # self.rubyforge_name = 'cauldronx' # if different than 'cauldron'
+end
+
+# vim: syntax=ruby

data/cauldron/bin/cauldron

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+abort "you need to write me"

data/cauldron/lib/cauldron.rb

@@ -0,0 +1,3 @@
+class Cauldron
+  VERSION = '1.0.0'
+end

data/cauldron/test/test_cauldron.rb

@@ -0,0 +1,8 @@
+require "test/unit"
+require "cauldron"
+
+class TestCauldron < Test::Unit::TestCase
+  def test_sanity
+    flunk "write tests or I will kneecap you"
+  end
+end

data/features/cauldron_example_cases.feature

@@ -0,0 +1,13 @@
+Feature: User enters example cases
+	The user enters a number of example cases that get saved to be ran later
+
+	Scenario Outline: add test cases
+		Given that the terminal has been started
+		When I add the case "<case>"
+		Then the case "<case>" should be saved 
+		
+		Scenarios: single paramerter cases
+			| 					case 						|
+			| 'sparky', 'spark'					|
+			| 'kel', 'kel'					 		|
+			

data/features/cauldron_generates_runtime_method.feature

@@ -0,0 +1,12 @@
+Feature: Cauldron generates a runtime method
+	I want a runtime method
+	That will solve a set of example cases
+
+	Scenario Outline: Generate a solution to a previously solved problem
+		Given that the terminal has been created 
+		When I add these <cases>
+		Then I should receive a runtime method like this <runtime_method>
+
+		Scenarios: example with only one parameter
+			|      cases   	   	   				         	|     							runtime_method   						|		demo_num  |
+			|  "'sparky','sparky'*'kel','kel'"      | "def method_3(var_6)\n\treturn var_6\nend\n"  |     1       |

data/features/cauldron_start_terminal.feature

@@ -0,0 +1,13 @@
+Feature: Cauldron starts on the command line
+	I want cauldron to start 
+	So that I can describe the method I want it generate
+	Scenario: start cauldron
+		When I start cauldron
+		Then I should see "Thanks for trying Cauldron - it's at really early stage right now"
+		And then I should see "To start enter your first test like this"
+		And then I should see "input,input,output"
+		And then I should see "For example "
+		And then I should see "'fish','animal'"
+		And then I should see "'cat','animal'"
+		And then I should see "'carrot','vegtable'"
+		And then I should see "and when you're done just type RUN"

data/features/step_definitions/cauldron_steps.rb

@@ -0,0 +1,16 @@
+
+When /^I add these "([^"]*)"$/ do |test_cases_statement|
+  test_cases = test_cases_statement.split('*')
+  test_cases.each do |x|
+    @terminal.submit x 
+  end
+end
+
+Then /^I should receive a runtime method like this "([^"]*)"$/ do |runtime_method_statement|
+  runtime_method_statement = runtime_method_statement.gsub('\\n',"\n").gsub('\\t',"\t")
+  #@terminal.submit('RUN').should == runtime_method_statement
+  @terminal.submit('RUN')
+  output.messages.should include(runtime_method_statement)
+end
+
+

data/features/step_definitions/terminal_steps.rb

@@ -0,0 +1,34 @@
+
+include Cauldron::Conversion
+
+Given /^that the terminal has been created$/ do
+  @terminal = Cauldron::Terminal.new(output)
+  @terminal.start
+end
+
+
+When /^I start cauldron$/ do
+  @terminal = Cauldron::Terminal.new(output)
+  @terminal.start
+end
+
+Then /^I should see "([^"]*)"$/ do |message|
+   output.messages.should include(message)
+end
+
+Then /^then I should see "([^"]*)"$/ do |message|
+  output.messages.should include(message)
+end
+
+When /^I add the case "([^"]*)"$/ do |test_case|
+  @terminal.submit test_case  
+end
+
+Given /^that the terminal has been started$/ do
+  @terminal = Cauldron::Terminal.new(output)
+  @terminal.start  
+end
+
+Then /^the case "([^"]*)" should be saved$/ do |test_case|
+  @terminal.cases.should include(convert_to_example(separate_values(test_case)))      
+end

data/features/support/env.rb

@@ -0,0 +1,19 @@
+$LOAD_PATH << File.expand_path('../../../lib',__FILE__)
+
+require 'cauldron'
+
+class Output
+  
+  def messages
+    @messages ||= []
+  end
+  
+  def puts(message)
+    messages << message
+  end
+  
+end
+
+def output
+  @output ||= Output.new
+end

data/lib/Chain.rb

@@ -0,0 +1,879 @@
+require "logger"
+class Chain
+  # TODO  This access is proably temporary
+  attr_reader :chain_mapping
+
+  # 
+  # @param  nodes     An array of theories in order
+  # 
+  def initialize()
+    @values, @nodes = {}, [] 
+    
+    # Create an array of possible ids for any theories added
+    @uniq_theory_instance_ids = ('A'...'Z').to_a 
+    
+    # Create a result version of 'finish'
+    finish = Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend")
+    tail_theory = finish.write
+    tail_theory.gsub!('runtime_method','var1')
+    tail_theory.gsub!('test_cases','var2')
+    tail_dependent = TheoryDependent.new(StringToTheory.run(tail_theory))
+    # TODO  Drop @tail_theory as a instance variable
+    @tail_theory = Theory.new([tail_dependent],nil,[])
+    
+    # NOTE: Now the head and tail are using the same ids for their variables
+    @chain_mapping = ChainMapping.new()
+    
+    # Get the value mappings for the chain
+    tc = Parser.run('test_cases')
+    real_method = Parser.run('runtime_method')
+    
+    # Add the tail to the nodes list
+    add_link(@tail_theory,{1=>real_method,2=>tc})
+    
+  end
+  
+  # TODO  I want to drop allot of these quick methods
+  def <<(node)
+    @nodes << node
+  end
+  
+  def length
+    return @nodes.length
+  end
+  
+  def each(&block)
+    @nodes.each(&block)
+  end
+  
+  def [](index)
+    return @nodes[index]
+  end
+
+  def first
+    return @nodes.first
+  end
+  
+  def last
+    return @nodes.last
+  end  
+  
+  def reverse
+    return Chain.new(@nodes.reverse)
+  end
+  
+  def shift
+    return @nodes.shift
+  end
+  
+  def copy
+    #return Chain.new(@nodes.copy)
+    return Marshal.load(Marshal.dump(self))
+  end
+  
+  def empty?
+    return @nodes.empty?
+  end
+  
+  def pop
+    return @nodes.pop
+  end
+  
+  def collect(&block)
+    return @nodes.collect(&block) 
+  end
+  
+  def write(tab=0)
+    return @nodes.inject('') {|total,x| total += x.write}
+  end
+  
+  def describe(tab=0)
+    return @nodes.inject('') {|total,x| total += x.describe}
+  end
+  
+  # Returns an array of all the unique theory variables used within
+  # the chain.
+  #
+  # e.g. [0,6,7] 
+  # 
+  def uniq_theory_variable_ids
+    return @nodes.inject([]) do |total,theory| 
+      total = total | theory.all_theory_variables.collect {|x| x.theory_variable_id}
+    end
+  end
+  
+  # Returns a new chain where they are all using the same respective theory
+  # variables.
+  #
+  # TODO  This seems to create implemented theories - I'm not sure this is what I want
+  #
+  def unify_chain
+    unless complete?
+      raise StandardError.new('Only complete chains can be unified')
+    end
+    unified_theories = @nodes.inject([]) do |total,theory|
+      mapping = generate_theory_mapping(theory.theory_instance_id)
+      total.push theory.map_to(mapping)
+    end
+    return UnifiedChain.new(unified_theories)
+  end
+  
+  # DEVELOPMENT
+  # Because I'm using Marshal to restore some of the theories I just need to check that 
+  # none of the components have duplicate ids.
+  #
+  def duplicate_component_ids?
+    collection = TheoryCollection.new(@nodes)
+    component_ids = collection.components.inject([]) {|total,x| total << x.theory_component_id }
+    return (component_ids.length != component_ids.uniq.length)
+  end
+  
+  # Returns the number of breaks in the chain - this is essential the number of
+  # unmet depements.
+  #
+  def broken_link_count
+    collection = TheoryCollection.new(@nodes)
+    return collection.dependents.inject(0) do |total,dependent| 
+      unless @chain_mapping.connected_component_ids.include?(dependent.theory_component_id)
+        total += 1
+      end
+      total
+    end      
+  end
+  
+  # TODO  Really need a method to highlight what is connected to what
+  
+  # DEVELOPMENT
+  # Writes out the chain but highlights any of links in the chain weren't connected 
+  # to a dependent.
+  # 
+  def highlight_broken_links
+    if duplicate_component_ids?
+      StandardLogger.instance.warning('You are using theories that share the same component_id')
+    end
+    unmet = []
+    each_unmet(:dependents,0,@nodes) do |index,theory,dependent|
+      unmet << dependent.theory_component_id  
+    end
+    return @nodes.inject('') {|msg,x| msg += x.highlight(unmet)}
+  end
+  
+  # Attempts to add a new link to form a complete chain between the head and tail.  It starts
+  # by linking to the tail and then head.
+  #
+  # TODO  This needs to return an array of chains indicating the various permutation they 
+  #       could be connected.
+  #
+  # TODO  link_permutations mighht be a more appropriate name
+  #
+  def add_link(theory,value_mapping=nil)
+    
+    # Give the theory an instance id
+    theory = theory.copy
+    raise StandardError.new('Reached limit to chains length') if @uniq_theory_instance_ids.empty?
+    theory.theory_instance_id = @uniq_theory_instance_ids.shift
+    
+    # Save the values for use later during the global mapping 
+    @values[theory.theory_instance_id] = value_mapping
+    
+    # The first link added should be the tail
+    if @nodes.empty?
+      add_tail(theory,value_mapping)
+      return
+    end
+    
+    # The second link should be the head  
+    # (this doesn't necessarily need to be be case but I'll keep this convention
+    if @nodes.length == 1 
+      return add_link_to(theory,0,value_mapping)
+    end
+    
+    # Attempt to add a link to all the possible locations (head and tail are exempt)
+    extended_chains = []
+    (1...@nodes.length).each do |position|
+      res = self.copy.add_link_to(theory,position,value_mapping)
+      extended_chains += res
+    end
+    return extended_chains
+    
+  end
+  
+  # Returns true if the chain can be connected from the head to the tail.
+  # 
+  def complete?
+    
+    # Check that all the variables in all the theories have been globally mapped, as well as the head
+    @nodes.each do |theory|
+      # Find the global variable for each of the theory variables
+      theory.all_theory_variables.each do |theory_variable|
+        begin
+          to_global_id(@chain_mapping,theory.theory_instance_id,theory_variable.theory_variable_id)
+        rescue StandardError => e   
+          StandardLogger.instance.error(e)       
+          return false
+        end
+      end
+    end
+    return dependents_met?
+    
+  end
+  
+  # This uses the supplied theories and checks whether the dependents
+  # of any of theories that might be used are reachable. 
+  #
+  # NOTE: This is only a rough assessment of whether the dependents are available
+  #       it doesn't mean that it is solvable but does identify that it definitely
+  #       isn't.
+  #
+  def solvable?(finish,theories)
+    
+    # Get the finish and check all the dependents can be met by the theories
+    all_results = theories.inject([]) {|total,x| total += x.results}
+    return false unless all_results.any? {|x| x.same_structure?(finish)}
+    
+    # Find the theories that can solve the problem and check their dependents can be met
+    # TODO  Should probably include the head theory in here too.
+    collection = TheoryCollection.new(theories.copy)
+    finishing_theories = []
+    collection.each_with_result_structure(finish) do |t,r|
+      finishing_theories.push(t) 
+    end
+    
+    finishing_theories.each do |x|
+    end
+    res = finishing_theories.any? do |x|
+      dependency_tree_met?(x,theories+[self.first.copy])
+    end
+    return res
+  end  
+  
+  # Implements a new the chain where all the theories are implemented.  It can 
+  # only be implemented if the chain is complete e.g. all the dependents and results
+  # are matched up.
+  #
+  def implement
+    raise StandardError.new('This chain is not complete') unless complete?
+
+    # Generate a global value mapping - so global id to real value
+    unifyied_chain = unify_chain
+
+    return unifyied_chain.implement(intrinsic_mapping)
+    
+  end  
+  
+  #  Returns an array of implemented theories that have variable syntax that can
+  #  be mapped to literal syntax(runtime_method,0,...) and also contain
+  #  real values for each of the variables.  So the runtime method will 
+  #  include all statements added to it. 
+  #
+  def each_theory_progression(initial_runtime_method,test_cases)
+    raise StandardError.new('Only complete theories can be watched') unless self.implementable?
+    
+    theories = []
+    previous_runtime_method = initial_runtime_method.copy
+    chain_validator = TheoryChainValidator.new
+    progressive_chain do |chain,theory|
+      initial_runtime_method.copy
+      runtime_method = chain_validator.build_method_from_chain( chain.implement,
+                                                                initial_runtime_method.copy,
+                                                                test_cases)
+      
+      # Create the intrinsic mapping for the theory
+      unified_chain = chain.unify_chain
+      
+      # * Go through each variable and find the intrinsic value
+      theory_intrinsic_mapping = Mapping.new
+      values = {:before=>{},:after=>{}}
+      unified_chain.theory_variables.each do |var|
+        intrinsic_value = global_id_intrinsic_value(var.theory_variable_id)
+        theory_intrinsic_mapping[var.theory_variable_id] = intrinsic_value        
+        
+        # Add the actual varlue of the intrinsic value
+        if intrinsic_value.kind_of?(IntrinsicRuntimeMethod)
+          values[:before][var.theory_variable_id] = previous_runtime_method.copy
+          values[:after][var.theory_variable_id] = previous_runtime_method.copy
+          next
+        end
+        if intrinsic_value.kind_of?(IntrinsicTestCases)
+          values[:before][var.theory_variable_id] = test_cases.copy
+          values[:after][var.theory_variable_id] = test_cases.copy
+          next
+        else
+          values[:before][var.theory_variable_id] = intrinsic_value.literal
+          values[:after][var.theory_variable_id] = intrinsic_value.literal
+        end
+      end
+
+      # Generate a unified version of the theory
+      mapping = generate_theory_mapping(theory.theory_instance_id)
+      unified_theory = theory.map_to(mapping)
+            
+      yield theory.map_to(theory_intrinsic_mapping,values), unified_theory
+      
+      # Save the previous method for the dependents
+      previous_runtime_method = runtime_method
+      
+    end
+    return theories
+    
+  end  
+  
+  # Return true if the chain can be implemented - so all the theories have literal values
+  # associated with them.  This could be directly via when the theory was added to the 
+  # chain or indirectly via connecting two theories.
+  #
+  def implementable?
+    self.implement
+    return true
+  rescue StandardError => e
+    StandardLogger.instance.info e 
+    return false
+  end
+  
+  # Returns an array of all the theory variables used in the chain
+  #
+  def theory_variables
+    return TheoryCollection.new(@nodes).theory_variables
+  end
+  
+  # TODO  Maybe just move this method to the UnfiedChain class
+  # Returns a set containing the intrinsic statements that created the variables.  It should look
+  # something like the following.
+  #
+  # [{:global_variable_id=>0,:intrinsic_statement=>runtime_method,:written_statement=>'var1'},
+  #  {:global_variable_id=>3,:intrinsic_statement=>runtime_method.params[0],:written_statement=>'var1.params[var3]'},
+  #  ...]
+  #
+  # Currently the only way variables are created are for array access.
+  # 
+  # There should not be the case where there are duplicate intrinsic_statements but different global_variable_ids - 
+  # for now at least.
+  # 
+  def variables_creation(runtime_method,test_cases)
+    raise StandardError.new('This should only be called on complete chains') unless complete?
+    res = []
+    unify_chain.theory_variables.each do |var|
+      intrinsic_value = global_id_intrinsic_value(var.theory_variable_id)
+      if intrinsic_value.kind_of?(IntrinsicRuntimeMethod)
+        res << {
+          :global_variable_id=>var.theory_variable_id,
+          :intrinsic_statement=>Parser.run('runtime_method'),
+          :written_statement=>'var'+var.theory_variable_id.to_s,
+          :variable_value=>runtime_method.copy
+        }    
+      elsif intrinsic_value.kind_of?(IntrinsicTestCases)
+        res << {
+          :global_variable_id=>var.theory_variable_id,
+          :intrinsic_statement=>Parser.run('test_cases'),
+          :written_statement=>'var'+var.theory_variable_id.to_s,
+          :variable_value=>test_cases.copy
+        }        
+      else
+        
+        # TODO  This whole bit is just really rushed------------------ write tests! 
+
+        # Find all the statements that include that variable 
+        unified_components = unify_chain.components
+        
+        # TODO  This is an extremely clumsy approach
+        # Collect all the written components matching the delcaration
+        written_components = unified_components.collect {|x| x.write}
+        written_components = written_components.select {|x| x.include?('var'+var.theory_variable_id.to_s)}
+        
+        # TODO  Should use the Parser to find the statement with the varx in
+        usage_statements = written_components.inject([]) do |total,x|
+          unless x.write.match(/\s.*\[var[\d]\]/).nil?
+            total << TheoryStatement.new(StringToTheory.run(x.write.match(/\s.*\[var[\d]\]/)[0]))
+          end
+          total
+        end
+        intrinsic_statements = usage_statements.collect {|x| x.map_to(intrinsic_mapping)}
+        
+        unless intrinsic_statements.collect {|x| x.write}.uniq.length == 1
+          raise StandardError.new('Unable to create intrinsic variable create for variable '+var.theory_variable_id.to_s)
+        end
+        
+        res << {
+          :global_variable_id=>var.theory_variable_id,
+          :intrinsic_statement=>intrinsic_statements.first,
+          :written_statement=>usage_statements.first.write,
+          :variable_value=>intrinsic_mapping[var.theory_variable_id].copy
+        }
+        
+      end       
+    end
+    return res
+  end
+  
+protected  
+  
+  # Returns the intrinsic mapping for the unified chain
+  #
+  def intrinsic_mapping
+    
+    # Generate a global value mapping - so global id to real value
+    unifyied_chain = unify_chain
+    
+    # Get all the global variable ids -
+    m = Mapping.new
+    unifyied_chain.theory_variables.each do |x|
+      m[x.theory_variable_id] = global_id_intrinsic_value(x.theory_variable_id)
+    end
+    return m
+  end
+  
+  # Returns an array of all the components used in the chain 
+  # TODO  Could be turned into a set.
+  def components
+    return @nodes.inject([]) {|total,x| total += x.components }
+  end
+  
+  # Returns the intrinsic value for specified global id.  The intrinsic value is
+  # IntrinsicRuntimeMethod.new(7), IntrinsicFixnum.new(8), ...
+  #
+  # @param  global_id   The global id saved in chain_mapping
+  #
+  def global_id_intrinsic_value(global_id)
+    
+    # Possible values for global_id
+    potentential_values = []
+    @chain_mapping.mapping[global_id].each do |key,value|
+      if @values[key]
+        potentential_values << @values[key][value]
+      end
+    end
+    
+    if potentential_values.empty?
+      raise StandardError.new('Could not find an implementation value for global variable '+global_id.to_s)
+    end
+    
+    if potentential_values.length > 1 
+      unless potentential_values.collect {|y| y.write}.uniq.length == 1
+        raise StandardError.new('There is more than one possible value for this - it is ok if there the same')
+      end
+    end
+    return potentential_values[0]    
+    
+  end
+  
+  # Replaces the current chain with the values specified
+  #
+  def create!(n,m,instance_ids,v=[])
+    @nodes, @chain_mapping, @uniq_theory_instance_ids, @values = n,m,instance_ids,v
+    # TODO  I need to check there won't be a problem with @uniq_theory_instance_ids
+    return self
+  end
+  
+  def nodes=(obj)
+    @nodes = obj
+  end
+  
+  # Returns any number of new chains after adding this link to the position
+  # specified.
+  # 
+  # TODO  SHould I raise an error if it doesn't connect to anything?
+  #
+  def add_link_to(theory,position,value_mapping)
+    # TODO  Down and up are quite similar I should consider refactoring
+    
+    # Do through each of the dependents and then find a result with the same structure
+    mappings = [@chain_mapping.copy]
+    upward_links = @nodes[0...position]
+#    theory.copy.dependents.each do |dependent|
+#      if StandardLogger.instance.level == 0
+#      end
+#      each_unmet(:results,position,upward_links) do |index,link,result|
+#        if result.same_structure?(dependent)
+#          if StandardLogger.instance.level == 0
+#          end
+#          new_mappings = []
+#          mappings.each do |x|
+#            new_mappings << x.apply_mapping_update(theory,dependent.theory_component_id,link,result.theory_component_id)
+#          end
+#          mappings = new_mappings
+#        end
+#      end
+#    end
+
+    theory.copy.dependents.each do |dependent|
+      each_result(position,upward_links) do |index,link,result|
+        if result.same_structure?(dependent)
+          new_mappings = []
+          mappings.each do |x|
+            new_mappings << x.apply_mapping_update(theory,dependent.theory_component_id,link,result.theory_component_id)
+          end
+          mappings = new_mappings
+        end
+      end
+    end
+    
+    # Go down the rest of the chain looking for exisitng links with unmet dependents
+    downward_links = @nodes[position...@nodes.length]
+    theory.copy.results.each do |result|
+      each_unmet(:dependents,position,downward_links) do |index,link,dependent|
+        if dependent.same_structure?(result)
+          new_mappings = []
+          mappings.each do |x|
+            new_mappings << x.apply_mapping_update(link,dependent.theory_component_id,theory,result.theory_component_id)
+          end
+          mappings = new_mappings
+        end
+      end
+    end
+    
+    # Strip out any mappings that are identical to original they are 
+    # links that haven't been connected with anything 
+    # (don't include the head since it only has one thing to connect to)
+    unless @nodes.length < 2
+      mappings = mappings.select {|x| !@chain_mapping.same?(x) }
+    end
+    
+    # Identify any orphan variables in the action and give them uniq global ids
+    mappings.each do |mapping|
+      theory.orphan_action_variables.each do |x|
+        mapping.add_mapping(mapping.next_free_global_id,theory.theory_instance_id,x.theory_variable_id)
+      end
+    end
+        
+    # Create a new nodes array with the new theory in place
+    updated_nodes = @nodes.copy
+    updated_nodes.insert(position,theory)
+    
+    # Create a new chain for each of the possible mappings
+    extended_chains = []
+    mappings.each do |x|
+      c = self.copy
+      new_chain = c.create!(updated_nodes,x,@uniq_theory_instance_ids.copy,@values.copy)
+      extended_chains << new_chain 
+    end
+    return extended_chains
+  end  
+  
+  # TODO  This could probably be replaced by the normal add_link_to method
+  def add_tail(theory,value_mapping={})
+    @nodes.push(theory.copy)
+  end
+  
+#  # TODO  I don't think this is used
+#  def update_unified_theory_variables(unified_theory_variables_mapping,chain_front,dependent,theory)
+#    
+#      # TODO   Once the mapping is in place for all the theory vairables in the 
+#      #        in the dependent then the dependent should be mapped, written out
+#      #        and compared to the result instead of the same_structure? method.
+#
+#      # Find all the results that have the same structure as the dependent
+#      # TODO  It should probably preference the earliest theories first.
+#      matching_theories = chain_front.select do |t|
+#        t.results.any? {|x| x.same_structure?(dependent)}
+#      end
+#      
+#      # Check that a matching theory was found in the chain
+#      if matching_theories.empty?
+#        # Couldn't find a theory that meets this theories depdenents - add the theory will
+#        # need to add a another link to the chain to connect this theory with the head.
+#        return unified_theory_variables_mapping
+#      end
+#      
+#      # Go through the matching thoeries and find the result that matched the dependent
+#      matching_results = matching_theories.inject([]) do |total,t|
+#        # TODO  Presumes there is only one result
+#        res = t.results.select {|x| x.same_structure?(dependent)}.first
+#        total << {:theory_id=>t.theory_id,:result=>res,:theory=>t}
+#      end
+#
+#      # Check how many results meet the dependents
+#      raise StandardError.new('Currently only handling one result to dependent match') unless matching_results.length == 1
+#      linking_result = matching_results.first
+#      
+#      # Link two theories so that the share the same global mapping
+#      @chain_mapping.connect(
+#        theory,
+#        dependent.theory_component_id,
+#        linking_result[:theory],
+#        linking_result[:result].theory_component_id
+#      )   
+#    return unified_theory_variables_mapping
+#    
+#  end
+  
+#  def map_to_tail(global_mapping,theory)
+#
+#    # * Check whether there are any dependents from the back of the chain not met
+#    
+#    # Attempt to connect the theories results to the unmet dependents.
+#    # NOTE: The theories position is always one away from the head so
+#    # [:head]
+#    # [:x]  <-----------this is where the new link will go.
+#    # [:linkB]
+#    # [:linkA] 
+#    # [:tail]
+#    
+#    possible_mappings = [global_mapping.copy]
+#    valid_mappings = [global_mapping.copy]
+#
+#    # 1.  Find all the unmet dependents down the chain e.g. :tail, :linkA and :linkB
+#    # TODO  Need to generate some nice diagrams for what's happing - very har to visualise
+#    
+#    # TEMP: This is the dependent for the tail of the chain - the head doesn't have any dependents
+#    unless unmet_dependents_and_link.empty?
+#      unmet_dependents_and_link.each do |dep_and_link|
+#        
+#        dependent = dep_and_link[:dependent]
+#        # TODO  This is very similar to the code above - re-factor
+#        # Do any of the results have the same structure as the dependent?
+#        if theory.results.any? {|x| x.same_structure?(dep_and_link[:dependent])}
+#          
+#          valid_mappings = []
+#          
+#          results = theory.results.select {|x| x.same_structure?(dep_and_link[:dependent])}
+#          possible_mappings.each do |mapping|
+#            results.each do |res|
+#              
+#              begin 
+#                new_mapping = potential_tail_mapping(mapping.copy,theory.copy,res.copy,dep_and_link[:dependent].copy,dep_and_link[:theory].copy)
+#                # TODO  Create special MappingError
+#              rescue StandardError => e
+#                StandardLogger.instance.error e
+#                next
+#              end
+#              valid_mappings << new_mapping
+#            end
+#          end
+#          
+#          # Make the valid mappings the possible mappings for the next stage                      
+#          possible_mappings = valid_mappings
+#          
+#        end
+#        
+#      end
+#      
+#    end    
+#    
+#    if valid_mappings.empty?
+#      raise StandardError.new('Unable to perform valid mapping')
+#    else
+#      # TODO  Should be returning all the potential mapping
+#      return valid_mappings[0]
+#    end
+#    
+#    #return global_mapping
+#  end
+  
+#  # Returns the updated mapping if a possible match is found otherwise it raises 
+#  # an error.
+#  #
+#  def potential_tail_mapping(global_mapping,new_theory,new_result,existing_dependent,existing_theory)
+#    
+#    # Check that the result and dependent have the same number of theory variables
+#    if new_result.theory_variables.length != existing_dependent.theory_variables.length
+#      raise StandardError.new('The result and dependent that are being linked do not have the same number of theory_variables')
+#    end
+#    
+#    new_result.theory_variables.zip(existing_dependent.theory_variables) do |result_theory_variable,dependent_theory_variable|
+#      # Add the results of the theory to the global variables.
+#
+#      # So these two variables need the same global variable
+#      # TODO  This presumes that the same theory isn't being used in the chain            
+#      global_mapping.connect(
+#        new_theory,
+#        new_result.theory_component_id,
+#        existing_theory,
+#        existing_dependent.theory_component_id
+#      )            
+#    end     
+#    return global_mapping
+#    
+#  end
+  
+  # Returns the global id of the variable given the theory id and the variable
+  # id.
+  # 
+  def to_global_id(global_mapping,theory_id,theory_variable_id)
+    global_id = global_mapping.find_global(theory_id,theory_variable_id)
+    if global_id.nil? 
+      raise StandardError.new('Unable to find global id for theory '+theory_id.to_s+' theory_variable_id: '+theory_variable_id.to_s)
+    end
+    return global_id
+  end
+  
+  # NOTE: The :tail isn't a real link, the last link just matches the :tail settings 
+  def link_to_tail(theory)
+    
+    # * Find the dependent(s) that connect to the finish
+    linking_results = theory.select_result_structure(@tail)
+    raise StandardError.new('Only expecting the theory to have one result that matches the finish') unless linking_results.length == 1
+    if linking_results.empty?
+      StandardLogger.instance.warning "this theory does not link to the tail"
+      return
+    end
+    linking_result = linking_results.first
+  end
+  
+#  def front_of_chain
+#    return [@nodes.first.copy]
+#  end
+  
+  # Returns a new theory mapping that replace the theories local ids with global 
+  # ids.
+  #
+  def generate_theory_mapping(theory_id)
+    mapping = Mapping.new
+    @chain_mapping.mapping.each do |key,value|
+      if value[theory_id]
+        mapping[value[theory_id]] = TheoryVariable.new(key)
+      end
+    end
+    return mapping
+  end
+  
+  # Returns true if the dependents of all the theories have been me.  It 
+  # does this by starting from the last link in the chain(the one cloest to
+  # the tail) and goes through each of it's dependents.  It searches up the 
+  # the chain until it finds a result that matches. 
+  #
+  # Check that all the dependents have been connected to a result component
+  #
+  # NOTE: This should only be ran on unfied chains.
+  # 
+  def dependents_met?
+    collection = TheoryCollection.new(@nodes)
+    return collection.dependents.all? do |dependent| 
+      @chain_mapping.connected_component_ids.include?(dependent.theory_component_id)
+    end
+  end
+  
+  # Start from the back of the chain and work backwards to the head.
+  #
+  def dependent_met?(dependent,chain)
+    chain.reverse.each do |theory|
+      theory.results.each do |result|
+        return true if result.write == dependent.write
+      end
+    end
+    return false
+  end
+  
+  # Returns an array of all the depdendents in the chain that haven't
+  # been met by the front of the chain.
+  #
+  def unmet_dependents
+    results = []
+    return results if self.empty?
+    duplicate_chain = self.copy
+    last_link = duplicate_chain.pop
+    last_link.dependents.each do |dependent|
+      results.push dependent unless dependent_met?(dependent,duplicate_chain.copy)
+    end
+    return results+duplicate_chain.unmet_dependents
+  end
+
+  # Goes up through each theory in the chain from the position
+  # specifies and yeilds any unment depndents or results and the
+  # theory it belongs to.
+  #
+  # @param    approach    Either :depndents or :results 
+  #
+  def each_unmet(approach,position,nodes)
+    # TODO  Need to exclude theories that use the immediate runtime method
+    index = 0
+    comp_ids = @chain_mapping.connected_component_ids
+    nodes.each do |theory|
+      unmets = theory.send(approach).select do |x|
+        !comp_ids.include?(x.theory_component_id)
+      end
+      unmets.each {|x| yield index, theory, x}
+      index += 1
+    end
+  end
+  
+  def each_result(position,nodes)
+    index = 0
+    nodes.each do |theory|
+      theory.results.each {|x| yield index, theory, x}
+      index += 1
+    end    
+  end
+  
+  # Returns a hash of all the unmet dependents down the chain (excluding the head)
+  # and the link/theory that it belongs to.
+  #
+  def unmet_dependents_and_link
+    results = []
+    return results if self.empty?
+    duplicate_chain = self.copy
+    
+    # Remove the head link from the chain
+    duplicate_chain.shift
+    
+    duplicate_chain.length.times do
+      last_link = duplicate_chain.pop
+      last_link.dependents.each do |d|
+        next if dependent_met?(d,duplicate_chain.copy)
+        results.push({:dependent=>d.copy,:theory=>last_link.copy}) 
+      end      
+    end
+    return results    
+  end
+  
+  # Removes any results from the head that aren't needed to meet 
+  # the dependents of the supplied theories.
+  # 
+  # NOTE  This method is only really needed while the head is so large
+  #       as development continue I don't think this call will be needed.(26/04/2011)
+  #
+  def remove_superfluous_head_results!(theories)
+    theory_dependents = theories.inject([]) {|total,x| total += x.dependents}
+    new_results = []
+    @nodes.first.results.each do |r|
+      if theory_dependents.any? {|x| r.same_structure?(x)}
+        new_results.push(r)
+      end
+    end    
+    @nodes.first.results = new_results
+  end  
+  
+  # Retruns true if all the dependents,and subsequent dependents of 
+  # the theory can be met otherwise it returns false. 
+  #
+  def dependency_tree_met?(theory,theories,pending_theories=[])
+    
+    return theory.dependents.all? {|d| dependent_can_be_met?(d,theories,pending_theories+[theory.copy])}
+    
+    # Finish if the theory is already in pending theories or has no dependents.
+  end
+  
+  def dependent_can_be_met?(dependent,theories,pending_theories=[])
+    
+    # Try to find theories thats result meets this dependent
+    theory_collection = TheoryCollection.new(theories.copy)
+    theory_collection.each_with_result_structure(dependent) do |theory,result|
+      
+      # Check whether the matching theory is in pending theories 
+      # (it is already being checked otherwise)
+      if pending_theories.any? {|x| x.theory_id == theory.theory_id}
+        return true
+      end
+      
+      #return dependency_tree_met?(theory,theories,pending_theories+[theory.copy])
+      return dependency_tree_met?(theory,theories,pending_theories+[theory.copy])
+      
+    end
+    StandardLogger.instance.warning '* failed to find a theory with a result to dependent: '
+    StandardLogger.instance.warning dependent.describe
+    return false
+  end
+  
+private
+  
+  # Itterates through a progressive extending chain also returning
+  # the theory that has just been added to the chain.
+  #
+  def progressive_chain
+    return @nodes.length.times do |i|
+      copied_chain = self.copy
+      copied_chain.nodes = @nodes[0..i] 
+      yield copied_chain, @nodes[i].copy 
+    end
+  end
+  
+end