cauldron 0.1.5 → 0.1.6

data/spec/cauldron/example_set_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+module Cauldron
+
+  describe ExampleSet do
+
+    describe '#all?' do
+
+      context %q{contains example {:arguments => ['Mass'], :response => 'effect'}} do
+
+        context %q{with block {|x| x.response == 'effect'}} do
+
+          let(:example_set) do
+            Cauldron::ExampleSet.new(
+              [
+                Cauldron::Example.new({:arguments => ['Mass'], :response => 'effect'})
+              ]
+            )
+          end
+
+          it 'returns false' do
+            example_set.all? {|x| x.response == 'effect'}.should == true
+          end
+
+        end
+
+      end
+
+    end
+
+    describe '#scope' do
+
+      let(:example) { Cauldron::Example.new({:arguments => ['Mass'], :response => 'effect'}) }
+
+      let(:example_set) do
+        Cauldron::ExampleSet.new(
+          [ example ]
+        )
+      end
+
+      it 'creates a new variables array' do
+        example_set.scope.variables.object_id.should_not === example.params.object_id
+      end
+
+    end
+
+  end
+
+end

data/spec/cauldron/example_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+module Cauldron
+  
+  describe Example do
+
+    describe '#params' do
+
+      let(:example) do
+        Cauldron::Example.new(
+          { arguments: [["Pip", "Rowe"]], response: ["Pi", "Row"] }
+        )
+      end
+
+      it "returns ['var0']" do
+        example.params.should == ['var0']
+      end
+
+      context '#params has already been called' do
+
+        before(:each) { example.params }
+
+        it "returns ['var0']" do
+          example.params.should == ['var0']
+        end        
+
+      end
+
+    end
+
+  end
+
+end

data/spec/cauldron/histories_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+module Cauldron
+  
+  describe Histories do
+
+    describe '#insert_points' do
+
+      context 'has history with point [0]' do
+
+        let(:first_line_history) { Cauldron::History.new([{point: [0]}])}
+
+        let(:subject){
+          Cauldron::Histories.new([first_line_history])          
+        }
+
+        it 'returns [ [0] ]' do
+          subject.insert_points.should == [[0]]
+        end
+
+      end
+
+      context 'has history 2 points [1,0]' do
+
+        let(:first_history) { Cauldron::History.new([{point: [1,0]}])}
+        let(:second_history) { Cauldron::History.new([{point: [1,0]}])}
+
+        let(:subject){
+          Cauldron::Histories.new([first_history,second_history])          
+        }        
+
+        it 'returns 1 insert point' do
+          expect(subject.insert_points.length).to eql(1)
+        end
+
+      end      
+
+    end
+
+    describe '#contexts_at' do
+
+    # #<Cauldron::Histories:0x007f7f5c3f38c8
+    #  @results=
+    #   [#<Cauldron::History:0x007f7f5c3f3940
+    #     @logs=
+    #      [{: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]}]>]>      
+
+      # point [0,0] => [{:var2=>"Sparky", :var0=>["Sparky", "Kels"], :var1=>nil}]
+      # point [0,0] => [{:var2=>"Kels", :var0=>["Sparky", "Kels"], :var1=>nil}]
+      # point [1] => [{:var2=>"Kels", :var0=>["Sparky", "Kels"], :var1=>nil}]
+
+      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
+
+      it 'returns 1 context' do
+        expect(histories.contexts_at([1]).length).to eql(1)
+      end
+
+      it 'returns 2 contexts' do
+        expect(histories.contexts_at([0, 0]).length).to eql(2)
+      end      
+
+    end
+
+    describe '#variable_permutations' do
+
+      let(:histories) do
+        Cauldron::Histories.new(
+          [
+            Cauldron::History.new([{var0: 4}])
+          ]
+        )
+      end
+
+      it 'returns [{var0: 4}]' do
+        histories.variable_permutations(1).should == [
+          {var0: 4}
+        ]
+      end
+
+      context 'when var0 is ["Sparky", "Kel"]' do
+
+        let(:histories) do
+          Cauldron::Histories.new(
+            [
+              Cauldron::History.new([{:var0=>["Sparky", "Kel"], :line=>0, :depth=>0, :total_line=>0}])
+            ]
+          )
+        end
+
+        it 'returns ["Sparky", "Kel"]' do
+          histories.variable_permutations(1).should == [
+            {var0: ["Sparky", "Kel"]}
+          ]
+        end        
+
+      end
+
+      context 'using two histories' do
+
+        let(:histories) do
+          Cauldron::Histories.new(
+            [
+              Cauldron::History.new([{:var0=>"Sparky", :line=>0, :depth=>0, :total_line=>0}]),
+              Cauldron::History.new([{:var0=>"Kel", :line=>0, :depth=>0, :total_line=>0}])
+            ]
+          )
+        end
+
+        it 'returns []' do
+          histories.variable_permutations(1).should == [
+            {var0: 'Sparky'}, {var0: 'Kel'}
+          ]
+        end              
+
+      end
+
+    end
+
+  end
+
+end

data/spec/cauldron/history_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+module Cauldron
+  
+  describe History do
+
+    describe '#insert_points' do
+
+      context %q{given the history is 
+        History is:
+          [line: 0, depth:0, var0: ['Sparky','Kel'] ]
+      } do
+
+        let(:subject) { History.new([{line: 0, depth: 0, point: [0], var0: ['Sparky','Kel'] }]) }
+
+        it 'has 1 insert point' do
+          expect(subject.insert_points.length).to eql(1)
+        end
+
+        it 'has the insert point [0,0]' do
+          subject.insert_points.should include([0])
+        end
+
+      end
+
+      context %q{given the history is 
+        History is:
+          [line: 1, depth:0, var0: 'Sparky', var1: 'Spark' ]
+        from:
+          var1 = var0.chop
+        } do
+
+        let(:subject) { History.new([{line: 1, depth: 0, point: [1], var0: 'Sparky', var1: 'Spark'}]) }
+
+        it 'has 1 insert point' do
+          expect(subject.insert_points.length).to eql(1)
+        end 
+          
+        it 'has the insert point [1,0]' do
+          subject.insert_points.should include([1])
+        end                   
+
+      end
+
+      context %q{
+        History is:
+          [line: 1, depth:1, total_line: 2, point: [0,1], var0: ['Sparky', 'Kels'], var1: 'Spark' ],
+          [line: 1, depth:1, total_line: 2, point: [0,1], var0: ['Sparky', 'Kels'], var1: 'Kel' ],
+          [line: 1, depth:0, total_line: 2, point: [1], var0: ['Sparky', 'Kels'], var1: 'Kel', var2: ['Spark', 'Kel'] ],
+        from:
+          var2 = var0.each do |var1|
+            var1.chop
+          end
+        } do
+
+          let(:subject) { 
+            History.new([
+              {line: 1, depth:1, total_line: 2, point: [0,1], var0: ['Sparky', 'Kels'], var1: 'Spark'},
+              {line: 1, depth:1, total_line: 2, point: [0,1], var0: ['Sparky', 'Kels'], var1: 'Kel'},
+              {line: 1, depth:0, total_line: 2, point: [1], var0: ['Sparky', 'Kels'], var1: 'Kel', var2: ['Spark', 'Kel']}
+            ]) 
+          }
+
+          it 'has 2 insert point' do
+            expect(subject.insert_points.length).to eql(2)
+          end
+
+          it 'has the insert point [1]' do
+            subject.insert_points.should include([1])
+          end
+
+          it 'has the insert point [0,1]' do
+            subject.insert_points.should include([0,1])
+          end                               
+
+      end
+
+    end
+
+    describe '#variables' do
+
+      context %q{
+        History is:
+          [line: 0, depth:0, var0: ['Sparky','Kel'] ]
+      } do
+
+        let(:history) { History.new([{line: 0, depth: 0, var0: ['Sparky','Kel'] }]) }
+
+        it 'returns "var0"' do
+          history.variables.should == [:var0]
+        end
+
+      end
+
+    end
+
+    describe '#values' do
+
+      context %q{
+        History is:
+          [line: 0, depth:0, var0: ['Sparky','Kel'] ]
+      } do
+
+        let(:history) { History.new([{line: 0, depth: 0, var0: ['Sparky','Kel'] }]) }
+
+        it %q{returns "[ ['Sparky','Kel'] ]"} do
+          history.values(:var0).should == [
+            ['Sparky','Kel']
+          ]
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/cauldron/if_relationship_spec.rb

@@ -13,7 +13,7 @@ module Cauldron
             {arguments: [7], response: 'seven'},
             {arguments: [8], response: 'eight'}
           ]          
-          IfRelationship.match?(problem).should be_true
+          expect(IfRelationship.match?(problem)).to eql(true)
         end
 
       end

data/spec/cauldron/operator/array_reverse_operator_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+module Cauldron
+  
+  describe 'ArrayReverseOperator' do
+
+    it_behaves_like "operator" do
+      let(:operator) { ArrayReverseOperator.new([0]) }
+      let(:initial_scope) { Cauldron::Scope.new(['var0']) }
+      let(:initial_operators) { [] }
+    end    
+
+    describe '.viable?' do
+
+      context 'the arguments are not arrays' do
+
+        it 'is false' do
+          expect(ArrayReverseOperator.viable?([8], ['lions','tigers','bears'])).to eql(false)
+        end
+
+      end
+
+      context 'using more than 1 argument' do
+
+        it 'is false' do
+          expect(ArrayReverseOperator.viable?([['lions'],['tigers']], ['lions','tigers'])).to eql(false)
+        end
+
+      end
+
+      context 'response is not an array' do
+
+        it 'is false' do
+          expect(ArrayReverseOperator.viable?([['lions','tigers']], 'lions')).to eql(false)
+        end
+
+      end      
+
+    end
+
+    describe '#successful?' do
+
+      context 'using array that needs reversed' do
+
+        it 'is true' do
+          operator = ArrayReverseOperator.new([0])
+          expect(
+            operator.successful?(
+              { arguments: [['lions','tigers']],response: ['tigers','lions']}
+            )
+          ).to eql(true)
+        end
+
+      end
+
+      context "using array that can't be reversed" do
+
+        it 'is false' do
+          operator = ArrayReverseOperator.new([0])
+          expect(
+            operator.successful?(
+              {arguments:[['lions','tigers']],response: ['lions','tigers']}
+            )
+          ).to eql(false)
+        end
+        
+      end
+
+    end
+
+  end
+
+end

data/spec/cauldron/{concat_operator_spec.rb → operator/concat_operator_spec.rb}

@@ -2,14 +2,24 @@ require 'spec_helper'
 
 module Cauldron
   
-  describe 'ConcatOperator' do 
+  describe ConcatOperator do 
+
+    it_behaves_like "leaf_operator" do
+      let(:leaf_operator) { ConcatOperator.new([0]) }
+    end
+
+    it_behaves_like "operator" do
+      let(:operator) { ConcatOperator.new([0]) }
+      let(:initial_scope) { Cauldron::Scope.new(['var0']) }
+      let(:initial_operators) { [] }
+    end        
     
     describe '.viable?' do
 
       context 'the arguments are not string' do
 
         it 'is false' do
-          ConcatOperator.viable?([8], 'foobar').should be_false
+          expect(ConcatOperator.viable?([8], 'foobar')).to eql(false)
         end
 
       end
@@ -17,7 +27,7 @@ module Cauldron
       context 'the reponse is not a string' do
 
         it 'is false' do
-          ConcatOperator.viable?(['foo'],8).should be_false
+          expect(ConcatOperator.viable?(['foo'],8)).to eql(false)
         end
 
       end
@@ -30,10 +40,13 @@ module Cauldron
 
         context 'response is "foobar"' do
 
+          let(:problems) do
+            Cauldron::ExampleSet.new(
+              [Cauldron::Example.new({ arguments: ['foo'], response: 'foobar'})]
+            )
+          end          
+
           it 'return "[bar]"' do
-            problems = [
-              { arguments: ['foo'], response: 'foobar'}
-            ]
             ConcatOperator.find_constants(problems).should == ['bar']
           end
 
@@ -41,10 +54,13 @@ module Cauldron
 
         context 'response is "barfoo"' do
 
+          let(:problems) do
+            Cauldron::ExampleSet.new(
+              [Cauldron::Example.new({ arguments: ['foo'], response: 'barfoo'})]
+            )
+          end
+
           it 'returns "[]"' do
-            problems = [
-              { arguments: ['foo'], response: 'barfoo'}
-            ]
             ConcatOperator.find_constants(problems).should == []            
           end
 
@@ -63,7 +79,7 @@ module Cauldron
             {arguments: ['foo'], response: 'foobar'},
             {arguments: ['goo'], response: 'goobar'}
           ]          
-          operator = ConcatOperator.new('bar')  
+          operator = ConcatOperator.new([])  
           problems.all? {|x| operator.successful?(x) }.should == true
         end
 
@@ -75,9 +91,11 @@ module Cauldron
 
       context 'using the constant "bar"' do
 
+        let(:scope) { Cauldron::Scope.new(['var0']) }
+
         it 'returns "var0.concat("bar")"' do
-          operator = ConcatOperator.new('bar')
-          operator.to_ruby.should == "  var0.concat('bar')"+"\n"
+          operator = ConcatOperator.new([0])
+          operator.to_ruby(scope,[]).should == "var0.concat(\"bar\")"
         end
 
       end