cauldron 0.1.0 → 0.1.1

data/lib/CodeHandler.rb

@@ -1,5 +1,3 @@
-# TODO  Look into matrix
-require "matrix"
 require "tsort"
 
 # A code handler continualy considers how to extend the complexity 
@@ -13,8 +11,6 @@ require "tsort"
 # can.  Note they are consider unique if the process to create them is 
 # new, NOT whether or not there value is new.
 #
-# TODO  Look up dynamic refactoring
-#
 class CodeHandler
   
   attr_reader :runtime_methods

data/lib/ScopeDependencies.rb

@@ -1,6 +1,7 @@
 class ScopeDependencies < Array
   
   def initialize
+    raise StandardError.new('Will anyone miss me')
     super()
   end
   

data/lib/Theory.rb

@@ -22,6 +22,10 @@ class Theory
     return Marshal.load(Marshal.dump(self))
   end
   
+  def irrelevant?
+    dependents.empty? and results.empty? and action.nil?
+  end
+  
   # Identify the dependents and actions that haven't changed between adding the action.
   # 
   def identify_unchanged
@@ -51,20 +55,6 @@ class Theory
     return Theory.new(changing_dependents,action.copy,changing_results,example_runtime_method.copy)
   end
   
-#  # NOTE: This method might not be useful.
-#  # Returns a number of theories but with the number of dependents and results limited by the
-#  # the numbers specified.
-#  #
-#  def variants(dependent_limit=4,results_limit=4)
-#    results = []
-#    @dependents.copy.permutation(dependent_limit).each do |d|
-#      @results.copy.permutation(results_limit).each do |r|
-#        results << Theory.new(d.copy,action.copy,r,example_runtime_method.copy)
-#      end
-#    end
-#    return results
-#  end
-  
   #  Loads a particular theory that has been saved to a file
   #
   def self.load_theory(theory_id)
@@ -140,13 +130,20 @@ class Theory
   #
   def map_to(mapping,values={})
     raise StandardError.new('Please use the maping datatype') unless mapping.kind_of?(Mapping)
+    # return TheoryImplementation.new(
+        # @dependents.collect {|y| y.map_to(mapping)},
+        # @action ? @action.map_to(mapping) : nil,
+        # @results.collect {|y| y.map_to(mapping)},
+        # mapping,
+        # values
+      # )    
     return TheoryImplementation.new(
         @dependents.collect {|y| y.map_to(mapping)},
         @action ? @action.map_to(mapping) : nil,
         @results.collect {|y| y.map_to(mapping)},
         mapping,
         values
-      )    
+      )       
   end
   
   # TODO  Need to write tests for this that use the mapping

data/lib/UnifiedChain.rb

@@ -35,7 +35,261 @@ class UnifiedChain < Chain
     implemented_nodes = @nodes.inject([]) do |total,theory|
       total << theory.map_to(mapping)
     end
-    return ImplementedChain.new(implemented_nodes)
+    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 valid_mapping_permutations(runtime_method,test_cases)
+    
+    # Get the initially available intrinsic values
+    intrinsic_values = [IntrinsicRuntimeMethod.new,IntrinsicTestCases.new]
+    
+    total_variables = self.theory_variables.length
+    
+    available_values = [IntrinsicRuntimeMethod.new,IntrinsicTestCases.new]    
+    
+    valid_mappings = [Mapping.new]
+    
+    #itteration_limit = 6
+    itteration_limit = 8
+    
+    @nodes.each_with_index do |node,index|
+
+      node.dependents.each do |dependent|
+        if index == 0
+          chain = partial_chain(0)
+        else
+          chain = partial_chain(index-1) 
+        end
+        limit = 0
+        until has_all_variables_been_found?(dependent,valid_mappings) or limit > itteration_limit
+          valid_mappings = extend_mapping(valid_mappings,dependent,runtime_method.copy,test_cases.copy,chain,available_values)
+          limit += 1
+        end  
+      end
+      
+      unless node.action.nil?
+        if index == 0
+          chain = partial_chain(0)
+        else
+          chain = partial_chain(index-1) 
+        end
+        limit = 0            
+        until has_all_variables_been_found?(node.action,valid_mappings) or limit > itteration_limit
+          valid_mappings = extend_mapping(valid_mappings,node.action,runtime_method.copy,test_cases.copy,chain,available_values)
+          limit += 1
+        end
+        if limit > itteration_limit  
+          raise StandardError.new('Unable to resolve action: '+node.action.write)
+        end        
+      end
+      
+      node.results.each do |result|
+        chain = partial_chain(index)
+        limit = 0            
+        until has_all_variables_been_found?(result,valid_mappings) or limit > itteration_limit
+          valid_mappings = extend_mapping(valid_mappings,result,runtime_method.copy,test_cases.copy,chain,available_values)
+          limit += 1
+        end
+          
+      end
+      
+    end
+      
+    return valid_mappings.collect {|x| Mapping.new(x)} 
+    
+  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 extend_mapping(valid_mappings,component,runtime_method,test_cases,chain,available_values)
+    
+    new_mappings = [] 
+    component.theory_variables.each do |var|
+      next if valid_mappings.first.has_key?(var.theory_variable_id)
+      valid_mappings.each do |mapping|
+
+        #next if mapping.has_key?(var.theory_variable_id)
+        implemented_chain = chain.implement(Mapping.new(mapping))
+        implemented_runtime_method = TheoryChainValidator.new.build_method_from_chain(
+                                        implemented_chain,runtime_method.copy,test_cases.copy
+                                      )        
+
+        possible_values = available_values-mapping.values   
+        begin 
+        values = intrinsic_values_for_variable(
+          var.theory_variable_id,
+          component,
+          mapping,
+          implemented_runtime_method,
+          test_cases.copy,
+          possible_values    
+        )
+        rescue NoMethodError => e
+          valid_mappings = valid_mappings-[mapping]
+          next
+        end
+        values = values.uniq      
+        values.each do |value|
+          copied_mapping = mapping.copy
+          copied_mapping[var.theory_variable_id] = value
+          new_mappings << copied_mapping 
+        end
+      end
+      
+    end
+    # => QUICK Hack
+    new_mappings = identify_uniq_mappings(new_mappings)
+    longest_mapping = new_mappings.inject(0) do |highest,m| 
+      if(m.length > highest) 
+        highest = m.length
+      end
+      highest
+    end
+    res = new_mappings.select {|x| x.length == longest_mapping}
+    new_mappings = res
+    
+    unless new_mappings.empty?
+      valid_mappings = new_mappings
+    end
+    return valid_mappings    
+    
+  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 partial_chain(limit)
+    links = @nodes[1..limit].collect {|x| x.copy }
+    UnifiedChain.new(links)    
+  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
@@ -48,6 +302,8 @@ class UnifiedChain < Chain
   #
   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}
     
@@ -57,22 +313,24 @@ class UnifiedChain < Chain
     # Take the first theory and identify all the accessors
     # (need to work out what is the runtime method and what the test cases)
     
-    #pp missing_intrinsic_values
-    #puts @nodes.first.class.to_s
-    #@nodes.each {|x| puts x.class}
     # TEMP: Why are these implemented theories
-    @nodes.first.all_theory_variables
+    # @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,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 = @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}
@@ -81,7 +339,6 @@ class UnifiedChain < Chain
       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

data/lib/cauldron.rb

@@ -1,6 +1,6 @@
-
 require 'required'
 
 require 'cauldron/sexp2cauldron'
 require 'cauldron/conversion'
+require 'cauldron/demos'
 require 'cauldron/terminal'

data/lib/cauldron/demos.rb

@@ -0,0 +1,280 @@
+module Cauldron
+  
+  module Demos
+    
+    def convert_to_cauldron_test_cases(cases)
+      cases.inject([]) do |total,x|
+        cauldron_case = CTestCase.new
+        cauldron_case[:params] = x[0]
+        cauldron_case[:output] = x[1]
+        total << cauldron_case
+      end
+    end     
+    
+    def demo(id)
+      
+      if id == '1'
+        return demo_one
+      end
+      raise StandardError.new('Unable to find demo with id '+id)
+    
+    end
+      
+    def demo_one
+      
+      @demo_1_test_cases = convert_to_cauldron_test_cases(
+        [
+          [['sparky'],'sparky'],
+          [['kel'],'kel']
+        ]
+      )      
+      
+      # Create demo #1 chain
+      #   Create the head for the chain
+      head = Theory.new([],nil,[])    
+      
+      link_one_action = TheoryAction.new(
+        TheoryStatement.new(StringToTheory.run('Statement.new(Return.new,var1.params[var3])')),
+        StringToTheory.run('var1.statement_id')
+      )
+      # NOTE: I need to add one result so the theory can be flagged as complete - I might not need it 
+      #       to be complete -
+      link_one_result = TheoryResult.new(StringToTheory.run("if(var1.all_pass?(var2))\nreturn true\nend"))
+      link_one = Theory.new([],link_one_action,[link_one_result])
+      chain = Chain.new
+      chain = chain.extension_permutaions(head).first
+      chain = chain.extension_permutaions(
+        link_one,
+        {
+          1=>IntrinsicRuntimeMethod.new,
+          2=>IntrinsicTestCases.new,
+          3=>IntrinsicLiteral.new(0)
+        }
+      ).first
+      
+      # Now implement the chain
+      implemented_chain = chain.implement
+      
+      # TODO  It should generate the values too.(TheoryGenerator)
+      return {
+        :initial_method=>RuntimeMethod.new(MethodUsage.new(MethodParameter.new)),
+        :test_cases=>@demo_1_test_cases,
+        :chain=>chain,
+        :values=>{}
+      }            
+      
+    end
+        
+    # => "def method_3(var_0)\n\tif(var_0 == 'fish')\n\t\treturn 'animal'\n\tend\n\treturn 'vegetable'\nend\n"
+    def demo_two
+      @demo_2_test_cases = convert_to_cauldron_test_cases(
+        [
+          [['fish'],'animal'],
+          [['carrot'],'vegtable'],
+        ]
+      )
+      head = Theory.new([],nil,[])
+      
+      # Statementents
+      # => TODO Need a clear way to format theories
+      # => OpenStatement.new(If.new,Container.new(runtime_method.params[var1],Equivalent.new,test_cases[var2][:params][var3]))
+      # => Statement.new(Return.new,test_cases[var2][:result]) (added to the open statement)
+      # => Statement.new(Return.new,test_cases[var6][:result])
+      
+      # => TODO Don't actually want to include these connection hacks
+      
+      # => HEAD
+      head_result = TheoryResult.new(StringToTheory.run(
+        "if(var1.kind_of?(RuntimeMethod))\nreturn true\nend")
+      )
+      head_result_2 = TheoryResult.new(StringToTheory.run(
+        "if(var2.length == 2)\nreturn true\nend")
+      )      
+      head = Theory.new([],nil,[head_result,head_result_2])
+      
+      # => LINK #1
+      link_one_dependent = TheoryDependent.new(StringToTheory.run(
+          "if(var1.kind_of?(RuntimeMethod))\nreturn true\nend"
+        )
+      )
+      link_one_dependent_2 = TheoryDependent.new(StringToTheory.run(
+        "if(var2.length == 2)\nreturn true\nend")
+      )       
+      link_one_action = TheoryAction.new(
+        TheoryStatement.new(StringToTheory.run(
+          'OpenStatement.new(TheoryStatement.new(If.new,Container.new(var1.params[var3],Equivalent.new,var2[var4][:params][var5])))'
+        )),
+        StringToTheory.run('var1.statement_id')
+      )
+      link_one_result = TheoryResult.new(StringToTheory.run(
+        "if(var1.kind_of?(RuntimeMethod))\nreturn true\nend"
+      ))
+      link_one_result_2 = TheoryResult.new(StringToTheory.run(
+        "if(var2.length == 2)\nreturn true\nend"
+      ))
+      link_one_result_3 = TheoryResult.new(StringToTheory.run(
+        "if(var4.kind_of?(Fixnum))\nreturn true\nend"
+      ))            
+      link_one = Theory.new([link_one_dependent,link_one_dependent_2],link_one_action,[link_one_result,link_one_result_2,link_one_result_3])      
+      
+      # => LINK #2
+      link_two_dependent = TheoryDependent.new(StringToTheory.run(
+        "if(var1.kind_of?(RuntimeMethod))\nreturn true\nend"
+      ))
+      link_two_dependent_2 = TheoryDependent.new(StringToTheory.run(
+        "if(var2.length == 2)\nreturn true\nend"
+      ))
+      link_two_dependent_3 = TheoryDependent.new(StringToTheory.run(
+        "if(var4.kind_of?(Fixnum))\nreturn true\nend"
+      ))                                    
+      link_two_action = TheoryAction.new(
+        TheoryStatement.new(StringToTheory.run(
+          'Statement.new(Return.new,var2[var4][:output])'
+        )),
+        StringToTheory.run('var1.first.statement_id')
+      )
+      # link_two_result = TheoryResult.new(StringToTheory.run(
+        # "if(var1.history(var2[var4][:params]) == var2[var4][:output])\nreturn true\nend"
+      # ))   
+      link_two_result = TheoryResult.new(StringToTheory.run(
+        "if(var2[var4][:params].length == 1)\nreturn true\nend"
+      ))        
+      # TODO  Don't want to have to include this one
+      link_two_result_2 = TheoryResult.new(StringToTheory.run(
+        "if(var6.kind_of?(Fixnum))\nreturn true\nend"
+      ))
+      link_two_result_3 = TheoryResult.new(StringToTheory.run(
+        "if(var1.kind_of?(RuntimeMethod))\nreturn true\nend"
+      ))      
+                     
+      link_two = Theory.new(
+        [link_two_dependent,link_two_dependent_2,link_two_dependent_3],
+        link_two_action,
+        [link_two_result,link_two_result_2,link_two_result_3]
+      )      
+      
+      # => LINK #3
+      # link_three_dependent = TheoryDependent.new(StringToTheory.run(
+        # "if(var1.history(var2[var4][:params]) == var2[var4][:output])\nreturn true\nend"        
+      # ))
+      link_three_dependent = TheoryDependent.new(StringToTheory.run(
+        "if(var2[var4][:params].length == 1)\nreturn true\nend"        
+      ))         
+      link_three_dependent_2 = TheoryDependent.new(StringToTheory.run(
+        "if(var6.kind_of?(Fixnum))\nreturn true\nend"
+      ))
+      link_three_dependent_3 = TheoryDependent.new(StringToTheory.run(
+        "if(var1.kind_of?(RuntimeMethod))\nreturn true\nend"
+      ))      
+      link_three_action = TheoryAction.new(
+        TheoryStatement.new(
+          StringToTheory.run(
+            'Statement.new(Return.new,var2[var6][:output])'  
+          )
+        ),
+        StringToTheory.run('var1.statement_id')
+      )
+      #link_three_result = TheoryResult.new(StringToTheory.run(
+      #  "if(var1.history(var2[var6][:params]) == var2[var6][:output])\nreturn true\nend"
+      #))
+      link_three_result = TheoryResult.new(StringToTheory.run(
+        "if(var2[var4][:params].length == 1)\nreturn true\nend" 
+      ))
+      link_three_result_2 = TheoryResult.new(StringToTheory.run(
+        "if(var2.length == 2)\nreturn true\nend"
+      ))             
+      link_three_result_3 = TheoryResult.new(StringToTheory.run(
+        "if(var1.length == 2)\nreturn true\nend"
+      ))       
+      link_three = Theory.new(
+        [link_three_dependent,link_three_dependent_2,link_three_dependent_3],
+        link_three_action,
+        [link_three_result,link_three_result_2,link_three_result_3]
+      )         
+      
+      # => LINK #4
+      #link_four_dependent = TheoryDependent.new(StringToTheory.run(
+      #  "if(var1.history(var2[var6][:params]) == var2[var6][:output])\nreturn true\nend"
+      #))
+      link_four_dependent = TheoryDependent.new(StringToTheory.run(
+       "if(var1.kind_of?(RuntimeMethod))\nreturn true\nend"
+      ))
+      link_four_dependent_2 = TheoryDependent.new(StringToTheory.run(
+        "if(var2.length == 2)\nreturn true\nend"
+      ))                  
+      link_four_dependent_3 = TheoryDependent.new(StringToTheory.run(
+        "if(var1.length == 2)\nreturn true\nend"
+      ))          
+      link_four_result = TheoryResult.new(StringToTheory.run(
+        "if(var1.all_pass?(var2))\nreturn true\nend"
+      ))      
+      link_four = Theory.new(
+        [link_four_dependent,link_four_dependent_2,link_four_dependent_3],
+        nil,
+        [link_four_result]
+      )      
+      
+      chain = Chain.new
+      chains = chain.extension_permutaions(head)
+      chain = chains.first
+      
+      head_id = chain.first.theory_id
+      last_id = chain.last.theory_id
+      
+      values = {
+        1=>IntrinsicRuntimeMethod.new,
+        2=>IntrinsicTestCases.new,
+        3=>IntrinsicLiteral.new(0),
+        4=>IntrinsicLiteral.new(0),
+        5=>IntrinsicLiteral.new(0),
+        6=>IntrinsicLiteral.new(1)          
+      }
+      
+      chains = chain.extension_permutaions(
+        link_one,values
+      )
+      order = [head_id,link_one.theory_id,last_id]
+      chain = chains.detect do |c|
+        c.collect {|t| t.theory_id} == order
+      end      
+      
+      chains = chain.extension_permutaions(
+        link_two,values
+      )
+      order = [head_id,link_one.theory_id,link_two.theory_id,last_id]
+      chain = chains.detect do |c|
+        c.collect {|t| t.theory_id} == order
+      end
+      
+      chains = chain.extension_permutaions(
+        link_three,values
+      )
+      order = [head_id,link_one.theory_id,link_two.theory_id,link_three.theory_id,last_id]
+      chain = chains.detect do |c|
+        c.collect {|t| t.theory_id} == order
+      end
+      
+      chains = chain.extension_permutaions(
+        link_four,values
+      )
+      order = [head_id,link_one.theory_id,link_two.theory_id,link_three.theory_id,link_four.theory_id,last_id]
+      chain = chains.detect do |c|
+        c.collect {|t| t.theory_id} == order
+      end
+      
+      unified_chain = chain.unify_chain
+      
+      implemented_chain = chain.implement
+      
+      return {
+        :initial_method=>RuntimeMethod.new(MethodUsage.new(MethodParameter.new)),
+        :test_cases=>@demo_2_test_cases,
+        :chain=>chain,
+        :values=>{}
+      }            
+                  
+    end    
+
+  end
+  
+end