cauldron 0.1.5 → 0.1.6

data/spec/cauldron/solution/composite_spec.rb

@@ -0,0 +1,421 @@
+require 'spec_helper'
+
+module Cauldron::Solution
+  
+  describe 'Composite' do
+
+    describe '#clone_solution' do
+
+      let(:composite) do
+        Cauldron::Solution::Composite.new([])
+      end   
+
+      it 'creates a new composite' do
+        composite.clone_solution.object_id.should_not == composite.object_id
+      end
+
+      context %q{it is: 
+        def function(var0)
+          var0.chop
+        end
+      } do
+
+        let(:containing_statement) do
+          Cauldron::StatementGenerator.new.default_template('lion',:chop).new([0])
+        end
+
+        let(:composite) do
+          Cauldron::Solution::Composite.new(
+            [Tree::TreeNode.new("CHILD1", containing_statement )]
+          )
+        end
+
+        it 'has different operators' do
+          composite.clone_solution.operators.object_id.should_not == composite.operators.object_id
+        end             
+
+      end
+
+    end
+
+    describe '#end_points' do
+
+      context 'with empty composite' do
+
+        let(:composite) do
+          Cauldron::Solution::Composite.new([])
+        end
+
+        it 'returns [[0]]' do
+          composite.end_points.should include([0])
+        end
+
+      end
+
+      context %q{it is: 
+        def function(var0)
+          var0.chop
+        end
+      } do
+
+        let(:containing_statement) do
+          Cauldron::StatementGenerator.new.default_template('lion',:chop).new([0])
+        end
+
+        let(:composite) do
+          Cauldron::Solution::Composite.new(
+            [Tree::TreeNode.new("CHILD1", containing_statement )]
+          )
+        end        
+
+        it 'returns [[1]]' do
+          composite.end_points.should include([1])
+        end
+
+        it 'has 1 point' do
+          composite.end_points.length.should == 1
+        end
+
+      end
+
+      context %q{it is: 
+        def function(var0)
+          var2 = var0.collect do |var1|
+          end
+        end
+      } do
+
+        let(:containing_statement) do
+          Cauldron::StatementGenerator.new.default_template(['lion','bear'],:collect).new([0])
+        end
+
+        let(:composite) do
+          Cauldron::Solution::Composite.new(
+            [Tree::TreeNode.new("CHILD1", containing_statement )]
+          )
+        end  
+
+        it 'has 2 points' do
+          composite.end_points.length.should == 2
+        end
+
+        it 'has point [[1]]' do
+          composite.end_points.should include([1])
+        end
+
+        it 'has point [[0,0]]' do
+          composite.end_points.should include([0,0])
+        end                    
+
+      end
+
+      context %q{it is: 
+        def function(var0)
+          var2 = var0.collect do |var1|
+            var1.chop
+          end
+        end
+      } do
+
+        let(:var1_chop) do
+          Cauldron::StatementGenerator.new.default_template('lion',:chop).new([0])
+        end
+
+        let(:containing_statement) do
+          Cauldron::StatementGenerator.new.default_template(['lion','bear'],:collect).new([0])
+        end
+
+        let(:composite) do
+          statement = Tree::TreeNode.new("CHILD1", containing_statement )
+          statement << Tree::TreeNode.new("CHILD1", var1_chop )
+          Cauldron::Solution::Composite.new(
+            [statement]#[Tree::TreeNode.new("CHILD1", containing_statement )]
+          )
+        end  
+
+        it 'has 2 points' do
+          composite.end_points.length.should == 2
+        end   
+
+        it 'has point [[1]]' do
+          composite.end_points.should include([1])
+        end             
+
+        it 'has point [[0,1]]' do
+          composite.end_points.should include([0,1])
+        end        
+
+      end
+
+    end
+
+    describe '#record' do
+
+      context %q{there is one example "var0 = ['lion','bear']"} do
+
+        let(:example) do 
+          Cauldron::Example.new( {arguments: [['lion','bear']], response: 8} )
+        end
+
+        context 'composite is "var0 = var1.collect { |var2|}' do
+
+          let(:containing_statement) do
+            Cauldron::StatementGenerator.new.default_template(['lion','bear'],:collect).new([0])
+          end
+
+          let(:composite) do
+            Cauldron::Solution::Composite.new(
+              [Tree::TreeNode.new("CHILD1", containing_statement )]
+            )
+          end
+
+          it 'returns a history with 3 log entries' do
+            composite.record(example).logs.length.should == 3
+          end
+
+        end
+
+      end
+
+    end
+
+    describe '#solution?' do
+
+      let(:problems) do
+        Cauldron::ExampleSet.new(
+          [
+            Cauldron::Example.new({ arguments: [["lion", "bear"]], response: ["bear", "lion"]}),
+            Cauldron::Example.new({ arguments: [["foo", "bar"]], response: ["bar", "foo"]})
+          ]
+        )
+      end
+
+      let(:composite) do
+        Cauldron::Solution::Composite.new(
+          [Tree::TreeNode.new("CHILD1", Cauldron::ArrayCollectTemplate::Default.new([0]))]
+        )
+      end
+
+      it 'is false' do
+        composite.solution?(problems).should == false
+      end
+
+      context "using valid chop example" do
+
+        let(:examples) do
+          Cauldron::ExampleSet.new(
+            [
+              Cauldron::Example.new({ arguments: ["Sparky"], response: 'Spark'}),
+              Cauldron::Example.new({ arguments: ["Kel"], response: 'Ke'})
+            ]
+          )
+        end
+
+        let(:dynamic_operator) do
+          Cauldron::StatementGenerator.new.default_template('string',:chop).new([0])
+        end        
+
+        let(:composite) do
+          Cauldron::Solution::Composite.new(
+            [Tree::TreeNode.new("CHILD1", dynamic_operator)]
+          )
+        end
+
+        it 'is true' do
+          composite.solution?(examples).should == true
+        end
+
+      end      
+
+    end
+
+    describe '#insert_tracking' do
+
+      context %q{
+        given a composite:
+          def function(params)
+
+          end
+        } do
+
+          # code =  """
+          #         """
+        let(:params) { ['var0'] }
+
+        it %q{
+          generates a method:
+            def function(params)
+              record(0,0,1,[0],local_variables.reject {|foo| foo == :_}.collect { |bar| [bar, eval(bar.to_s)] })
+            end
+          } do
+            Composite.new([]).insert_tracking(params).sexp.should match_code_of( %q{
+def function(var0)
+  record(0,0,1,[0],local_variables.reject {|foo| foo == :_}.collect { |bar| [bar, eval(bar.to_s)] })
+end
+})
+        end
+
+      end
+
+    end
+
+    describe '#to_ruby' do
+
+      context "hasn't any operators" do
+
+        let(:variables) { Cauldron::Scope.new(['var0']) }
+
+        let(:subject) do
+          Cauldron::Solution::Composite.new([])
+        end
+
+        it "doesn't raise an error" do
+          expect{
+            subject.to_ruby( variables )
+          }.not_to raise_error
+        end
+
+      end
+
+      context 'first line' do
+
+        context 'has operator "Array#collect"' do
+
+          let(:array_collect) { Cauldron::ArrayCollectTemplate::Default.new([0]) }
+
+          let(:tree) do
+            # Tree::TreeNode.new("ROOT", "Root Content").tap do |root|
+            #   root << Tree::TreeNode.new("CHILD1", array_collect)
+            #   root << Tree::TreeNode.new("CHILD2", string_asterisk)
+            # end
+            root = Tree::TreeNode.new("ROOT", "Root Content")
+            child = Tree::TreeNode.new("CHILD1", array_collect) 
+            grand_child = Tree::TreeNode.new("CHILD2", string_asterisk)
+            child << grand_child
+            root << child
+            root
+          end
+
+          context 'has operator "String#*"' do
+
+            let(:string_asterisk) { StringAsteriskOperator.new([1]) }
+
+            let(:scope) { Cauldron::Scope.new(['var0']) }
+
+            it 'is "var0.collect { |var1| var1 * 2 }"' do
+              Cauldron::Solution::Composite.new(
+                tree.children
+              ).to_ruby( scope ).should == 'var0.collect { |var1| var1 * 2 }'
+            end
+
+          end
+
+        end
+
+      end
+
+      context %q{with the operators} do 
+
+        let(:scope) { Cauldron::Scope.new(['var0']) }
+
+        let(:tree) do
+          root_node = Tree::TreeNode.new("ROOT", "Root Content")
+          child_node = Tree::TreeNode.new("CHILD1", Cauldron::VarCollectOperator.new([0]) )
+          #child_node << Tree::TreeNode.new("GRANDCHILD1", NumericOperator.new([2], 2) ) 
+          child_node << Tree::TreeNode.new("GRANDCHILD1", NumericOperator.new([2]) ) 
+          root_node << child_node
+          # -- 
+          child_node_2 = Tree::TreeNode.new("CHILD2", Cauldron::VarCollectOperator.new([1]) )
+          child_node_2 << Tree::TreeNode.new("GRAND-CHILD2", ToSOperator.new([4]) )
+          root_node << child_node_2
+          root_node
+        end
+
+        it %q{generates the code} do
+          pending
+          Composite.new(
+            tree.children
+            #[Cauldron::VarCollectOperator.new([0]), NumericOperator.new([2], 2) ],
+            #[Cauldron::VarCollectOperator.new([1]), ToSOperator.new([4])]
+          ).to_ruby( scope ).should == %q{
+var1 = var0.collect do |var2|
+ var2 + 2
+ end;
+ var3 = var1.collect do |var4|
+ var4.to_s 
+end
+}.strip.gsub(/\n/,'')
+        end
+
+      end
+
+      context 'with VarCollect' do
+
+        let(:variables) { Cauldron::Scope.new(['var0']) }
+
+        let(:tree) do
+          root_node = Tree::TreeNode.new("ROOT", "Root Content")
+          child_node = Tree::TreeNode.new("CHILD1", Cauldron::VarCollectOperator.new([0]) )
+          child_node_2 = Tree::TreeNode.new("CHILD2", StringAsteriskOperator.new([2]) )
+          child_node << child_node_2
+          root_node << child_node
+          root_node
+        end
+
+        it %q{
+var1 = var0.collect do |var2|
+  var2 * 2
+end
+} do
+          Composite.new(
+            tree.children
+          ).to_ruby( variables ).should == %q{
+var1 = var0.collect do |var2|
+ var2 * 2 
+end
+}.strip.gsub(/\n/,'')
+        end
+
+      end      
+
+    end
+
+    describe '#to_sexp' do
+
+      context 'using initial operator "Array#collect"' do
+
+        let(:collect_operator) { Cauldron::ArrayCollectTemplate::Default.new([0]) }
+
+        let(:scope) { Cauldron::Scope.new(['var0']) }
+
+        context 'using second operator "x * 3"' do
+
+          let(:string_multiple) { StringAsteriskOperator.new([1]) }
+
+          let(:tree) do
+            root_node = Tree::TreeNode.new("ROOT", "Root Content")
+            child_node = Tree::TreeNode.new("CHILD1", collect_operator )
+            child_node_2 = Tree::TreeNode.new("CHILD2", string_multiple )
+            child_node << child_node_2
+            root_node << child_node
+            root_node
+          end          
+
+          it 'returns "var0.collect {|x| x * 2}"' do
+            Composite.new(tree.children).to_sexp(scope).should match_code_of(
+              %q{
+                var0.collect { |var1| 
+                  var1 * 2
+                }
+              }
+            )
+          end
+
+        end
+
+      end
+
+    end
+
+  end  
+end

data/spec/cauldron/solution/one_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+module Cauldron::Solution
+  
+  describe 'One' do 
+
+    let(:solution) do
+      Cauldron::Solution::One.new
+    end
+    
+    describe '#to_ruby' do
+
+      #it 'returns "var0.concat("bar")"' do
+      it %q{returns var0.collect { |x| x * 2 } } do
+          solution.to_ruby(['var0']).to_s.should == %q{
+var0.collect { |x| x * 2 }
+}.strip
+      end
+
+    end
+
+  end
+  
+end

data/spec/cauldron/statement_generator_spec.rb

@@ -0,0 +1,211 @@
+require 'spec_helper'
+
+module Cauldron
+
+  describe StatementGenerator do
+
+    describe '#method_to_sexp' do
+
+      let(:subject) { StatementGenerator.new}
+
+      context 'instance is "3"' do
+
+        let(:instance) { 3 } 
+
+        context 'dynamic_method is ":+"' do
+
+          let(:dynamic_method) { :+ } 
+
+          it "doesn't raise an error" do
+            expect{
+              subject.method_to_sexp(instance, dynamic_method)
+            }.not_to raise_error
+          end
+
+        end
+
+      end
+
+    end
+
+    describe '#build_class' do
+
+      let(:subject) { StatementGenerator.new }
+
+      context 'with string instance "string"' do
+
+        context 'with method "chop"' do
+
+          it "doesn't raise an error" do
+            expect{
+              subject.build_class('string', 'chop')
+            }.not_to raise_error
+          end
+
+        end
+
+      end
+
+    end
+
+    describe '#dynamic_template_name' do
+
+      context 'with instance 4' do
+
+        context 'with method "+"' do
+
+          let(:subject) do
+            Object.const_set(
+              StatementGenerator.new.dynamic_template_name(4,'+'),
+              Class.new
+            )            
+          end
+
+          it 'generates a valid class name' do
+            expect{
+              subject.new
+            }.not_to raise_error
+          end
+
+          after(:each) do
+            Object.send(:remove_const, StatementGenerator.new.dynamic_template_name(4,'+'))
+          end
+
+        end
+
+      end
+
+    end
+
+    describe '#build_template' do
+
+      let(:subject) { StatementGenerator.new}
+
+      context 'with instance 4' do
+
+        context 'with method "+"' do
+
+          it "doesn't raise an error" do
+            expect{ subject.build_template(4, '+') }.not_to raise_error
+          end
+
+        end
+
+      end
+
+    end
+
+    describe '#build' do
+
+      let(:subject) { StatementGenerator.new}
+
+      it 'returns 1 operator' do
+        expect(subject.build('string',[:chop]).length).to eql(1)
+      end
+
+      describe 'generating String#chop' do
+
+        let(:operators) { [] }
+        let(:scope) { Cauldron::Scope.new(['var0']) }
+
+        describe 'unbuilt instance' do
+
+          it 'returns a instance that raises an error when #to_tracking_sexp' do
+            expect{
+              subject.build(
+                'string',[:chop]
+              ).first.to_tracking_sexp(
+                operators, scope, Cauldron::Caret.new
+              )
+            }.to raise_error(StandardError)
+          end
+
+        end
+
+        describe '#realizable?' do
+
+          let(:operator) do
+            subject.default_template('string',:chop).new([0])
+          end
+
+        end
+
+        describe '#to_ruby' do
+
+          let(:operator) do
+            subject.default_template('string',:chop).new([0])
+          end
+
+          it 'returns the "var0.chop"' do
+            operator.to_ruby(scope,[]).should == 'var0.chop'
+          end
+
+        end
+
+        describe '#instances' do
+
+          describe 'adding String#chop in collect statement' do
+
+            let(:histories) do
+              Cauldron::Histories.new(
+                [
+                  Cauldron::History.new(
+                    [
+                      {:var2=>"Sparky", :var0=>["Sparky", "Kels"], :var1=>nil, :line=>0, :depth=>1, :total_line=>3, :point=>[0, 0]},
+                      {:var2=>"Kels", :var0=>["Sparky", "Kels"], :var1=>nil, :line=>0, :depth=>1, :total_line=>3, :point=>[0, 0]},
+                      {:var0=>["Sparky", "Kels"], :var1=>["Sparky", "Kels"], :line=>0, :depth=>0, :total_line=>4, :point=>[1]}
+                    ]
+                  )
+                ]
+              )
+            end
+
+            let(:composite) do
+              Cauldron::Solution::Composite.new(
+                [
+                  Tree::TreeNode.new(
+                    "ROOT", 
+                    StatementGenerator.new.default_template(
+                      ["Sparky", "Kels"],
+                      :collect
+                    ).new([0])                    
+                  )
+                ]
+              )
+            end
+
+            let(:examples) do
+              Cauldron::ExampleSet.new(
+                [
+                  Cauldron::Example.new({arguments: [["Sparky", "Kels"]], response: ["Spark", "Kel"]}),
+                  Cauldron::Example.new({arguments: [["Pip", "Rowe"]], response: ["Pi", "Row"]})
+                ]
+              )
+            end
+
+            let(:insert_points) { [[0, 0], [1]] }
+
+            let(:operator) do
+              subject.default_template('string',:chop)
+            end            
+
+            # instances(histories, composite, examples, insert_points)
+            it 'returns 1 new composite' do
+              expect(
+                operator.instances(
+                  histories, composite, examples, insert_points
+                ).length
+              ).to eql(1)
+            end
+
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end