cauldron 0.1.2 → 0.1.3

data/cauldron/lib/cauldron.rb

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

data/features/cauldron_generates_runtime_method.feature

@@ -2,12 +2,15 @@ Feature: Cauldron generates a runtime method
 	I want a runtime method
 	That will solve a set of example cases
 
+  TODO  The second solution isn't correct but for now it will do
+
 	Scenario Outline: Generate a solution to a previously solved problem
 		Given that the terminal has been created 
-		When I add these <cases>
+		When I add a case with a param <case_1_param> and an expected output of <case_1_output>
+		And I add a case with a param <case_2_param> and an expected output of <case_2_output>
 		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_0(var_0)\n\treturn var_0\nend\n"  |     1       |
-			|	 "'fish','animal'*'carrot','vegetable'"			|	"def method_0(var_0)\n\tif(var_0 == 'fish')\n\t\treturn 'animal'\n\tend\n\treturn 'vegetable'\nend\n" | 2 |	
+		 | case_1_param | case_1_output | case_2_param | case_2_output | runtime_method                                                                                                        |
+		 | "sparky"     | "sparky"      | "kel"        | "kel"         | "def method_0(var_0)\n  return var_0\nend\n"                                                                          |
+		 | "fish"       | "animal"      | "carrot"     | "vegetable"   | "def method_0(var_0)\n  if(var_0 == 'fish')\n    return 'animal'\n  end\n  return 'vegetable'\n  return var_0\nend\n" |

data/features/cauldron_generates_single_paramter_methods.feature

@@ -0,0 +1,25 @@
+Feature: Cauldron generates single parameter methods
+
+	Cauldron can generate runtime methods that accepts one parameters
+	
+	NOTE: it creates the file in tmp/aruba/launch.rb - so that loading path needs to be changed
+				- use @pause to see if it's working.
+
+ 	@announce @slow_process
+	Scenario: Method returns the passed in value
+  	Given a file named "launch.rb" with:
+      """
+			$LOAD_PATH.unshift File.expand_path( File.join('lib') )
+			require 'cauldron'
+			cauldron = Cauldron::Terminal.new(STDOUT,false)
+			cauldron.start
+      """		
+		And I run `ruby launch.rb` interactively
+    And I add the case "sparky","sparky"
+    And I type "RUN"
+    When I type "QUIT"
+    Then the output should contain:
+      """
+      return var_0
+      """
+		

data/features/cauldron_interactive_start_terminal.feature

@@ -0,0 +1,17 @@
+Feature: It should display a start up message
+
+  @announce @slow_process
+  Scenario: Interactive cauldron start up
+    Given a file named "launch.rb" with:
+      """
+      $LOAD_PATH.unshift File.expand_path( File.join('lib') )
+      require 'cauldron'
+      cauldron = Cauldron::Terminal.new(STDOUT,false)
+      cauldron.start
+      """ 
+    And I run `ruby launch.rb` interactively
+    When I type "QUIT"
+    Then the output should contain: 
+      """
+      Starting...
+      """

data/features/cauldron_quit_terminal.feature

@@ -0,0 +1,9 @@
+Feature: Cauldron can be quit from the terminal
+	Typing "QUIT" in the terminal will cause the process to quit
+		
+		see for examples https://github.com/cucumber/aruba/blob/master/features/interactive.feature
+
+		#Scenario: quit cauldron from the terminal
+		#	Given I've started Cauldron
+		#	Then the exit status should be 0
+			

data/features/cauldron_start_terminal.feature

@@ -7,7 +7,6 @@ Feature: Cauldron starts on the command line
 		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

@@ -1,9 +1,14 @@
 
-When /^I add these "([^"]*)"$/ do |test_cases_statement|
-  test_cases = test_cases_statement.split('*')
-  test_cases.each do |x|
-    @terminal.submit x 
-  end
+# When /^I add these "([^"]*)"$/ do |test_cases_statement|
+  # test_cases = test_cases_statement.split('*')
+  # test_cases.each do |x|
+    # @terminal.submit x 
+  # end
+# end
+
+When /^I add a case with a param "([^"]*)" and an expected output of "([^"]*)"$/ do |param, output|
+  #@terminal.submit("'"+param+,"'+output+'"')  
+  @terminal.submit("'#{param}','#{output}'")
 end
 
 Then /^I should receive a runtime method like this "([^"]*)"$/ do |runtime_method_statement|

data/features/step_definitions/terminal_steps.rb

@@ -6,12 +6,39 @@ Given /^that the terminal has been created$/ do
   @terminal.start
 end
 
+Given /^I've started Cauldron$/ do
+  When "I start cauldron"
+end
 
 When /^I start cauldron$/ do
   @terminal = Cauldron::Terminal.new(output)
   @terminal.start
 end
 
+# When /^I type "([^"]*)"$/ do |command|
+  # @terminal.submit command
+# end
+
+# When /^I type "([^"]*)","([^"]*)"$/ do |param, output|
+  # #type "'"+param+"','"+output+"'"
+  # type 'test'
+# end
+
+When /^I add the case "([^"]*)","([^"]*)"$/ do |param, output|
+  #pending # express the regexp above with the code you wish you had
+  type "'"+param+"','"+output+"'"
+end
+
+
+# Then /^cauldron should say 'bye'$/ do
+  # output.messages.should include('bye')
+# end
+# 
+# Then /^the exit status should be (\d+)$/ do |exit_status|
+  # @terminal.submit 'QUIT'
+  # @last_exit_status.should == exit_status.to_i
+# end
+
 Then /^I should see "([^"]*)"$/ do |message|
    output.messages.should include(message)
 end

data/features/support/env.rb

@@ -2,6 +2,8 @@ $LOAD_PATH << File.expand_path('../../../lib',__FILE__)
 
 require 'cauldron'
 
+require 'aruba/cucumber'
+
 class Output
   
   def messages

data/features/support/hooks.rb

@@ -0,0 +1,15 @@
+
+# => http://itshouldbeuseful.wordpress.com/2011/06/23/step-through-your-cucumber-features-interactively/
+AfterStep('@pause') do
+  print "Press Return to continue..."
+  STDIN.getc
+end
+
+Before('@slow_process') do
+  @aruba_io_wait_seconds = 3
+  @aruba_timeout_seconds = 3
+end
+
+Before do
+  @dirs = ["."]
+end

data/lib/Chain.rb

@@ -11,7 +11,7 @@ class Chain
     @values, @nodes = {}, [] 
     
     # Create an array of possible ids for any theories added
-    @uniq_theory_instance_ids = ('A'...'Z').to_a 
+    @uniq_theory_instance_ids = ('AA'...'ZZ').to_a 
     
     # Create a result version of 'finish'
 
@@ -141,7 +141,8 @@ class Chain
       mapped_theory = theory.map_to(mapping)
       total.push(mapped_theory)
     end
-    return UnifiedChain.new(unified_theories)
+    # => TODO This contians information about the chain before it has been unified  - this should not be included  
+    return UnifiedChain.new(unified_theories,@chain_mapping.copy).freeze
   end
   
   # DEVELOPMENT
@@ -591,7 +592,6 @@ protected
     
     if potentential_values.length > 1 
       unless potentential_values.collect {|y| y.write}.uniq.length == 1
-        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

data/lib/Mapping.rb

@@ -5,6 +5,7 @@ class Mapping
   
   def initialize(hash={})
     super()
+    raise StandardError.new('This should be a hash not a '+hash.class.to_s) unless hash.kind_of?(Hash)
     @hash = hash
   end
   

data/lib/PartialChain.rb

@@ -0,0 +1,253 @@
+# => TODO This is a duplicate of of UnifiedChain - it needs stripped down allot - probably shouldn't exist
+
+class PartialChain
+  
+  def initialize(nodes)
+    @nodes = nodes
+  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
+  
+  def copy
+    #return Chain.new(@nodes.copy)
+    return Marshal.load(Marshal.dump(self))
+  end  
+  
+  # Returns an array of all the theory variables in the chain.  All the 
+  # theory variables should be global across the chain. 
+  #
+  def theory_variables
+    results = @nodes.inject([]) do |total,theory|
+      total += theory.all_theory_variables.collect {|x| x}
+      total
+    end
+    return results.uniq
+  end
+  
+  def length
+    return @nodes.length
+  end
+  
+  # Return an implemented version of the chain where all the theory variables have
+  # been replaced with read values.
+  #
+  def implement(mapping)
+    implemented_nodes = @nodes.inject([]) do |total,theory|
+      total << theory.map_to(mapping)
+    end
+    return ImplementedChain.new(implemented_nodes,mapping)
+  end
+
+  def implementation_permuatations2(runtime_method,test_cases,mapping)
+
+    more_mapping = valid_mapping_permutations(runtime_method.copy,test_cases.copy)
+
+    return more_mapping.inject([]) { |total,mapping| total << self.copy.implement(mapping) }
+    
+  end
+  
+  def has_all_variables_been_found?(component,mappings)
+    component.theory_variables.each do |var|
+      mappings.each do |mapping|
+        return false unless mapping.has_key? var.theory_variable_id
+      end
+    end
+    return true
+  end
+  
+  def identify_uniq_mappings(mappings)
+    uniq_mappings = []
+    count = mappings.length
+    until mappings.empty?
+      mapping = mappings.shift
+      already_exists = mappings.any? do |x|
+        next false unless x.length == mapping.length
+        next false unless x.keys.sort == mapping.keys.sort
+        all_values_the_same = true 
+        x.each do |key,value|
+          if mapping[key].class != value.class
+            all_values_the_same = false
+          end 
+          if mapping[key].class == value.class
+            if mapping[key].kind_of?(IntrinsicLiteral)
+              if mapping[key].write != value.write
+                all_values_the_same = false
+              end
+            end
+          end
+        end
+        next false unless all_values_the_same
+        next true
+      end
+      unless already_exists
+        uniq_mappings << mapping
+      end
+    end
+    if uniq_mappings.length == 0 && count != 0
+      raise StandardError.new('uniq_mappings should not be 0')
+    end
+    return uniq_mappings
+  end
+  
+  def intrinsic_values_for_variable(id,component,mapping,runtime_method,test_cases,intrinsic_values)
+    
+    values = []
+    component.statements_with_variable(id).each do |statement|
+      reg = eval('/^var'+id.to_s+'\./')
+        if statement.write.match(reg)
+        
+        intrinsic_values.each do |value|
+          temp_mapping = mapping.copy
+          temp_mapping[id] = value
+          # => TODO Not validating the component - e.g. if(var1.kind_of?(RuntimeMethod))
+          if valid_mapping?(runtime_method.copy,test_cases.copy,statement,temp_mapping)
+            values << value
+          end
+        end
+        next
+      end
+      
+      # values for index
+      index_values = []
+      intrinsic_statement = statement.map_to(mapping)
+      if intrinsic_statement.select_all {|z| z.kind_of?(TheoryVariable)}.length > 0
+        if m = intrinsic_statement.write.match(/([\w\.]+)\[var(\d)+\]/)
+          method_call = $1
+          if m2 = method_call.match(/var(\d+)/)
+            next 
+          end
+          literal = evaluate_statement(method_call,runtime_method.copy,test_cases.copy)
+          literal.length.times do |n|
+            index_values << IntrinsicLiteral.new(n)
+          end        
+        end    
+      end      
+      values += index_values
+      
+      #variable_values = []
+      #result.statements_with_variable(var.theory_variable_id).each do |statement|
+      #variable_values += values_for_variable_as_argument(var,statement,mapping,intrinsic_values,implemented_runtime_method.copy,test_cases.copy)
+      #end
+      #values += variable_values
+      
+      #intrinsic_statement = statement.map_to(mapping)
+      variable_values = []
+      intrinsic_values.each do |value|
+        literal = intrinsic_statement.write.gsub(/var(\d)+/,value.write)
+        begin
+          eval literal
+          variable_values << value
+        rescue
+          next
+        end
+      end
+      #return results
+      values += variable_values      
+      
+      
+    end
+    return values
+  end
+  
+  def mapping_permutations(keys,values)
+    values.permutation(keys.length).to_a.inject([]) do |total,value_permutation|
+      total << Hash[*keys.zip(value_permutation).flatten]
+    end
+  end
+  
+  def valid_mapping?(runtime_method,test_cases,statement,mapping)
+    intrinsic_statement = statement.map_to(mapping)
+    return false unless intrinsic_statement.select_all {|z| z.kind_of?(TheoryVariable)}.length == 0
+    valid_statement?(intrinsic_statement,runtime_method.copy,test_cases.copy)
+  end
+  
+  def evaluate_statement(statement,runtime_method,test_cases)
+    eval statement
+  end
+  
+  def valid_statement?(statement,runtime_method,test_cases)
+    eval statement.write
+    return true
+  rescue NoMethodError
+    return false    
+  end
+  
+  # Returns an array of implemented chains using the various value
+  # permutations.  Essential what it is looking for is mapping to convert 
+  # all the theory variables to intrinsic variables.
+  #
+  # @param  runtime_method    The runtime method instance that will be populated to 
+  #                           create the solution.<#RuntimeMethod >
+  # @param  test_cases        The test cases instance containing real values.
+  #
+  def implementation_permuatations(runtime_method,test_cases,mapping)
+    
+    return implementation_permuatations2(runtime_method,test_cases,mapping)
+    
+    # Determine the number of variables without intrinsic values
+    theory_variable_ids = theory_variables.collect {|x| x.theory_variable_id}
+    
+    # Collect the theory variables without intrinsic values
+    missing_intrinsic_values = theory_variable_ids-mapping.keys
+    
+    # Take the first theory and identify all the accessors
+    # (need to work out what is the runtime method and what the test cases)
+    
+    # TEMP: Why are these implemented theories
+    # @nodes.first.all_theory_variables
+    
+    # Create the theory generator
+    generator = TheoryGenerator.new()
+    
+    #accessors, temp_mapping = generator.generate_accessors_and_mapping(test_cases,runtime_method,1)
+    accessors, temp_mapping = generator.generate_accessors_and_mapping(test_cases,runtime_method,3)
+
+    if temp_mapping.length > missing_intrinsic_values.length
+
+      # Now to assign real values to the chain
+      
+      # Apply the values in the various permutaions 
+      # (this is very crude and means that odd calls )
+      #theory_variable_ids = @nodes.first.all_theory_variables.collect {|x| x.theory_variable_id }
+      
+      theory_variable_ids = self.theory_variables.collect {|x| x.theory_variable_id }
+      
+      # Get the posible sets for values in an array so that non of the arrays contain all the same values
+      res = temp_mapping.values.collect {|x| x}
+      
+      # TODO  This is a complete hack but I think I should be using intrinsic values rather than real
+      intrinsic_res = res.collect {|x| x.to_intrinsic}
+      value_permutaions = intrinsic_res.permutation(theory_variable_ids.length).to_a
+      uniq_value_permutations = value_permutaions.collect {|x| x.to_set}.uniq
+      possible_mappings = []
+      
+      theory_variable_id_permutations = theory_variable_ids.permutation(theory_variable_ids.length).to_a
+      
+      possible_mappings = []
+      theory_variable_id_permutations.each do |theory_variable_id_permutation|
+        uniq_value_permutations.each do |value_permutation|
+          m = Mapping.new
+          theory_variable_id_permutation.zip(value_permutation.to_a) do |key,value|
+            m[key] = value
+          end
+          possible_mappings << m
+        end
+        
+      end
+      
+      # Implemented changes
+      return possible_mappings.inject([]) { |total,mapping| total << self.copy.implement(mapping) }
+      
+    else
+      raise StandardError.new('Could not generate enough real vlaues to test theory - try increasing the itterations')
+    end
+    
+  end      
+  
+end