cauldron 0.1.5 → 0.1.6

data/lib/cauldron/history.rb

@@ -0,0 +1,34 @@
+module Cauldron
+
+  class History
+
+    attr_reader :logs
+
+    def initialize(logs)
+      @logs = logs
+    end
+
+    def variables
+      results = []
+      @logs.select do |line|
+        results += line.keys.select {|x| x.match(/var*/) }
+      end
+      results
+    end
+
+    def values(variable_name)
+      @logs.inject([]) do |total,line|
+        if line.has_key?(variable_name)
+          total << line[variable_name]
+        end
+        total
+      end
+    end
+
+    def insert_points
+      logs.collect {|x| x[:point] }.uniq
+    end
+
+  end
+
+end

data/lib/cauldron/if_relationship.rb

@@ -1,4 +1,4 @@
-class IfRelationship < Relationship
+class IfRelationship #< Relationship
 
   # TODO Need to change to IfSolution probably
 
@@ -6,15 +6,13 @@ class IfRelationship < Relationship
     @problems = problems
   end
 
-  def to_ruby
+  def to_ruby(variables)
 
     # Add the arguments
-    args = @problems.first[:arguments]
-    variables = (0...args.length).collect {|x| 'var'+x.to_s}
     result = ''
     @problems.each_with_index do |x,i|
-      result += '  if '+variables[0].to_s+' == '+quote(x[:arguments][0])+"\n"
-      result += '    return '+quote(x[:response])+"\n"
+      result += '  if '+variables[0].to_s+' == '+quote(x.arguments[0])+"\n"
+      result += '    return '+quote(x.response)+"\n"
       result += '  end'+"\n"
     end    
     result

data/lib/cauldron/number_addition_template/add_five.rb

@@ -0,0 +1,71 @@
+module Cauldron
+
+  module NumberAdditionTemplate
+
+    class AddFive
+
+      attr_reader :indexes
+
+      def initialize(indexes)
+        @indexes = indexes
+      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
+          return false
+        end
+        return true
+   
+      end
+
+      def to_sexp(scope, children)
+        first_variable = 'var'+@indexes[0].to_s
+        #binding.pry
+        #'var0 + 5'
+        #''
+        puts %Q{#{first_variable} + 5}
+        Ripper::SexpBuilder.new(%Q{#{first_variable} + 5}).parse
+      end
+
+      def clone_statement
+        # TODO Need to clone the sexp methods
+        # o = DynamicOperator.new(@information, @sexp_methods)
+        # o.instance_eval(Sorcerer.source(@sexp_methods, indent: true))
+        # o
+        self.class.new(@indexes.clone)
+      end
+
+      def to_ruby(scope, operators)
+        Sorcerer.source to_sexp(scope, operators)
+      end  
+
+      def branch?
+        false
+      end              
+
+    end
+
+  end
+
+end

data/lib/cauldron/number_addition_template/template.rb

@@ -0,0 +1,56 @@
+module Cauldron
+
+  module NumberAdditionTemplate
+
+    class Template < Cauldron::TemplateBase
+
+      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? { |context| x.context_realizable?(context) }
+              results << extend_actualized_composite(x, composite, examples, point)
+            end
+            #results << extend_actualized_composite(x, composite, examples, point)
+          end
+        end
+
+        results
+      end
+
+      def self.context_instances(contexts)
+        temp = []
+        contexts.each do |context|
+          temp << context.keys.collect(&:to_s).select {|x| x.match(/var\d/) }
+        end
+        results = temp.flatten.uniq
+        
+        variable_numbers = results.collect { |x| x.match(/var(\d+)/)[1] }
+        variable_numbers.collect { |x| Cauldron::NumberAdditionTemplate::AddFive.new([x.to_i])}
+      end      
+
+    end
+
+  end
+
+end

data/lib/cauldron/operator.rb

@@ -0,0 +1,62 @@
+module Cauldron
+
+  module Operator   
+    
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def 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 context_instances(contexts)
+        temp = []
+        contexts.each do |context|
+          temp << context.keys.collect(&:to_s).select {|x| x.match(/var\d/) }
+        end
+        results = temp.flatten.uniq
+        
+        variable_numbers = results.collect { |x| x.match(/var(\d+)/)[1] }
+        variable_numbers.collect { |x| new([x.to_i])}
+      end      
+
+    end
+
+  end
+
+end

data/lib/cauldron/operator/array_reverse_operator.rb

@@ -0,0 +1,160 @@
+class ArrayReverseOperator
+
+  def initialize(indexes)
+    raise StandardError.new('Need at least one item') if indexes.empty?
+    @indexes = indexes
+  end  
+
+  # Matching in 
+  def successful?(problem)
+    # NOTE - for the future - like the idea of not actually calling the method
+    # input.length.each do |i|
+    # does input[0] == output[input.length-0]
+    # does input[1] == output[input.length-1]
+    # does input[3] == output[input.length-3]
+    # end
+    
+    # in this case x.reverse will work
+    return true if problem[:arguments].first.reverse == problem[:response]
+    false
+  end
+
+  # 1. Only has one argument value
+  # 2. Argument is an array value
+  # 3. Response is an array 
+  def self.viable?(arguments,output)
+    return false unless arguments.length == 1
+    return false unless arguments.all? { |x| x.kind_of?(Array) }
+    return false unless output.kind_of?(Array)
+    true
+  end
+
+  def self.uses_constants?
+    false
+  end
+
+  def self.find_constants(problems)
+    []
+  end
+
+  def self.uses_block?
+    false
+  end
+
+  def self.process(arguments)
+    arguments.collect {|x| x.reverse }
+  end
+
+  def to_ruby(operators, scope)
+    Sorcerer.source build(operators, scope)
+  end
+
+  def build(operators, scope)
+    to_sexp(operators, scope)
+  end
+
+  def to_sexp(scope, operators)
+    [:call, 
+      [:vcall, 
+        [:@ident, scope[@indexes[0]] ]
+      ], 
+      :".", 
+      [:@ident, "reverse"]
+    ]    
+  end
+
+  def branch?
+    false
+  end
+
+  def self.init(indexes)
+    self.new(indexes)
+  end
+
+  def self.instances(histories, composite, examples, insert_points)
+
+    # TEMP
+    unless examples.class == Cauldron::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)
+
+      # scopes = scopes_at_point(point)
+
+      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.extend_actualized_composite(x, container, examples, point)
+    cloned_container = container.clone_solution
+    cloned_container.add_statement_at(x, point)
+    cloned_container
+    Cauldron::ActualizedComposite.new(cloned_container, examples)
+  end  
+
+  def clone_statement
+    self.class.init(@indexes.clone)
+  end  
+
+  def context_realizable?(context)
+    
+    vars = context.keys.select {|x| x.match(/var\d/) }
+    var_names = vars.collect(&:to_s)
+
+    a = %Q{
+    def function(var0)
+      #{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] })  
+    rescue NoMethodError => e
+      return false
+    rescue StandardError => e
+      puts e
+    end
+    return true
+    
+  end  
+
+  def self.context_instances(contexts)
+    results = []
+    contexts.each do |context|
+      results << context.keys.collect(&:to_s).select {|x| x.match(/var\d/) }
+    end
+    results = results.flatten.uniq
+    variable_numbers = results.collect { |x| x.match(/var(\d+)/)[1] }
+    variable_numbers.collect { |x| init([x.to_i])}
+  end  
+
+end

data/lib/cauldron/operator/concat_operator.rb

@@ -0,0 +1,72 @@
+class ConcatOperator
+
+  include Cauldron::Operator
+
+  def initialize(indexes)
+    @indexes = indexes
+    @constant = 'bar'
+  end
+
+  def self.viable?(arguments, response)
+    return false unless arguments.all? { |x| x.kind_of?(String) }
+    return false unless response.kind_of?(String)
+    # TODO - Only accpets one argument
+    true
+  end
+
+  def self.find_constants(problems)
+    problems.examples.inject([]) do |total, x| 
+      result = x.response.gsub( Regexp.new('^'+x.arguments.first),'')
+      total << result unless result == x.response
+      total
+    end.uniq
+  end
+
+  def self.uses_constants?
+    true
+  end
+
+  def self.uses_block?
+    false
+  end  
+
+  def branch?
+    false
+  end
+
+  # Operator for "x.concat("bar")"
+  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 build(operators, scope)
+    to_sexp(scope)
+  end
+
+  def to_sexp(scope, operators)
+    first_variable = 'var'+@indexes[0].to_s
+    [:program,
+     [:stmts_add,
+      [:stmts_new],
+      [:method_add_arg,
+       [:call,
+        [:vcall, [:@ident, first_variable ]],
+        :".",
+        [:@ident, "concat"]],
+       [:arg_paren,
+        [:args_add_block,
+         [:args_add,
+          [:args_new],
+          [:string_literal,
+           [:string_add, [:string_content], [:@tstring_content, @constant]]]],
+         false]]]]]
+  end
+
+end