cauldron 0.1.5 → 0.1.6

data/lib/cauldron/scope.rb

@@ -0,0 +1,24 @@
+module Cauldron
+
+  class Scope
+    include Enumerable
+
+    attr_reader :variables
+
+    def initialize(variables)
+      @variables = variables
+    end
+
+    def new_variable!
+      #@variables << "var#{variables.length+1}"
+      @variables << "var#{variables.length}"
+      @variables.last
+    end
+
+    def [](index)
+      variables[index]
+    end
+
+  end
+
+end

data/lib/cauldron/solution/composite.rb

@@ -0,0 +1,236 @@
+module Cauldron::Solution
+
+  class Composite
+
+    attr_reader :operators
+
+    def initialize(children)
+      raise StandardError.new('inital value should be an array') unless children.kind_of?(Array)      
+      @operators = children
+    end
+
+    def record(example)
+      # TODO params passed twice - and example not used at all
+      insert_tracking(example.params).process(example)
+    end
+
+    def end_points
+      results = []
+      operators.each do |x|
+        if x.content.branch?
+          results << [0,x.children.length]
+        end
+      end
+      results << [operators.length]
+    end
+
+    def clone_solution
+      #self.clone
+      tree_operators = operators.collect do |node|
+        Tree::TreeNode.new('x', node.content.clone_statement)
+      end
+      Composite.new(tree_operators)
+    end
+
+    def add_statement_at(statement, point)
+      if point.length == 2
+        container = self.operators[0]
+        #return self if container.length > 1 # TODO: Quick hack to get it working
+        container << Tree::TreeNode.new('SASA', statement)
+      elsif point.length == 1
+        operators << Tree::TreeNode.new('SASA', statement)
+      else
+        raise StandardError.new('Have not written code: '+point.inspect)
+      end
+      self
+    end
+
+    def insert_tracking(params)
+      scope = Cauldron::Scope.new(params.clone)
+
+      # TODO Might be useful
+      # trace = TracePoint.new(:call) do |tp|
+      #   p [tp.lineno, tp.event, tp.raised_exception]
+      # end
+
+      
+      # NEW: Implementation
+      m = %Q{
+        def function(#{params.join(',')})
+          #{to_ruby(Cauldron::Scope.new(params.clone))}
+        end
+      }
+
+      sexp = Ripper::SexpBuilder.new(m).parse
+      rendered_code = Sorcerer.source(sexp, indent: true)
+      caret = Cauldron::Caret.new
+
+      rendered_code = Sorcerer.source(sexp, indent: true).gsub(/end/,"\nend").split("\n").reject(&:empty?).join("\n")
+
+      # Generate tracking code with pending substitutions
+      tracked_code = []
+      rendered_code.each_line do |line|
+        #if line.match /end\s+/
+        if line.match /end/
+          tracked_code << Sorcerer.source(Ripper::SexpBuilder.new(Cauldron::Tracer.substitue_tracking).parse) #Sorcerer.source(Cauldron::Tracer.substitue_tracking)
+        end
+        tracked_code << line
+      end
+      sexp = Ripper::SexpBuilder.new(tracked_code.join("\n")).parse       
+      code_tracking  = Sorcerer.source(sexp, indent: true)
+      code_tracking.split("\n")
+
+      current_line = -1
+      total_lines = 0
+      new_tracked_code = []
+      last_line = nil
+      relative_line = 0
+      placeholder = nil
+      point = [0,0]
+      current_depth = 0
+      caret = Cauldron::Caret.new
+
+      points = end_points
+
+      code_tracking.split("\n").each do |line|
+
+        if line.match /record/
+          depth = (line.match(/^(\s+)/)[0].length / 2) -1
+          if depth > current_depth
+            relative_line = 0
+          end
+          current_depth = depth
+
+          new_tracked_code << last_line
+          new_tracked_code << Sorcerer.source(
+                                Cauldron::Tracer.tracking(relative_line, depth, total_lines, points.shift)
+                              )
+          new_tracked_code << placeholder
+        else
+          total_lines += 1
+
+          unless line['=']
+            placeholder = "#{'placeholder_'+rand(10000000000).to_s}"
+            last_line = "#{placeholder} = "+line
+          end
+
+          if last_line
+            if !last_line.match(/\s+end/).nil? || !last_line.match(/function/).nil? # || last_line.match /function/
+              last_line = nil
+              placeholder = nil
+            end
+          end
+
+          if line.match /end$/
+            unless line.strip == 'end'
+              line = line.gsub(/end$/,'')
+            end
+          end
+
+          new_tracked_code << line
+          current_line += 1
+        end
+        #total_lines += 1
+      end
+
+      # NOTE: Keep this to debug before conversion of S-EXP      
+      sexp = Ripper::SexpBuilder.new(new_tracked_code.join("\n")).parse
+      
+      Cauldron::Tracer.new(sexp)
+
+    end
+
+    def reset_and_track(caret)
+      caret.return_depth(0)
+      Cauldron::Tracer.tracking(caret.line, caret.current_depth, caret.total_lines)
+    end
+
+    def to_sexp(scope=Cauldron::Scope.new)
+
+      res = operators.collect do |operator|
+        #begin
+          operator.content.to_ruby(scope, operator.children)  
+        # rescue NoMethodError => e
+        #   binding.pry
+        # end
+        
+      end.join("\n")
+
+      sexp = Ripper::SexpBuilder.new(res).parse
+      return sexp
+    end
+
+    def to_ruby(scope)
+      return '' if operators.empty?
+      Sorcerer.source(to_sexp(scope))
+    end
+
+    def add_first_statement(statement)
+      [:stmts_add, [:stmts_new], statement]
+    end
+
+    def add_statement(statement, inner)
+      [:stmts_add, inner, statement]
+    end
+
+    def solution?(problems)
+      o = Object.new
+      m = %Q{
+        def function(#{problems.variables.join(',')})
+          #{to_ruby(problems.scope)}
+        end
+      }
+      o.instance_eval(m)
+
+      #o.function *problems.examples.first.arguments
+      problems.all? do |example|
+        o.function(*example.arguments) == example.response
+      end
+
+    # TODO: Remove this resque - it is just a temp
+    rescue NoMethodError => e
+      return false
+    rescue NameError => e
+      return false
+    rescue TypeError => e
+      return false
+    end
+
+    # TODO Drop this method
+    def successful?(problem)
+
+      # # TODO track the parameters of the operator
+      # operators.trace(problem)
+
+      # # TODO For now just evalute the code
+      # return true if problem[:arguments].first == problem[:response]    
+      # false
+
+      pt = PryTester.new
+
+      args = problem.arguments
+      variables = problem.params #(0...args.length).collect {|x| 'var'+x.to_s}
+      a = [
+        'def function('+variables.join(',')+');'+self.to_ruby(variables)+"; end", 
+        'function('+problem.arguments.collect {|x| to_programme(x) }.join(',')+')'
+      ]
+      
+      res = pt.eval(
+        ['def function('+variables.join(',')+');'+self.to_ruby(variables)+"; end", 'function('+problem.arguments.collect {|x| to_programme(x) }.join(',')+')']
+      )
+
+      problem.response == res
+    end
+
+    def to_programme(value)
+      if value.kind_of?(String)
+        return %Q{'#{value}'}
+      end
+      value.to_s
+    end
+
+    # TODO Add a safety evalutor
+    
+  end
+
+end

data/lib/cauldron/solution/one.rb

@@ -0,0 +1,49 @@
+# def function(var0)
+#   var0.collect { |x| x * 2 }
+# end
+
+module Cauldron::Solution
+
+  class One
+
+    def initialize
+
+    end
+
+    def successful?(problem)
+      return false unless problem.arguments.first.kind_of?(Array)
+      return false unless problem.arguments.first[0] * 2 == problem.response[0]
+      return false unless problem.arguments.first[1] * 2 == problem.response[1]
+      true    
+    end
+
+    def to_ruby(variables)
+      sexp =
+      [:method_add_block, 
+        [:call, 
+          [:vcall, 
+            [:@ident, variables[0]]
+          ], 
+          :".", 
+          [:@ident, "collect"]
+        ], 
+        [:brace_block, 
+          [:block_var, 
+            [:params, 
+              [[:@ident, "x"]]
+            ]
+          ], 
+          [
+            :binary, 
+            [:var_ref, [:@ident, "x"]],
+            :*,
+            [:@int, "2"]
+          ]
+        ]
+      ] 
+      Sorcerer.source(sexp)
+    end
+
+  end
+
+end

data/lib/cauldron/statement_generator.rb

@@ -0,0 +1,298 @@
+module Cauldron
+
+  class StatementGenerator
+
+    # Build appropriate classes that can build appropriate instances - instances 
+    # must have the constants
+    def build(instance,dynamic_methods,declare_variable=false)
+      dynamic_methods.collect do |x|
+        build_template(instance,x)
+      end
+    end
+
+    # TODO Change to build_blue_print
+    def build_template(instance, dynamic_method)
+      build_class(instance, dynamic_method)
+    end
+
+    def sexp_method_to_ruby(instance, dynamic_method)
+      %Q{
+        def to_ruby(scope, operators)
+          Sorcerer.source self.to_sexp(scope, operators)
+        end
+      }
+    end
+
+    def sexp_method_to_desc
+      %Q{
+        def to_desc
+          to_ruby( Cauldron::Scope.new(['var0']), [] )    
+        end
+      }      
+    end
+
+    def method_to_sexp(instance, dynamic_method)
+
+      # Does it expect arguments?
+      begin
+        instance.send(dynamic_method)
+      rescue ArgumentError => e
+        
+        number_of_arguments = e.message.match(/(\d+)\)/)[1].to_i
+
+        #statement = "scope[@indexes[0]] #{dynamic_method}"
+        statement = "scope[@indexes[0]]"
+
+        to_sexp_method = %Q^
+          def to_sexp(scope, operators)
+            Ripper::SexpBuilder.new(#{statement}).parse
+          end
+        ^        
+        # to_sexp_method = %Q^
+        #   def to_sexp(scope, operators)
+        #     Ripper::SexpBuilder.new("\#{scope[@indexes[0]]} + \#{constant}").parse 
+        #   end
+        # ^
+        return to_sexp_method
+      end
+
+      if instance.send(dynamic_method).class == Enumerator
+        %Q^
+          def to_sexp(scope, operators)
+            scope_var = scope.new_variable!
+            scope_var_two = scope.new_variable!
+            dynamic_method = '#{dynamic_method}'
+
+            first_variable = 'var'+@indexes[0].to_s
+            
+            a = "\#{scope_var} = \#{first_variable}.\#{dynamic_method} do |\#{scope_var_two}|"+"\n"
+            a += operators.collect {|x| x.content.to_ruby(scope, x.children) }.join("\n")
+            a += "\n"+"end"+"\n"
+            puts a
+            Ripper::SexpBuilder.new(a).parse
+
+          end
+        ^
+      else
+        %Q{
+          def to_sexp(scope, operators)
+            first_variable = 'var'+@indexes[0].to_s
+            [:call,
+              [:vcall, [:@ident, first_variable ]],
+              :".",
+              [:@ident, "#{dynamic_method}"]
+            ]
+          end        
+        }
+      end
+    end
+
+    def requires_arguments?(instance, dynamic_method)
+      instance.send(dynamic_method)
+      false
+    rescue ArgumentError => e
+      true
+    end
+
+    def expects_block?(instance, dynamic_method)
+      instance.send(dynamic_method).class == Enumerator
+    end
+
+    def branch_method(instance, dynamic_method)
+      if requires_arguments?(instance, dynamic_method)
+        return %q{
+          def branch?
+            false
+          end
+        }        
+      end
+
+      if expects_block?(instance, dynamic_method)
+        return %q{
+          def branch?
+            true
+          end          
+        }
+      end
+      %q{
+        def branch?
+          false
+        end          
+      }
+    end
+
+    def template_sexp(instance, dynamic_method)
+
+      res = %Q{
+
+        #{sexp_method_to_ruby(instance, dynamic_method)}
+
+        #{method_to_sexp(instance, dynamic_method)}
+
+        #{sexp_method_to_desc}
+
+        #{branch_method(instance, dynamic_method)}
+
+        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
+     
+      }
+      Ripper::SexpBuilder.new(res).parse
+    end
+
+    def dynamic_template_name(instance, dynamic_method)
+      dynamic_method_name = dynamic_method.to_s.gsub(/\+/,'Add')
+      dynamic_name = ('Dynamic'+'_'+instance.class.to_s+'_'+dynamic_method_name.to_s).camelize
+      dynamic_name+'Template'
+    end
+
+    def default_template(instance, dynamic_method)
+      blue_print = build_class(instance, dynamic_method)
+      blue_print.statement_classes.first        
+    end
+
+    def build_class(instance, dynamic_method)
+      sexp = template_sexp(instance, dynamic_method)
+      information = { constants: false }
+      
+      template_name = dynamic_template_name(instance, dynamic_method)
+
+      # http://ruby-doc.org/core-2.3.0/Class.html
+      # http://stackoverflow.com/questions/4113479/dynamic-class-definition-with-a-class-name
+      unless Object.const_defined? template_name
+        c = Object.const_set(
+              template_name,  
+              Class.new do
+
+                attr_reader :indexes, :dynamic_name, :sexp_methods
+                attr_accessor :failed_uses                
+
+                def initialize(information, sexp_methods)
+                  @information, @sexp_methods = information, sexp_methods
+                  @failed_uses = []
+                end  
+
+                # NOTE: These theses classes define the constants
+                def statement_classes(examples = nil)
+
+                  #binding.pry
+
+                  # Find the constants
+                  b = Object.const_set(
+                    self.class.to_s+rand(4000000).to_s,
+                    Class.new do
+
+                      include Cauldron::Operator
+                      include Cauldron::DynamicOperatorModule   
+
+                      attr_reader :indexes        
+                      attr_accessor :failed_uses     
+
+                      def initialize(indexes)
+                        @indexes = indexes
+                        @failed_uses = []
+                      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] }
+                        # TODO Presumes that only one variable is passed
+                        variable_numbers.collect { |x| new([x.to_i])}
+                      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 rip2
+                        %Q{
+                        def function(var0)
+                          #{Sorcerer.source(to_sexp(Cauldron::Scope.new(['var0']),[]), indent: true)}
+                        end
+                        }
+                      end
+
+                    end
+                  )
+                  b.class_eval(Sorcerer.source(sexp_methods, indent: true))
+                  [b]
+                end                 
+
+              end
+            )
+        
+        
+        #a = c.new(information, sexp.clone)
+
+        #return a.statement_classes.first        
+        return c.new(information, sexp.clone)
+      else
+        #a = eval(template_name).new(information, sexp.clone)
+        return eval(template_name).new(information, sexp.clone) #a.statement_classes.first
+      end
+
+      raise StandardError.new('Should not get here')
+    end
+
+  end
+
+end
+
+# TODO stacking mulitple rescues does not work
+# realizable?
+
+# def realizable?(composite, examples)
+#   o = Object.new
+#   composite.to_ruby(examples.scope)
+#   sexp = rip(composite,examples) 
+#   o.instance_eval(Sorcerer.source(sexp, indent: true))
+#   begin
+#     o.function(examples.examples.first.arguments.first)
+#   rescue NoMethodError
+#     # TODO Need to record failing tests here
+#     failed_uses << { composite:composite, examples: examples}
+#     return false
+#   end
+#   true
+# end