cauldron 0.1.0 → 0.1.1

data/Gemfile

@@ -10,4 +10,6 @@ group :development do
   gem "bundler", "~> 1.0.15"
   gem "jeweler", "~> 1.6.2"
   gem "rcov", ">= 0"
+  gem "ruby2ruby", "~>1.2.5"
+  gem "ruby_parser", "~>2.0.6"
 end

data/Rakefile

@@ -11,6 +11,12 @@ rescue Bundler::BundlerError => e
 end
 require 'rake'
 
+$LOAD_PATH << File.expand_path('../lib',__FILE__)
+
+require 'lib/cauldron'
+
+load File.join(File.dirname(__FILE__), 'tasks', 'theory_tasks.rake')
+
 require 'jeweler'
 Jeweler::Tasks.new do |gem|
   # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
@@ -21,6 +27,7 @@ Jeweler::Tasks.new do |gem|
   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"]
+  gem.required_ruby_version = '>= 1.6.8'
   # dependencies defined in Gemfile
 end
 Jeweler::RubygemsDotOrgTasks.new

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.1

data/features/cauldron_generates_runtime_method.feature

@@ -8,5 +8,6 @@ Feature: Cauldron generates a runtime method
 		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       |
+			|      cases   	   	   				         				|     							runtime_method   						|		demo_num  |
+			|  "'sparky','sparky'*'kel','kel'"      			| "def method_3(var_6)\n\treturn var_6\nend\n"  |     1       |
+			|	 "'fish','animal'*'carrot','vegatable'"			|	"def method_3(var_0)\n\tif(var_0 == 'fish')\n\t\treturn 'animal'\n\tend\n\treturn 'vegetable'\nend\n" | 2 |	

data/features/step_definitions/cauldron_steps.rb

@@ -8,7 +8,6 @@ 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/support/method_1.example

@@ -0,0 +1,3 @@
+def method_3(var_6)
+	return var_6
+end

data/features/support/method_2.example

@@ -0,0 +1,6 @@
+def method_1(var_1)
+	if var_1 == 'fish'
+		return 'animal'
+	end
+	return 'vegtable'
+end

data/lib/Chain.rb

@@ -29,7 +29,8 @@ class Chain
     real_method = Parser.run('runtime_method')
     
     # Add the tail to the nodes list
-    add_link(@tail_theory,{1=>real_method,2=>tc})
+    #add_link(@tail_theory,{1=>real_method,2=>tc})
+    extension_permutaions(@tail_theory,{1=>real_method,2=>tc})
     
   end
   
@@ -102,6 +103,14 @@ class Chain
     end
   end
   
+  def unmet_dependents_ids
+    collection = TheoryCollection.new(@nodes)
+    return collection.dependents.inject([]) do |total,dependent|
+      total << dependent.theory_component_id unless @chain_mapping.connected_component_ids.include?(dependent.theory_component_id)
+      total
+    end
+  end  
+  
   # Returns a new chain where they are all using the same respective theory
   # variables.
   #
@@ -113,7 +122,8 @@ class Chain
     end
     unified_theories = @nodes.inject([]) do |total,theory|
       mapping = generate_theory_mapping(theory.theory_instance_id)
-      total.push theory.map_to(mapping)
+      mapped_theory = theory.map_to(mapping)
+      total.push(mapped_theory)
     end
     return UnifiedChain.new(unified_theories)
   end
@@ -143,7 +153,6 @@ class Chain
   
   # 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.
   # 
@@ -161,12 +170,7 @@ class Chain
   # 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)
+  def extension_permutaions(theory,value_mapping=nil)
     
     # Give the theory an instance id
     theory = theory.copy
@@ -247,6 +251,80 @@ class Chain
     return res
   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|
+      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)
+    # => TODO Do I like this? It means I'm including some forced connections
+    unless @nodes.length < 2
+      
+      # Identify the mappings that are the same
+      mappings = mappings.select {|x| !@chain_mapping.same?(x) }
+      # => TODO Should inlcude error/warning and exit when there are no new mappings
+    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    
+  
   # 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.
@@ -335,6 +413,20 @@ class Chain
   def theory_variables
     return TheoryCollection.new(@nodes).theory_variables
   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
   
   # TODO  Maybe just move this method to the UnfiedChain class
   # Returns a set containing the intrinsic statements that created the variables.  It should look
@@ -353,6 +445,7 @@ class Chain
     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 << {
@@ -380,10 +473,22 @@ class Chain
         written_components = unified_components.collect {|x| x.write}
         written_components = written_components.select {|x| x.include?('var'+var.theory_variable_id.to_s)}
         
+        # => DEV
+        temp_component = written_components.first
+
+        # => MATCH var0.params[var2] in runtime_method.add_statement_at(OpenStatement.new(TheoryStatement.new(If.new, Container.new(var0.params[var2], Equivalent.new, var1[var4][:params][var3]))),var0.statement_id)
+        reg = eval('/[\w\d\.\[\]:]*\['+var.write+'\]/')
+                
         # TODO  Should use the Parser to find the statement with the varx in
+        #var_match = /\s.*\[var[\d]\]/
+        #var_match = /^[\s|\(]+(.*\[var[\d]\])/
+        var_match = reg
         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]))
+          
+          #unless x.write.match(/\s.*\[var[\d]\]/).nil?
+          unless x.write.match(var_match).nil?
+            match = x.write.match(var_match)[0]
+            total << TheoryStatement.new(StringToTheory.run(match))
           end
           total
         end
@@ -405,6 +510,27 @@ class Chain
     return res
   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  
+  
 protected  
   
   # Returns the intrinsic mapping for the unified chain
@@ -449,7 +575,8 @@ protected
     
     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')
+        pp potentential_values
+        raise StandardError.new('There is more than one possible value for this('+global_id.to_s+') - it is ok if there the same')
       end
     end
     return potentential_values[0]    
@@ -468,223 +595,11 @@ protected
     @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.
   # 
@@ -709,10 +624,6 @@ protected
     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.
   #
@@ -752,23 +663,9 @@ protected
     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
+  # specifies and yeilds any unment dependents or results and the
   # theory it belongs to.
   #
   # @param    approach    Either :depndents or :results 
@@ -794,27 +691,6 @@ protected
     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.
   #