cauldron 0.1.5 → 0.1.6

data/spec/cauldron/operator/hash_key_value_operator_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+module Cauldron
+  
+  describe HashKeyValueOperator do 
+
+    it_behaves_like "operator" do
+      let(:operator) { HashKeyValueOperator.new([0]) }
+      let(:initial_scope) { Cauldron::Scope.new(['var0']) }
+      let(:initial_operators) { [] }
+    end      
+    
+    describe '.viable?' do
+
+      context 'the argument is not a hash' do
+
+        it 'is false' do
+          expect(HashKeyValueOperator.viable?(['string'], 'foobar')).to eql(false)
+        end
+
+      end
+
+      context 'the argument is a hash' do
+
+        it 'is true' do
+          expect(HashKeyValueOperator.viable?([{:foo => 'bar'}], 'foobar')).to eql(true)
+        end
+
+      end
+
+    end
+
+    describe '.uses_constants?' do
+
+      it 'is true' do
+        expect(HashKeyValueOperator.uses_constants?).to eql(true)
+      end
+
+    end
+
+    describe '.find_constants' do
+
+      context 'hash uses key :foo' do
+
+        let(:problems) do
+          Cauldron::ExampleSet.new(
+            [Cauldron::Example.new({ arguments: [{:foo => 'bar'}], response: 'bar'})]
+          )
+        end         
+
+        it 'return ":foo"' do
+          HashKeyValueOperator.find_constants(problems).should == [:foo]
+        end
+
+      end
+
+    end
+
+    describe '#successful?' do
+
+      context 'both problems return reponse when using the key' do
+
+        let(:problems) do
+          Cauldron::ExampleSet.new(
+            [
+              Cauldron::Example.new({ arguments: [{:foo => 'bar'}], response: 'bar'}),
+              Cauldron::Example.new({ arguments: [{:foo => 'mass', :bar => 'effect'}], response: 'mass'}),
+            ]
+          )
+        end        
+
+        it 'is true' do
+          operator = HashKeyValueOperator.new([0])  
+          problems.all? {|x| operator.successful?(x) }.should == true
+        end
+
+      end
+
+    end
+
+    describe '#to_ruby' do
+
+      let(:scope) { Cauldron::Scope.new(['var0']) }
+
+      context 'using the constant ":foo"' do
+
+        it 'returns "var0[:foo]"' do
+          operator = HashKeyValueOperator.new([0])
+          operator.to_ruby(scope,[]).should == 'var0[:foo]'
+        end
+
+      end
+
+    end
+
+  end
+  
+end

data/spec/cauldron/operator/numeric_operator_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+module Cauldron
+  
+  describe 'NumericOperator' do
+
+    it_behaves_like "operator" do
+      let(:operator) { NumericOperator.new([0]) }
+      let(:initial_scope) { Cauldron::Scope.new(['var0']) }
+      let(:initial_operators) { [] }
+    end    
+
+    describe '#realizable?' do
+
+      let(:subject) { NumericOperator.new([0]) }
+
+      context 'histories is [[{:var0 => 8}]]' do
+
+        let(:histories) do 
+          Histories.new([Cauldron::History.new([{:var0 => 8}])])
+        end
+
+        before(:each) { histories.stub(:variable_permutations).and_return [{:var0 => 8}] }
+
+        it 'returns true' do
+          subject.realizable?(histories).should == true
+        end
+
+      end
+
+      context %q{histories is [[{:var0 => 'string'}]]} do
+
+        let(:histories) do 
+          Histories.new([Cauldron::History.new([{:var0 => 'string'}])])
+        end
+
+        before(:each) { histories.stub(:variable_permutations).and_return [{:var0 => 'string'}] }
+
+        it 'returns false' do
+          subject.realizable?(histories).should == false
+        end
+
+      end      
+
+    end
+    
+    describe '.viable?' do
+
+      context 'consistent difference between argument and response' do
+
+        it 'is true' do
+          problem = [
+            {arguments: [7], response: 8},
+            {arguments: [10], response: 11}
+          ]
+          expect(problem.all? {|x| NumericOperator.viable?(x[:arguments], x[:response]) }).to eql(true)
+        end
+
+      end
+
+      context 'arguments are not numeric' do
+
+        it 'is false' do
+          problem = [
+            {arguments: ["ted"], response: 8},
+            {arguments: ["ben"], response: 11}
+          ]          
+          expect(problem.all? {|x| NumericOperator.viable?(x[:arguments], x[:response]) }).to eql(false)
+        end
+
+      end
+
+      context 'responses are not numeric' do
+
+        it 'is false' do
+          problem = [
+            {arguments: [7], response: 'ben'},
+            {arguments: [10], response: 'ted'}
+          ]
+          expect(problem.all? {|x| NumericOperator.viable?(x[:arguments], x[:response]) }).to eql(false)
+        end
+
+      end
+
+    end
+
+    describe '#successful?' do
+
+      context 'no consistent difference between values' do
+
+        let(:problem) do
+          [
+            {arguments: [7], response: 24},
+            {arguments: [10], response: 11}
+          ]                    
+        end
+
+        let(:operator) { NumericOperator.new([0]) }
+
+        it 'is false' do    
+          expect(problem.all? { |x| operator.successful?(x) }).to eql(false)
+        end
+
+      end
+
+    end     
+
+  end
+  
+end

data/spec/cauldron/operator/string_asterisk_operator_spec.rb

@@ -0,0 +1,196 @@
+require 'spec_helper'
+
+module Cauldron
+  
+  describe StringAsteriskOperator do
+
+    it_behaves_like "leaf_operator" do
+      let(:leaf_operator) { StringAsteriskOperator.new([0]) }
+    end
+
+    # it_behaves_like "operator" do
+    #   let(:operator) { StringAsteriskOperator.new([0], 2) }
+    #   let(:initial_scope) { Cauldron::Scope.new(['var0']) }
+    #   let(:initial_operators) { [] }
+    # end    
+
+    describe '.history_goals' do
+
+      context 'with the history [{:x => "lima"},{:x => "bear"}]' do
+
+        let(:history) { [{:x => "lima"},{:x => "bear"}] }
+
+        context "and target ['limalima','bearbear']" do
+
+          it 'returns "x * 2"' do
+            StringAsteriskOperator.history_goals(
+              history, ['limalima','bearbear']
+            ).should == [
+              [{:x => 'lima'}, 'limalima'],
+              [{:x => 'bear'}, 'bearbear']
+            ]
+          end
+
+        end
+
+      end
+
+    end
+
+    describe '.instances' do
+
+      context 'with the history [{:x => "lima"},{:x => "bear"}]' do
+
+        let(:history) { [{:x => "lima"},{:x => "bear"}] }
+
+        let(:scope) { Cauldron::Scope.new(['var0','x']) }
+
+        context "and target ['limalima','bearbear']" do
+
+          it 'returns "x * 2"' do
+            pending
+            StringAsteriskOperator.instances(
+              history, ['limalima','bearbear']
+            ).first.to_ruby(scope).should == "x * 2"
+          end
+
+        end
+
+      end
+
+    end
+
+    describe '.find_constants' do
+
+      context 'argument string is "hello"' do
+
+        context 'response string is hellohello' do
+
+          let(:problems) do
+            Cauldron::ExampleSet.new(
+              [Cauldron::Example.new({ arguments: ['hello'], response: 'hellohello' })]
+            )
+          end          
+
+          it 'returns [2]' do
+            StringAsteriskOperator.find_constants(problems).should == [2]
+          end
+
+        end
+
+        context 'response string is "foo"' do
+
+          let(:problems) do
+            Cauldron::ExampleSet.new(
+              [Cauldron::Example.new({ arguments: ['hello'], response: 'foo' })]
+            )
+          end          
+
+          it 'returns []' do
+            StringAsteriskOperator.find_constants(problems).should == []  
+          end
+
+        end
+
+      end
+
+      context 'argument is ["foo", "lima"]' do
+
+        context 'response is ["foofoo", "limalima"]' do
+
+          let(:problems) do
+            Cauldron::ExampleSet.new(
+              [Cauldron::Example.new({ arguments: [["foo", "lima"]], response: ["foofoo", "limalima"] })]
+            )
+          end          
+
+          it 'returns []' do
+            StringAsteriskOperator.find_constants(problems).should == []
+          end
+
+        end
+
+      end
+
+    end
+
+    describe '.viable?' do
+
+      context 'argument is a string' do
+
+        context 'response is string' do
+
+          it 'is true' do
+            expect(StringAsteriskOperator.viable?(['hello'],'hellohello') ).to eql(true)
+          end
+
+        end
+
+        context 'response is an array' do
+
+          it 'is false' do
+            expect(StringAsteriskOperator.viable?(['hello'],['hellohello']) ).to eql(false)
+          end
+
+        end
+
+      end
+
+      context 'argument is not a string' do
+
+        it 'is false' do
+          expect(StringAsteriskOperator.viable?([8],'hellohello')).to eql(false)
+        end
+
+      end
+
+    end    
+
+    describe '.uses_constants?' do
+
+      it 'is true' do
+        expect(StringAsteriskOperator.uses_constants?).to eql(true)
+      end
+
+    end
+
+    describe '#successful?' do
+
+      context 'argument string is "hello"' do
+
+        context 'response string is hellohello' do
+
+          context 'constant is 2' do
+
+            it 'is true' do
+              problem = { arguments: ['hello'], response: 'hellohello' }
+              operator = StringAsteriskOperator.new([0])
+              expect(operator.successful?(problem) ).to eql(true)
+            end
+
+          end
+
+        end
+
+      end      
+
+    end
+
+    describe '#to_ruby' do
+
+      context 'constant is 2' do
+
+        let(:scope) { Cauldron::Scope.new(['var0']) }
+
+        it 'returns "var0 * 2"' do
+          operator = StringAsteriskOperator.new([0])
+          operator.to_ruby(scope,[]).should == "var0 * 2"
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/cauldron/operator/var_collect_operator_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+module Cauldron
+  
+  describe VarCollectOperator do
+
+    it_behaves_like "operator" do
+      let(:operator) { VarCollectOperator.new([0]) }
+      let(:initial_scope) { Cauldron::Scope.new(['var0']) }
+      let(:initial_operators) { [] }
+    end    
+
+    let(:operator) do
+      VarCollectOperator.new([0])
+    end
+
+    let(:scope) do
+      Cauldron::Scope.new(['var0'])
+    end
+
+    describe '#to_ruby' do
+
+      it %q{is 
+var1 = var0.collect do |var2|
+  var2
+end        
+} do
+        operator.to_ruby(scope,[]).should == %{
+var1 = var0.collect do |var2| var2 end          
+}.strip
+      end
+
+
+    end
+
+  end
+
+end

data/spec/cauldron/pot_spec.rb

@@ -4,6 +4,13 @@ module Cauldron
   
   describe 'Pot' do
 
+    let(:collect_and_multiple) do
+      [
+        { arguments: [['foo','lima']], response: ['foofoo','limalima'] },
+        { arguments: [['bar','delta']], response: ['barbar','deltadelta'] }
+      ]      
+    end
+
     describe '#solve' do
 
       context 'passed simple if statement problem' do
@@ -19,13 +26,13 @@ module Cauldron
 %q{
 def function(var0)
   if var0 == 7
-    return 'seven'
+    return "seven"
   end
   if var0 == 8
-    return 'eight'
+    return "eight"
   end
-end  
-}.strip
+end
+}.lstrip
         end
 
       end
@@ -33,6 +40,7 @@ end
       context 'passed +1 problem' do
 
         it 'returns a function that adds 1 to total' do
+          pending
           pot = Pot.new
           pot.solve(
             [
@@ -43,8 +51,36 @@ end
 %q{
 def function(var0)
   var0 + 1
-end  
-}.strip          
+end
+}.lstrip
+        end
+
+      end
+
+      context %{passed ['Pip','Rowe'] and returns ['Pi','Row']} do
+
+        let(:pot) { pot = Pot.new }
+        let(:examples) do
+          [{arguments: [['Pip','Rowe']], response: ['Pi','Row']}]
+        end
+
+        it %q{
+          returns 
+            def function(var0)
+              var2 = var0.collect do |var1|
+                var1.chop
+              end
+            end            
+        } do
+          pending
+          expect(pot.solve(examples) ).to eql( 
+%q{
+def function(var0)
+  var1 = var0.collect do |var2|
+    var2.chop
+  end
+end
+}).lstrip
         end
 
       end
@@ -52,41 +88,167 @@ end
       context 'passed "foo" and return "foobar"' do
 
         it 'returns a concat function' do
+          pending
           pot = Pot.new
-          pot.solve(
+          expect(pot.solve(
             [
               {arguments: ['foo'], response: 'foobar'},
               {arguments: ['bar'], response: 'barbar'}
             ]
-          ).should == 
+          )).to eql(
 %q{
 def function(var0)
-  var0.concat('bar')
+  var0.concat("bar")
 end
-}.strip          
+}).lstrip
         end
 
       end
 
-      context 'passed ["lion","bear"] and return ["bear","lion"]' do
+      context 'passed ["lion","bear"] and return ["bear","lion"]' do       
 
         it 'returns a reverse function' do
           pot = Pot.new
           pot.solve(
             [
-              { arguments: [['lion','bear']], response: ['bear','lion'] },
-              { arguments: [['foo','bar']], response: ['bar','foo'] }
+              { arguments: [['lion', 'bear']], response: ['bear','lion'] },
+              { arguments: [['foo', 'bar']], response: ['bar','foo'] }
             ]
           ).should == 
 %q{
 def function(var0)
   var0.reverse
 end
-}.strip      
+}.lstrip
+        end
+
+      end
+
+      context '{:foo => 5, :bar => 7 } and return 7' do
+
+        context '{:foo => 10, :bar => 5 } and return 10' do
+
+          let(:pot) { Pot.new }
+
+          it 'returns the value of foo' do
+            pot.solve(
+              [
+                { arguments: [{:foo => 5, :bar => 7 }], response: 5 },
+                { arguments: [{:foo => 10, :bar => 5 }], response: 10 }
+              ]
+            ).should == 
+%q{
+def function(var0)
+  var0[:foo]
+end
+}.lstrip
+          end
+
         end
 
       end
 
+      describe 'using string#* problem' do
+
+        it 'returns a valid statement' do
+          pending
+          sexp = Ripper::SexpBuilder.new(%Q{def function(var0)\n  var0 * 3\nend}).parse
+          pot = Pot.new
+          pot.solve(
+            [
+              {arguments: ['foo'], response: 'foofoofoo'},
+              {arguments: ['bar'], response: 'barbarbar'}
+            ]
+          ).should == 
+%q{
+def function(var0)
+  var0 * 3
+end
+}.lstrip
+        end
+
+      end
+
+      describe 'chaining operators' do
+
+        describe 'use of Array#collect' do
+
+          describe 'use of string#*' do
+
+            it %{returns the function
+def function(var0)
+  var0.collect { |x| x * 2 }
+end
+              } do
+                pending
+              pot = Pot.new
+              expect(pot.solve(
+                [
+                  { arguments: [['foo', 'lima']], response: ['foofoo', 'limalima'] },
+                  { arguments: [['bar', 'delta']], response: ['barbar', 'deltadelta'] }
+                ]
+              )).to eql(
+%q{
+def function(var0)
+  var0.collect { |x|
+    x * 2
+  }
+end
+}).lstrip
+            end
+
+          end
+
+        end
+
+      end 
+
+    end
+
+    describe '#chain_operators' do
+
+      it 'returns a solution function' do
+        pending
+        pot = Pot.new
+        pot.chain_operators(
+          collect_and_multiple,
+          [ArrayCollect.new([0]), StringAsteriskOperator.new([1])]
+        ).should == "var0.collect { |var1| var1 * 2 }"
+      end
+
+    end
+
+    describe '#build_chain_operator' do
+
+      #[ArrayCollect, StringAsteriskOperator]
+      context 'operators are Array#collect and String#*' do
+
+        let(:scope) do
+          Cauldron::Scope.new(['var0'])
+        end
+
+        let(:tree) do
+          root = Tree::TreeNode.new("ROOT", "Root Content")
+          child = Tree::TreeNode.new("CHILD1", ArrayCollect.new([0])) 
+          grand_child = Tree::TreeNode.new("CHILD2", StringAsteriskOperator.new([1],2))
+          child << grand_child
+          root << child
+          root
+        end        
+
+        it 'is "var0.collect { |x| x * 2 }"' do
+          pending
+          pot = Pot.new
+          pot.build_chain_operator(
+            [ArrayCollect, StringAsteriskOperator],
+            collect_and_multiple
+          ).to_ruby(scope).should == Cauldron::Solution::Composite.new(
+            tree.children #[ArrayCollect.new([0]),StringAsteriskOperator.new([1],2)]
+          ).to_ruby(Cauldron::Scope.new(['var0']))
+        end
+
+      end
+ 
     end
     
   end