cauldron 0.1.5 → 0.1.6

data/lib/cauldron/operator/hash_key_value_operator.rb

@@ -0,0 +1,74 @@
+#http://www.ruby-doc.org/core-2.1.1/Hash.html
+#hsh[key] → value
+class HashKeyValueOperator
+
+  # var0[:foo]
+
+  def initialize(indexes)
+    @indexes = indexes
+    @constant = :foo
+    #@constant, @indexes = constant, indexes
+  end
+
+  def self.viable?(arguments, response)
+    return false unless arguments.all? { |x| x.kind_of?(Hash) }
+    true
+  end
+
+  def self.uses_constants?
+    true
+  end
+
+  def self.find_constants(problems)
+    problems.collect {|x| x.arguments.first.keys }.flatten
+  end
+
+  def successful?(problem)
+    if problem.arguments.first[@constant] == problem.response
+      return true
+    end
+    return false    
+  end
+
+  def to_ruby(scope, operators)
+    Sorcerer.source self.to_sexp(scope, operators)
+  end
+
+  def to_sexp(scope, operators)
+    [:aref,
+      [:vcall, 
+        [:@ident, scope[0]]
+      ], 
+      [:args_add_block, 
+        [
+          :args_add, 
+          [:args_new], 
+          sexp_index
+        ]
+      ]
+    ]
+  end 
+
+  def sexp_index
+    if @constant.kind_of?(Symbol)
+      a = [
+            :symbol_literal, 
+            [:symbol, [:@ident, @constant]],
+            [:string_add, [:@ident, @constant]]
+          ]
+      return a      
+    elsif @constant.kind_of?(String)
+      return [
+                :string_literal, 
+                [
+                  :string_add, 
+                  [:string_content], 
+                  [:@tstring_content, @constant ]
+                ]
+            ] 
+    else
+      raise StandardError.new('Unknown index')
+    end
+  end 
+
+end

data/lib/cauldron/operator/numeric_operator.rb

@@ -0,0 +1,115 @@
+class NumericOperator 
+
+  include Cauldron::Operator
+
+  # Maybe NumericOperation
+  ADDITION = 4
+
+  def initialize(indexes)
+    @indexes = indexes
+  end
+
+  # Is the problem suitable for a numeric operatio?
+  # e.g. can the .find_contants call be called without error
+  def self.viable?(arguments,output)
+
+    # 1. Only has one argument value
+    # 2. Argument is a numeric value
+    # 3. Response is numeric
+
+    # TODO  Need to save these viablility tests in shared (easily comparable) state.
+    #       e.g. so all viable operations can be found in one go. 
+
+    return false unless arguments.all? { |x| x.kind_of?(Numeric) }
+    return false unless output.kind_of?(Numeric)
+    true
+
+  end
+
+  def realizable?(histories)
+    parameters = histories.variable_permutations(@indexes.length)
+    parameters.each do |params|
+      begin
+        realize(params)
+      rescue TypeError
+        return false
+      end
+    end
+    true
+  end
+
+  def realize(params)
+    o = Object.new
+    a = %Q{
+      def function(var0)
+        #{Sorcerer.source(to_sexp(Cauldron::Scope.new(['var0']),[]), indent: true)}
+      end
+    }
+    o.instance_eval(a)
+    o.function(*params.values)
+  end
+
+  def to_sexp(scope, operators)
+    [:binary, [:@ident, scope[@indexes[0]] ] , :+, [:@int, ADDITION.to_s]]
+  end
+
+  def to_ruby(scope, operators)
+    Sorcerer.source self.to_sexp(scope, operators)
+  end
+
+  def build(operators, scope)
+    to_sexp(scope)    
+  end  
+
+  # Operator for "x + n" e.g. x + 1
+  # Does the input match the answer
+  def successful?(problem)
+    if (problem[:arguments].first + ADDITION) == problem[:response]
+      return true
+    end
+    return false
+  end
+
+  def self.find_constants(problems)
+    problems.collect {|x| x.response - x.arguments.first }.uniq
+  end
+
+  def self.uses_constants?
+    true
+  end
+
+  def self.uses_block?
+    false
+  end
+
+  def branch?
+    false
+  end
+
+  def context_realizable?(context)
+    vars = context.keys.select {|x| x.match(/var\d/) }
+    var_names = vars.collect(&:to_s)
+    
+    first_variable = 'var'+@indexes[0].to_s
+
+    a = %Q{
+    def function(#{first_variable})
+      #{Sorcerer.source(to_sexp(Cauldron::Scope.new(var_names), []), indent: true)}
+    end
+    }       
+    
+    o = Object.new
+    o.instance_eval(a)
+
+    begin
+      #o.function(*vars.collect {|x| context[x] })  
+      o.function context[first_variable.to_sym]
+    rescue NoMethodError => e
+      return false
+    rescue StandardError => e
+      puts e
+    end
+    return true    
+  end
+    
+end

data/lib/cauldron/operator/string_asterisk_operator.rb

@@ -0,0 +1,131 @@
+class StringAsteriskOperator
+
+  # var0 * 3
+
+  # TODO Possibly include the scope of the index
+  # a = 5
+  # ['sdsd'].each do |b|
+  #   c = 5
+  # end
+  # (1...6).each do |d|
+  #   g = d
+  # end
+
+  # [0] = ['a']
+  # [1] = ['b', 'c']
+  # [2] = ['g', 'd']
+
+  # Although it should probably be
+  # [0] = [ ['a'] ]
+  # [1] = [ ['b', 'c'], ['g', 'd'] ]
+  #
+  # Or the order it was added might be more useful - e.g. last variable, second last variable or first variable
+  # - variable at depth(1)[1] - stepUp(1).first
+
+  def initialize(indexes)
+    @indexes = indexes
+    @constant = 2
+    #@constant, @indexes = constant, indexes
+  end
+
+  def self.instances(histories, composite, examples, insert_points)
+
+    # TEMP
+    unless examples.class == ExampleSet
+      raise StandardError.new('Examples should be an example')
+    end
+
+    # Print out each insertable statements
+    scope = examples.scope
+
+    # self.init([0]).to_ruby(scope)
+    # - this will print out "var0.chop"
+
+    # Get the variables available at each point
+    results = []
+
+    insert_points.each do |point|
+
+      # Find the variables at a particular point
+      # TODO Change to test
+      contexts = histories.contexts_at(point)
+      composites = context_instances(contexts)
+
+      composites.each do |x|
+        if contexts.all? do |context|
+          x.context_realizable?(context)
+        end
+          results << extend_actualized_composite(x, composite, examples, point)
+        end
+      end
+
+    end
+    
+    results
+  end  
+
+  # def self.instances(context_history, target)
+  #   res = history_goals(context_history, target)
+
+  #   possible_constant = res.collect do |x|
+  #     x[1].scan( x[0][:x] ).count
+  #   end.uniq
+
+  #   if possible_constant.length == 1
+  #     #return [StringAsteriskOperator.new([1],possible_constant.first)]
+  #     return [StringAsteriskOperator.new([1])]
+  #   end
+
+  # end
+
+  def self.history_goals(context_history,target)
+    variables = context_history.first.keys
+    context_history.each {|x| x[variables.first] }.zip(target)
+  end
+
+  def self.find_constants(problems)
+    return [] unless problems.all? { |x| x.response.kind_of?(String) }
+    problems.collect {|x| x.response.scan(x.arguments.first).count }.reject {|x| x == 0}
+  end
+
+  def self.viable?(arguments,output)
+    return false unless output.kind_of?(String)
+    return false unless arguments.first.kind_of?(String)
+    true
+  end
+
+  def self.uses_constants?
+    true
+  end
+
+  def self.uses_block?
+    false
+  end
+
+  def branch?
+    false
+  end 
+
+  def successful?(problem)
+    return true if problem[:arguments].first*@constant == problem[:response]    
+    false
+  end
+
+  def to_ruby(scope, operators)
+    Sorcerer.source self.to_sexp([], scope)
+  end
+
+  # def to_sexp(operators, scope)
+  #   [:binary, [:vcall, [:@ident, scope[@indexes[0]] ]], :*, [:@int, @constant]]
+  # end
+  def to_sexp(scope, children)
+    first_variable = 'var'+@indexes[0].to_s
+    Ripper::SexpBuilder.new(%Q{#{first_variable} * #{@constant}}).parse
+  end  
+
+  # TODO Get rid of the defined names
+  def build(operators, scope)
+    to_sexp(operators, scope)
+  end
+
+end

data/lib/cauldron/operator/to_s_operator.rb

@@ -0,0 +1,18 @@
+class ToSOperator
+
+  def initialize(indexes)
+    @indexes = indexes
+  end
+
+  def build(operators, scope)
+    [
+      :call,
+      [:vcall, 
+        [:@ident, scope[@indexes[0]]]
+      ],
+      :".",
+      [:@ident, "to_s"]
+    ]  
+  end
+
+end

data/lib/cauldron/operator/var_collect_operator.rb

@@ -0,0 +1,29 @@
+module Cauldron
+
+  class VarCollectOperator
+
+    def initialize(indexes)
+      @indexes = indexes
+    end
+
+    def to_ruby(contents, variables)
+      Sorcerer.source self.to_sexp( contents ,variables)
+    end
+
+    def to_sexp(scope, operators)
+      scope_var = scope.new_variable!
+      second_scope_var = scope.new_variable!
+      if operators.empty?
+        return [:stmts_add, [:stmts_new], [:assign, [:var_field, [:@ident, scope_var ]], [:method_add_block, [:call, [:vcall, [:@ident, scope[@indexes[0]]]], :".", [:@ident, "collect"]], [:do_block, [:block_var, [:params, [[:@ident, second_scope_var]], nil, nil, nil, nil, nil, nil], false], [:stmts_add, [:stmts_new], [:var_ref, [:@ident, second_scope_var]]]]]]]
+      else
+        return [:stmts_add, [:stmts_new], [:assign, [:var_field, [:@ident, scope_var ]], [:method_add_block, [:call, [:vcall, [:@ident, scope[@indexes[0]]]], :".", [:@ident, "collect"]], [:do_block, [:block_var, [:params, [[:@ident, second_scope_var]], nil, nil, nil, nil, nil, nil], false], [:stmts_add, [:stmts_new], operators.first.content.build([], scope) ]]]]]
+      end
+    end
+
+    def build(children, scope)
+      to_sexp(scope, children)
+    end   
+
+  end
+
+end

data/lib/cauldron/pot.rb

@@ -4,20 +4,59 @@ module Cauldron
 
     def solve(problems)
 
+      example_set = Cauldron::ExampleSet.new(problems.collect {|x| Cauldron::Example.new(x) })
+      
       # Identify the relationship
-      relationship = find_relationship(problems)
+      
+      # Pry::Code
+      # TODO Change term to solution
+      if find_saved_solution(example_set)
+        variables = example_set.variables
+        solution = find_saved_solution(example_set)
+        sexp = Ripper::SexpBuilder.new('def function('+variables.join(',')+');'+solution.to_ruby(variables)+"; end").parse
+        return Sorcerer.source(sexp, indent: true)        
+      end
+      relationship = find_relationship(example_set)
 
       # Generate if statements
       result = ''
 
-      # Add the arguments
-      args = problems.first[:arguments]
-      variables = (0...args.length).collect {|x| 'var'+x.to_s}
-      result = 'def function('+variables.join(',')+')'+"\n"
-      result << relationship.to_ruby
-      result += 'end'
+      variables = example_set.variables
+      #sexp = Ripper::SexpBuilder.new('def function('+variables.join(',')+');'+relationship.to_ruby(variables)+"; end").parse
+      sexp = Ripper::SexpBuilder.new('def function('+variables.join(',')+');'+relationship.to_ruby(example_set.scope)+"; end").parse
+
+      Sorcerer.source(sexp, indent: true)
+      
+    end
+
+    def chain_operators(problems,operators)
+      # TODO Presumes only two operators
+
+      operators[0].to_ruby( [
+        Tree::TreeNode.new("CHILD1", operators[1])
+      ], Cauldron::Scope.new(['var0']) )
+    end 
+
+    def single_viable_operators(problems)
+
+      operations = [ 
+        NumericOperator, ArrayReverseOperator, 
+        HashKeyValueOperator, StringAsteriskOperator,
+        ConcatOperator
+      ]
+
+      # Try each possible operation
+      viable_option_classes = []
+      operations.each do |operation_class|
+
+        # Are all the problems viable for this operation
+        if problems.all? {|x| operation_class.viable?(x.arguments,x.response) }
+          viable_option_classes << operation_class
+        end
+
+      end
 
-      result
+      viable_option_classes
 
     end
 
@@ -30,33 +69,104 @@ module Cauldron
       value.to_s
     end
 
-    def find_relationship(problems)     
+    def build_operators(operation_class,problems)
+      results = []
+      if operation_class.uses_constants?
+        
+        possible_constants = operation_class.find_constants(problems)
 
-      operations = [NumericOperator, ConcatOperator, ArrayReverseOperator]
+        possible_constants.each do |constant|
+          #operator = operation_class.new([0],constant)
+          operator = operation_class.new([0])
+          results << operator
+        end
+      else
 
-      # Try each possible operation
-      operations.each do |operation_class|
+        # Does the operator always result in the correct solution
+        operator = operation_class.new([0])
+        results << operator                 
 
-        # Are all the problems viable for this operation
-        if problems.all? {|x| operation_class.viable?(x[:arguments],x[:response]) }
-          possible_constants = operation_class.find_constants(problems)
-          possible_constants.each do |constant|
-            operator = operation_class.new(constant)
-
-            # Does the operator always result in the correct solution
-            if problems.all? {|x| operator.successful?(x) }
-              return operator
-            end
-          end
+      end
+      results
+    end
+
+    # BRUTE FORCE - Loop through all the solutions
+    def find_saved_solution examples
+      solutions = [
+        Cauldron::Solution::One.new
+      ]
+      successful_solutions = solutions.select do |solution|
+        examples.all? { |problem| solution.successful?(problem) }
+      end
+      return successful_solutions[0] unless successful_solutions.empty?
+      nil
+    end
+
+    def find_relationship(examples)     
+
+      # ==== NEW APPROACH ====
+
+      new_composites =  [ 
+                          Cauldron::ActualizedComposite.new(
+                            Cauldron::Solution::Composite.new([]), 
+                            examples
+                          )
+                        ]
+      itterations = 0
+      until itterations == 2
+
+        new_composites = extended_composites(new_composites)
+
+        if new_composites.any? {|x| x.solution?(examples) }
+          return new_composites.select {|x| x.solution?(examples) }.first.composite
+        end
+        itterations += 1
+      end
+      
+      # 1. TRY TO FIND SOLUTION via the history
+      # 2. Desired history
+      # 3. Chaing matching history
+
+      # ================== END HERE ===============
+
+      solutions = []
+      single_viable_operators(examples).each do |operation_class|
+
+        operators = build_operators(operation_class,examples)
+        operators.each do |operator|
+          root = Tree::TreeNode.new("ROOT", "Root Content")
+          root << Tree::TreeNode.new("CHILD1", operator)
+          solutions << Cauldron::Solution::Composite.new(root.children)
         end
+      end
 
+      solutions.each do |solution|
+        if solution.solution?(examples)
+          return solution
+        end
       end
 
-      if IfRelationship.match? problems
-        return IfRelationship.new(problems)
+      # operator_chains = viable_double_operators(problems)
+
+      # operator_chains.each do |operators|
+        
+      #   code = build_chain_operator(operators,problems)
+      #   if problems.all? {|x| code.successful?(x) }
+      #     return code
+      #   end
+      # end
+
+      if IfRelationship.match? examples
+        return IfRelationship.new(examples)
       end
-      IfRelationShip.new(problems)
+      IfRelationShip.new(examples)
     end
+
+    def extended_composites(actualized_composites)
+      actualized_composites.inject([]) do |total, x|
+        total += x.extend_solution; total
+      end
+    end 
     
   end