cauldron 0.1.3 → 0.1.5

data/lib/cauldron/relationship.rb

@@ -0,0 +1,5 @@
+class Relationship
+
+
+
+end

data/lib/cauldron/terminal.rb

@@ -1,67 +1,11 @@
 module Cauldron
   
   class Terminal
-    
-    include Cauldron::Conversion
-    include Cauldron::Demos
-    
-    attr_reader :cases
-    
-    def initialize(output,auto=true)
-      @output, @cases, @auto = output, [], auto
-      
-      # Create a logger for the user inputs
-      #file = File.open('user-input.log', File::WRONLY | File::APPEND)
-      file = File.open('user-input.log', 'w+')
-      # To create new (and to remove old) logfile, add File::CREAT like;
-      #   file = open('foo.log', File::WRONLY | File::APPEND | File::CREAT)
-      @user_logger = Logger.new(file)      
-      
+   
+    def initialize(output = STDOUT)
+      @output = output
     end
-    
-    def start
-      @output.puts 'Starting....'
-      @pot = Cauldron::Pot.new
-      @pot.clear
-      @output.puts '* Adding example case'      
-      @pot.simmer(demo_one)
-      @pot.simmer(demo_two)
-      
-      @output.puts "Thanks for trying Cauldron - it's at really early stage right now"
-      @output.puts "in fact it can only generate a method that returns the parameter passed through"
-      @output.puts ""
-      @output.puts "To start enter your first test like this"    
-      @output.puts "input,input,output"
-      @output.puts "For example "
-      @output.puts "'fish','animal'"
-      @output.puts "'carrot','vegtable'"
-      @output.puts "and when you're done just type RUN"
-
-      # Wait for the user's inputs
-      unless @auto
-        loop do 
-          submit gets
-        end      
-      end
-      
-    end
-    
-    def submit(input)
-      
-      @user_logger.info input
-      
-      if input =~ /^RUN$/
-        @output.puts @pot.brew(@cases).reset_ids!.basic_write
-      elsif input =~ /^QUIT$/
-        # => TODO Include 'bye' output too
-        #Process.exit!(true)
-        at_exit {0}
-        exit
-      else
-        @cases << convert_to_example(separate_values(input))
-      end
-    end   
-
+   
   end
   
 end

data/lib/cauldron/version.rb

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

data/lib/core/string.rb

@@ -0,0 +1,21 @@
+# TODO Really want a nice indent solution - like cucumber
+# http://stackoverflow.com/questions/3350648/ruby-indented-multiline-strings
+# Personally, I think that Ruby's indented heredocs are useless and they should work more like Bash indented heredocs and also strip whitespace inside the string …
+
+# Anyway, there are a couple of libraries that try to deal with this situation. There is a wide array of libraries that try to fix this problem:
+
+#     Martin Aumont's Unindent library which is also part of the Facets library
+#     Facets also provides String#margin
+#     Sunlight Labs' Unindentable library
+#     Samuel Dana's Indentation library
+
+# https://github.com/Mynyml/Unindent/
+class String
+  def unindent
+    indent = self.split("\n").select {|line| !line.strip.empty? }.map {|line| line.index(/[^\s]/) }.compact.min || 0
+    self.gsub(/^[[:blank:]]{#{indent}}/, '')
+  end
+  def unindent!
+    self.replace(self.unindent)
+  end
+end

data/sandbox.rb

@@ -1,6 +1,9 @@
 $LOAD_PATH.unshift File.expand_path('../lib',__FILE__)
 
 require 'cauldron'
+require 'ruby_debug'
+require 'yaml'
+
 
 # unified_chain = Cauldron::Util::Saver.load(1)
 # 
@@ -10,14 +13,32 @@ require 'cauldron'
 # puts 'Working'
 
 
-unified_chain = Cauldron::Util::Saver.load(33)
-runtime_method = Cauldron::Util::Saver.load(31)
-test_cases  = Cauldron::Util::Saver.load(32)
-
-puts unified_chain.describe
+# unified_chain = Cauldron::Util::Saver.load(298)
+# runtime_method = Cauldron::Util::Saver.load(31)
+# test_cases  = Cauldron::Util::Saver.load(32)
+# 
+# puts unified_chain.describe
 
 
 #unified_chain.valid_mapping_permutations(runtime_method,test_cases)
 
-  
+string = <<-EOF
+  blah blah
+  blah blah
+  EOF
+puts string
+
+module YAML
+
+  require 'rspec'
+
+  def YAML.load_file( filepath )
+    File.open( filepath ) do |f|
+      f = double(:file)
+      load( double(:file) )
+    end
+  end
+
+end
 
+details = YAML.load_file("loaded_file.yaml")

data/spec/cauldron/array_reverse_operator_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+module Cauldron
+  
+  describe 'ArrayReverseOperator' do
+
+    describe '.viable?' do
+
+      context 'the arguments are not arrays' do
+
+        it 'is false' do
+          ArrayReverseOperator.viable?([8], ['lions','tigers','bears']).should be_false
+        end
+
+      end
+
+      context 'using more than 1 argument' do
+
+        it 'is false' do
+          ArrayReverseOperator.viable?([['lions'],['tigers']], ['lions','tigers']).should be_false
+        end
+
+      end
+
+      context 'response is not an array' do
+
+        it 'is false' do
+          ArrayReverseOperator.viable?([['lions','tigers']], 'lions').should be_false
+        end
+
+      end      
+
+    end
+
+    describe '#successful?' do
+
+      context 'using array that needs reversed' do
+
+        it 'is true' do
+          operator = ArrayReverseOperator.new
+          operator.successful?([['lions','tigers']],['tigers','lions']).should be_true
+        end
+
+      end
+
+      context "using array that can't be reversed" do
+
+        it 'is false' do
+          operator = ArrayReverseOperator.new
+          operator.successful?([['lions','tigers']],['lions','tigers']).should be_false
+        end
+        
+      end
+
+    end
+
+  end
+
+end

data/spec/cauldron/concat_operator_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+module Cauldron
+  
+  describe 'ConcatOperator' do 
+    
+    describe '.viable?' do
+
+      context 'the arguments are not string' do
+
+        it 'is false' do
+          ConcatOperator.viable?([8], 'foobar').should be_false
+        end
+
+      end
+
+      context 'the reponse is not a string' do
+
+        it 'is false' do
+          ConcatOperator.viable?(['foo'],8).should be_false
+        end
+
+      end
+
+    end
+
+    describe '.find_constants' do
+
+      context 'argument is "foo"' do
+
+        context 'response is "foobar"' do
+
+          it 'return "[bar]"' do
+            problems = [
+              { arguments: ['foo'], response: 'foobar'}
+            ]
+            ConcatOperator.find_constants(problems).should == ['bar']
+          end
+
+        end
+
+        context 'response is "barfoo"' do
+
+          it 'returns "[]"' do
+            problems = [
+              { arguments: ['foo'], response: 'barfoo'}
+            ]
+            ConcatOperator.find_constants(problems).should == []            
+          end
+
+        end
+
+      end
+
+    end
+
+    describe '#successful?' do
+
+      context 'all arguments end with "bar"' do
+
+        it 'returns true' do
+          problems = [
+            {arguments: ['foo'], response: 'foobar'},
+            {arguments: ['goo'], response: 'goobar'}
+          ]          
+          operator = ConcatOperator.new('bar')  
+          problems.all? {|x| operator.successful?(x) }.should == true
+        end
+
+      end
+
+    end
+
+    describe '#to_ruby' do
+
+      context 'using the constant "bar"' do
+
+        it 'returns "var0.concat("bar")"' do
+          operator = ConcatOperator.new('bar')
+          operator.to_ruby.should == "  var0.concat('bar')"+"\n"
+        end
+
+      end
+
+    end
+
+  end
+  
+end

data/spec/cauldron/if_relationship_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+module Cauldron
+  
+  describe 'IfRelationship' do 
+    
+    describe '.match?' do
+
+      context 'any valid collection of problems' do
+
+        it 'is true' do
+          problem = [
+            {arguments: [7], response: 'seven'},
+            {arguments: [8], response: 'eight'}
+          ]          
+          IfRelationship.match?(problem).should be_true
+        end
+
+      end
+
+    end
+
+  end
+  
+end

data/spec/cauldron/numeric_operator_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+module Cauldron
+  
+  describe 'NumericOperator' do 
+    
+    describe '.viable?' do
+
+      context 'consistent difference between argument and response' do
+
+        it 'is true' do
+          problem = [
+            {arguments: [7], response: 8},
+            {arguments: [10], response: 11}
+          ]
+          #NumericOperator.viable?(problem).should be_true
+          problem.all? {|x| NumericOperator.viable?(x[:arguments], x[:response]) }.should be_true
+        end
+
+      end
+
+      context 'arguments are not numeric' do
+
+        it 'is false' do
+          problem = [
+            {arguments: ["ted"], response: 8},
+            {arguments: ["ben"], response: 11}
+          ]          
+          #NumericValueRelationship.match?(problem).should be_false
+          problem.all? {|x| NumericOperator.viable?(x[:arguments], x[:response]) }.should be_false
+        end
+
+      end
+
+      context 'responses are not numeric' do
+
+        it 'is false' do
+          problem = [
+            {arguments: [7], response: 'ben'},
+            {arguments: [10], response: 'ted'}
+          ]          
+          #NumericValueRelationship.match?(problem).should be_false
+          problem.all? {|x| NumericOperator.viable?(x[:arguments], x[:response]) }.should be_false
+        end
+
+      end
+
+    end
+
+    describe '#successful?' do
+
+      context 'no consistent difference between values' do
+
+        it 'is false' do
+          problem = [
+            {arguments: [7], response: 24},
+            {arguments: [10], response: 11}
+          ]          
+          operator = NumericOperator.new(17)  
+          #NumericValueRelationship.match?(problem).should be_false
+          problem.all? {|x| operator.successful?(x) }.should be_false
+        end
+
+      end
+
+    end
+
+  end
+  
+end

data/spec/cauldron/pot_spec.rb

@@ -2,163 +2,93 @@ require 'spec_helper'
 
 module Cauldron
   
-  describe 'Pot' do 
-    
-    describe '#simmer' do
-      before(:each) {
-        @pot = Cauldron::Pot.new
-        @pot.clear
-      }
-      it 'can simmer with demo one' do 
-        lambda {@pot.simmer(demo_one)}.should_not raise_error
-      end
-      it 'can simmer with demo two' do 
-        lambda {@pot.simmer(demo_two)}.should_not raise_error        
-      end
-      it 'can simmer with both demo one and two' do
-        lambda {@pot.simmer(demo_one)}.should_not raise_error
-        lambda {@pot.simmer(demo_two)}.should_not raise_error        
-      end
-    end
-    
-    describe '#brew' do
-      it 'can come up with a solution after it has been given demo_one' do
-        pot = Cauldron::Pot.new
-        pot.clear
-        pot.simmer(demo_one)
-        cases = []
-        cases << convert_to_example(separate_values("'sparky','sparky'"))
-        cases << convert_to_example(separate_values("'kel','kel'"))
-        
-        ruby      =  "
-            def method_0(var_0)
-              \treturn var_0
-            end
-          "             
-        parser    = RubyParser.new          
-        sexp      = parser.process(ruby)
-        sexp2cauldron = Sexp2Cauldron.new      
-        pot.brew(cases).reset_ids!.basic_write.should == sexp2cauldron.process(sexp).basic_write  
-      end
-      
-      it 'can come up with a solution that fits demo two' do
-        pot = Cauldron::Pot.new
-        pot.clear
-        pot.simmer(demo_two)
-        cases = []
-        cases << convert_to_example(separate_values("'carrot','vegtable'"))
-        cases << convert_to_example(separate_values("'fish','animal'"))
-        
-        ruby      =  "
-                        def method_0(var_0)
-                          \tif(var_0 == 'carrot')
-                          \t\treturn 'vegtable'
-                          \tend
-                          \treturn 'animal'
-                        end        
-                     "
-        parser    = RubyParser.new          
-        sexp      = parser.process(ruby)
-        sexp2cauldron = Sexp2Cauldron.new
-        pot.brew(cases).reset_ids!.basic_write.should == sexp2cauldron.process(sexp).basic_write                     
-      end
-      
-      context 'it has both demo one and two loaded' do
-        before(:each) {
-          @pot = Cauldron::Pot.new
-          @pot.clear
-          @pot.simmer(demo_one)
-          @pot.simmer(demo_two)
-        }
-        it 'can generate a solution like demo 1' do
-          cases = []
-          cases << convert_to_example(separate_values("'pip','pip'"))
-          cases << convert_to_example(separate_values("'rowiage','rowiage'"))
-          ruby      =  "
-            def method_0(var_0)
-              \treturn var_0
-            end
-          "
-          parser    = RubyParser.new          
-          sexp      = parser.process(ruby)
-          sexp2cauldron = Sexp2Cauldron.new      
-          @pot.brew(cases).reset_ids!.basic_write.should == sexp2cauldron.process(sexp).basic_write                              
+  describe 'Pot' do
+
+    describe '#solve' do
+
+      context 'passed simple if statement problem' do
+
+        it 'returns a valid statement' do
+          pot = Pot.new
+          pot.solve(
+            [
+              {arguments: [7], response: 'seven'},
+              {arguments: [8], response: 'eight'}
+            ]
+          ).should == 
+%q{
+def function(var0)
+  if var0 == 7
+    return 'seven'
+  end
+  if var0 == 8
+    return 'eight'
+  end
+end  
+}.strip
         end
-        it 'can repeatedly generate a demo 1 solution' do
-          case_set_one = []
-          case_set_one << convert_to_example(separate_values("'pip','pip'"))
-          case_set_one << convert_to_example(separate_values("'rowiage','rowiage'"))
-          
-          case_set_two = []
-          case_set_two << convert_to_example(separate_values("'andy','andy'"))
-          case_set_two << convert_to_example(separate_values("'kel','kel'"))
-          
-          ruby      =  "
-            def method_0(var_0)
-              \treturn var_0
-            end
-          "          
-          sexp2cauldron = Sexp2Cauldron.new      
-          @pot.brew(case_set_one).reset_ids!.basic_write.should == sexp2cauldron.process(RubyParser.new.process(ruby)).basic_write                              
-          @pot.brew(case_set_two).reset_ids!.basic_write.should == sexp2cauldron.process(RubyParser.new.process(ruby)).basic_write
+
+      end
+
+      context 'passed +1 problem' do
+
+        it 'returns a function that adds 1 to total' do
+          pot = Pot.new
+          pot.solve(
+            [
+              {arguments: [7], response: 8},
+              {arguments: [10], response: 11}
+            ]
+          ).should == 
+%q{
+def function(var0)
+  var0 + 1
+end  
+}.strip          
         end
-        it 'can generate a solution like demo 2(it needs to discount the demo 1 solution)' do
-          cases = []
-          cases << convert_to_example(separate_values("'sparky','bro'"))
-          cases << convert_to_example(separate_values("'kel','sis'"))
-          ruby      =  "
-                          def method_0(var_0)
-                            \tif(var_0 == 'sparky')
-                            \t\treturn 'bro'
-                            \tend
-                            \treturn 'sis'
-                          end        
-                       "                    
-          parser    = RubyParser.new          
-          sexp      = parser.process(ruby)
-          sexp2cauldron = Sexp2Cauldron.new
-          @pot.brew(cases).reset_ids!.basic_write.should == sexp2cauldron.process(sexp).basic_write
+
+      end
+
+      context 'passed "foo" and return "foobar"' do
+
+        it 'returns a concat function' do
+          pot = Pot.new
+          pot.solve(
+            [
+              {arguments: ['foo'], response: 'foobar'},
+              {arguments: ['bar'], response: 'barbar'}
+            ]
+          ).should == 
+%q{
+def function(var0)
+  var0.concat('bar')
+end
+}.strip          
         end
-        it 'can repeatedly generate a demo 2 solution' do
-          case_set_one = []
-          case_set_one << convert_to_example(separate_values("'sparky','bro'"))
-          case_set_one << convert_to_example(separate_values("'kel','sis'"))
-          
-          ruby      =  "
-                          def method_0(var_0)
-                            \tif(var_0 == 'sparky')
-                            \t\treturn 'bro'
-                            \tend
-                            \treturn 'sis'
-                          end        
-                       "                    
-          parser    = RubyParser.new          
-          sexp      = parser.process(ruby)
-          sexp2cauldron = Sexp2Cauldron.new
-          @pot.brew(case_set_one).reset_ids!.basic_write.should == sexp2cauldron.process(sexp).basic_write          
-          
-          case_set_two = []
-          case_set_two << convert_to_example(separate_values("'carrot','vegtable'"))
-          case_set_two << convert_to_example(separate_values("'apple','fruit'"))
-          
-          ruby      =  "
-                          def method_0(var_0)
-                            \tif(var_0 == 'carrot')
-                            \t\treturn 'vegtable'
-                            \tend
-                            \treturn 'fruit'
-                          end        
-                       "                    
-          parser    = RubyParser.new          
-          sexp      = parser.process(ruby)
-          sexp2cauldron = Sexp2Cauldron.new
-          @pot.brew(case_set_two).reset_ids!.basic_write.should == sexp2cauldron.process(sexp).basic_write
-                                        
+
+      end
+
+      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'] }
+            ]
+          ).should == 
+%q{
+def function(var0)
+  var0.reverse
+end
+}.strip      
         end
+
       end
-      
+
     end
     
   end
-
+  
 end