cauldron 0.1.5 → 0.1.6

data/lib/cauldron/template_base.rb

@@ -0,0 +1,14 @@
+module Cauldron
+
+  class TemplateBase
+
+    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    
+    
+  end
+
+end

data/lib/cauldron/tracer.rb

@@ -0,0 +1,55 @@
+module Cauldron
+
+  class Tracer
+
+    attr_reader :sexp, :results
+
+    def initialize(sexp)
+      @sexp = sexp
+      @results = []
+    end
+
+    def process(example)
+      object = Tracer.new(sexp)
+      object.instance_eval(Sorcerer.source(sexp, indent: true))
+      object.function(example.arguments.first)
+
+      History.new(object.results)
+    #rescue => e
+      # binding.pry
+      # Sorcerer.source(sexp, indent: true) 
+      # var0 = [5,7]
+    end
+
+    def record(line, depth, total_line, point, entry)
+      #h = Hash[*entry.flatten] 
+      h = Hash[*entry.flatten(1)]
+      h.merge!(:line => line)
+      h.merge!(:depth => depth)
+      h.merge!(:total_line => total_line)
+      h.merge!(:point => point)
+      h = h.reject {|key,value| key.to_s.match /^placeholder/ }
+      @results << h
+      #@results << #entry # TODO Only want the trace to have on result so it should probably be in the initilaize call only
+    end
+
+    def self.substitue_tracking
+      %q{
+      record("line", "depth", "total_lines", "point")
+      }
+    end
+
+    def self.tracking(line, depth, total_line, point)
+      a = %Q{
+        record(#{line}, #{depth}, #{total_line}, #{point}, local_variables.reject { |foo|
+          foo == :_
+        }.collect { |bar|
+          [bar, eval(bar.to_s)]
+        })
+      }   
+      Ripper::SexpBuilder.new(a).parse
+    end
+
+  end
+
+end

data/lib/cauldron/version.rb

@@ -1,3 +1,3 @@
 module Cauldron
-  VERSION = "0.1.5"
+  VERSION = "0.1.6"
 end

data/lib/pry_tester.rb

@@ -0,0 +1,76 @@
+class PryTester
+  extend Forwardable
+
+  attr_reader :pry, :out
+
+  def_delegators :@pry, :eval_string, :eval_string=
+
+  def initialize(target = TOPLEVEL_BINDING, options = {})
+    @pry = Pry.new(options.merge(:target => target))
+    @history = options[:history]
+
+    @pry.inject_sticky_locals!
+    reset_output
+  end
+
+  def eval(*strs)
+    reset_output
+    result = nil
+
+    strs.flatten.each do |str|
+      # Check for space prefix. See #1369.
+      if str !~ /^\s\S/
+        str = "#{str.strip}\n"
+      end
+      @history.push str if @history
+
+      if @pry.process_command(str)
+        result = last_command_result_or_output
+      else
+        result = @pry.evaluate_ruby(str)
+      end
+    end
+
+    result
+  end
+
+  def push(*lines)
+    Array(lines).flatten.each do |line|
+      @pry.eval(line)
+    end
+  end
+
+  def push_binding(context)
+    @pry.push_binding context
+  end
+
+  def last_output
+    @out.string if @out
+  end
+
+  def process_command(command_str)
+    @pry.process_command(command_str) or raise "Not a valid command"
+    last_command_result_or_output
+  end
+
+  def last_command_result
+    result = Pry.current[:pry_cmd_result]
+    result.retval if result
+  end
+
+  protected
+
+  def last_command_result_or_output
+    result = last_command_result
+    if result != Pry::Command::VOID_VALUE
+      result
+    else
+      last_output
+    end
+  end
+
+  def reset_output
+    @out = StringIO.new
+    @pry.output = @out
+  end
+end

data/ruby_to_sexp.rb

@@ -0,0 +1,74 @@
+require 'ripper'
+require 'sorcerer'
+require 'pp'
+
+sexp = Ripper::SexpBuilder.new(%q{
+var0.to_s
+}).parse
+pp sexp
+pp Sorcerer.source(sexp, indent: true)
+puts '===='
+
+sexp = Ripper::SexpBuilder.new(%q{
+def test(var0)
+  var0.bounce
+  var1.kick
+end
+}).parse
+pp sexp
+pp Sorcerer.source(sexp, indent: true)
+puts '===='
+
+
+sexp = Ripper::SexpBuilder.new(%q{
+var1 = var0.collect do |x|
+  x + 2
+end
+var2 = var1.collect do |x|
+  x.to_s
+end
+}).parse
+puts sexp.inspect
+pp sexp
+puts '-------'
+
+sexp = Ripper::SexpBuilder.new(%q{
+var0.collect do |x|
+  record(local_variable)
+end
+}).parse
+puts sexp.inspect
+pp sexp
+Sorcerer.source(sexp, indent: true)
+
+puts '================'
+sexp = Ripper::SexpBuilder.new(%q{
+var0.collect do |var1|
+  record(0)
+end
+record(1)
+}).parse
+puts sexp.inspect
+pp sexp
+Sorcerer.source(sexp, indent: true)
+
+puts '================'
+sexp = Ripper::SexpBuilder.new(%q{
+var0.collect do |var1|
+  var1 * 3 
+end
+}).parse
+pp sexp
+Sorcerer.source(sexp, indent: true)
+
+puts '================'
+sexp = Ripper::SexpBuilder.new(%q{
+def function(var0)
+  var0.collect do |var1|
+    record(0,1,1,local_variables.reject {|foo| foo == :_}.collect { |bar| [bar, eval(bar.to_s)] })
+  end
+  record(1,0,1,local_variables.reject {|foo| foo == :_}.collect { |bar| [bar, eval(bar.to_s)] })
+end
+}).parse
+pp sexp
+Sorcerer.source(sexp, indent: true)

data/sandbox.rb

@@ -12,6 +12,9 @@ require 'yaml'
 # 
 # puts 'Working'
 
+# === Pry ===
+# Pry::Code.new(@str).length 
+
 
 # unified_chain = Cauldron::Util::Saver.load(298)
 # runtime_method = Cauldron::Util::Saver.load(31)
@@ -19,6 +22,10 @@ require 'yaml'
 # 
 # puts unified_chain.describe
 
+# gem install ruby_parser
+# RubyParser.new.parse "1+1"
+
+# gem 'sexp_processor', '~> 4.4.3'
 
 #unified_chain.valid_mapping_permutations(runtime_method,test_cases)
 

data/sexp_to_ruby.rb

@@ -0,0 +1,150 @@
+require 'ripper'
+require 'sorcerer'
+require 'pp'
+
+# 1. ball.collect
+sexp = [:program,
+          [:stmts_add,
+            [:stmts_new], 
+            [:call, 
+              [:vcall, [:@ident, 'ball']],
+              :".",
+              [:@ident, 'bounce' ]
+            ] 
+          ]
+        ]
+
+# 2. 
+# ball.bounce
+# ball.kick
+sexp = [:program,
+          [:stmts_add,
+            [:stmts_add,
+              [:stmts_new], 
+                [:call, 
+                  [:vcall, [:@ident, 'ball']],
+                  :".",
+                  [:@ident, 'bounce' ]
+                ]             
+              ],
+            [:call, 
+              [:vcall, [:@ident, 'ball']],
+              :".",
+              [:@ident, 'kick' ]
+            ],        
+          ] 
+        ]
+# e.g.
+#  [:program, [:stmts_add, [:stmts_add, [:stmts_new], 'ball.bound'], 'ball.kick' ]
+
+bounce_call = [:call, 
+                [:vcall, [:@ident, 'ball']],
+                :".",
+                [:@ident, 'bounce' ]
+              ]
+kick_call =   [:call, 
+                [:vcall, [:@ident, 'ball']],
+                :".",
+                [:@ident, 'kick' ]
+              ]
+throw_call =  [:call, 
+                [:vcall, [:@ident, 'ball']],
+                :".",
+                [:@ident, 'throw' ]
+              ]              
+
+# 3. 
+# ball.bounce
+# ball.kick
+# ball.throw
+sexp =  [:program,
+          [:stmts_add,
+            [:stmts_add,
+              [:stmts_add,
+                [:stmts_new],
+                bounce_call
+              ],
+              kick_call
+            ],
+            throw_call
+          ]
+        ]
+
+# 4. 
+method_ident = [:@ident, "test"]
+params = [:paren, [:params, [[:@ident, "var0"]] ]]
+# def test(var0)
+#  var0.bounce
+#  var1.kick
+# end
+sexp =  [:program,
+          [:stmts_add,
+            [:stmts_new],
+            [:def,
+              method_ident,
+              params,
+              [:bodystmt,
+                [:stmts_add,
+                  [:stmts_add,
+                    [:stmts_add,
+                      [:stmts_new],
+                      bounce_call
+                    ],
+                    kick_call
+                  ],
+                  throw_call
+                ]
+              ]
+            ]
+          ]
+        ]
+
+# 5. 
+# var0.collect do |x|
+#   record(local_variable)
+# end
+
+var_collect = [:call, 
+                [:vcall, [:@ident, "var0"]],
+                :".",
+                [:@ident, "collect"]
+              ]
+var0_block_var =  [:block_var,
+                    [:params, [[:@ident, "x"]] ],
+                    false
+                  ]
+method_add_arg =  [:method_add_arg,
+                    [:fcall, [:@ident, "record"]],
+                    [:arg_paren,
+                      [:args_add_block,
+                        [:args_add,
+                          [:args_new],
+                          [:vcall, [:@ident, "local_variable"]]
+                        ]
+                      ]
+                    ]
+                  ]
+
+sexp =  [:program,
+          [:stmts_add,
+            [:stmts_new],
+            [:method_add_block,
+              var_collect,
+              [:do_block,
+                var0_block_var,
+                [:stmts_add,
+                  [:stmts_new],
+                  method_add_arg
+                ]
+              ]
+            ]
+          ]
+        ]
+
+
+pp Sorcerer.source(sexp, indent: true)
+puts Sorcerer.source(sexp, indent: true)
+
+
+sexp = [:call, [:vcall, [:@ident, 'var0']], :".", [:@ident, "chop"]]
+pp Sorcerer.source(sexp, indent: true)

data/spec/cauldron/actualized_composite_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+module Cauldron
+
+  describe ActualizedComposite do
+
+    let(:empty_composite) do
+      Cauldron::Solution::Composite.new([])
+    end
+
+    describe '#to_ruby' do
+
+      let(:nested_statement) do
+        Tree::TreeNode.new( 'x', StatementGenerator.new.default_template(['lion','bear'],:collect).new([0]) )
+      end
+
+      let(:composite) do
+        chop = StatementGenerator.new.default_template('lion',:chop).new([2])
+        nested_statement << Tree::TreeNode.new('x', chop)
+        Cauldron::Solution::Composite.new([nested_statement])
+      end
+
+      let(:examples) do
+        Cauldron::ExampleSet.new(
+          [ Cauldron::Example.new(
+              { arguments: [["lion", "bear"]], response: ["bea", "lio"]}
+            )
+          ]
+        )        
+      end
+
+      let(:subject) do
+        Cauldron::ActualizedComposite.new(
+          composite, examples
+        )
+      end
+
+      it 'prints the correct statement' do
+        subject.to_ruby.should == %q{var1 = var0.collect do |var2| var2.chop end}
+      end
+
+    end
+
+    describe '#histories' do
+
+      context %q{there is one example "var0 = ['lion','bear']"} do
+
+        let(:examples) do
+          Cauldron::ExampleSet.new(
+            [Cauldron::Example.new( {arguments: [['lion','bear']], response: 8} )]
+          )
+        end
+
+        context 'composite is empty' do
+
+          let(:subject) { Cauldron::ActualizedComposite.new(empty_composite, examples)}
+
+          it 'returns 1 history' do
+            subject.histories.length.should == 1
+          end
+
+          it 'history contains single log' do
+            subject.histories.first.logs.length.should == 1
+          end
+
+        end
+
+        context 'composite is "var0 = var1.collect { |var2|}' do
+
+          let(:containing_statement) do
+            StatementGenerator.new.default_template(['lion','bear'],:collect).new([0])
+          end
+
+          let(:composite) do
+            Cauldron::Solution::Composite.new(
+              [Tree::TreeNode.new("CHILD1", containing_statement )]
+            )
+          end
+
+          let(:subject) { Cauldron::ActualizedComposite.new(composite, examples)} 
+
+          # TODO total_line is going to be wrong
+          log_history = %q{
+            | {line: 0, depth: 1, total_line: 3, point: [0,0], var0: ['lion', 'bear'], var2: 'lion', var1: nil} |
+            | {line: 0, depth: 1, total_line: 3, point: [0,0], var0: ['lion', 'bear'], var2: 'bear', var1: nil} |
+            | {line: 0, depth: 0, total_line: 4, point: [1], var0: ['lion', 'bear'], var1: ['lion', 'bear'] } |
+          }
+
+          it 'contains a history with 3 entries' do
+            subject.histories.first.logs.length.should == 3
+          end
+          
+          it %Q{retuns the following history: #{log_history} } do
+            pending
+            # logs = [
+            #   {line: 0, depth: 1, var0: ['lion', 'bear'], var2: 'lion', var1: nil},
+            #   {line: 0, depth: 1, var0: ['lion', 'bear'], var2: 'bear', var1: nil},
+            #   {line: 1, depth: 0, var0: ['lion', 'bear'], var1: ['lion', 'bear'] }           
+            # ]
+            subject.histories.first.logs.should match_history(log_history)
+            #logs.should match_history(log_history)
+          end                 
+
+        end
+
+      end
+
+    end
+
+    describe '#extend_solution' do
+
+      let(:examples) do
+        Cauldron::ExampleSet.new(
+          [
+            Cauldron::Example.new( {arguments: [7], response: 8} ),
+            Cauldron::Example.new( {arguments: [10], response: 11} )
+          ]
+        )
+      end
+
+      let(:subject) { Cauldron::ActualizedComposite.new(empty_composite, examples)}
+
+      context 'there is only the numeric operator available' do
+
+        before(:each) do
+          Builder.stub(:available_statement_types).and_return [NumericOperator]
+        end
+
+        it 'returns 1 actualized composite' do
+          pending
+          subject.extend_solution.should have(1).composite
+        end
+
+      end
+
+    end
+
+  end
+
+end