cauldron 0.1.5 → 0.1.6

data/lib/cauldron/array_reverse_operator.rb

@@ -1,39 +0,0 @@
-class ArrayReverseOperator
-
-  #Arra
-
-  def initialize
-  end  
-
-  # Matching in 
-  def successful?(input,output)
-    # NOTE - for the future - like the idea of not actually calling the method
-    # input.length.each do |i|
-    # does input[0] == output[input.length-0]
-    # does input[1] == output[input.length-1]
-    # does input[3] == output[input.length-3]
-    # end
-    
-    # in this case x.reverse will work
-    return true if input.first.reverse == output
-    false
-  end
-
-  # 1. Only has one argument value
-  # 2. Argument is an array value
-  # 3. Response is an array 
-  def self.viable?(arguments,output)
-    return false unless arguments.length == 1
-    return false unless arguments.all? { |x| x.kind_of?(Array) }
-    return false unless output.kind_of?(Array)
-    true
-  end
-
-  def self.find_constants(problems)
-    []
-  end
-
-  # def describe - 
-  # should be able to describe the x.object_id moving to the different locations
-
-end

data/lib/cauldron/concat_operator.rb

@@ -1,34 +0,0 @@
-class ConcatOperator
-
-  def initialize(constant)
-    @constant = constant
-  end
-
-  def self.viable?(arguments, response)
-    return false unless arguments.all? { |x| x.kind_of?(String) }
-    return false unless response.kind_of?(String)
-    # TODO - Only accpets one argument
-    true
-  end
-
-  def self.find_constants(problems)
-    problems.inject([]) do |total, x| 
-      result = x[:response].gsub( Regexp.new('^'+x[:arguments].first),'')
-      total << result unless result == x[:response]
-      total
-    end.uniq
-  end
-
-  # Operator for "x.concat("bar")"
-  def successful?(problem)
-    if (problem[:arguments].first + @constant) == problem[:response]
-      return true
-    end
-    return false
-  end
-
-  def to_ruby
-    '  var0.concat(\''+@constant.to_s+'\')'+"\n"
-  end
-
-end

data/lib/cauldron/numeric_operator.rb

@@ -1,45 +0,0 @@
-class NumericOperator
-
-  # Maybe NumericOperation
-
-  def initialize(constant)
-    @constant = constant
-  end
-
-  # Is the problem suitable for a numeric operatio?
-  # e.g. can the .find_contants call be called without error
-  def self.viable?(arguments,output)
-
-    # 1. Only has one argument value
-    # 2. Argument is a numeric value
-    # 3. Response is numeric
-
-    # TODO  Need to save these viablility tests in shared (easily comparable) state.
-    #       e.g. so all viable operations can be found in one go. 
-
-    return false unless arguments.all? { |x| x.kind_of?(Numeric) }
-    return false unless output.kind_of?(Numeric)
-    true
-
-  end
-
-  def to_ruby
-    '  var0 + '+@constant.to_s+"\n"
-  end
-
-  # Operator for "x + n" e.g. x + 1
-  def successful?(problem)
-    # Does the input match the answer
-    #problem.collect {|x| x[:response] - x[:arguments].first }.uniq.length == 1
-    if (problem[:arguments].first + @constant) == problem[:response]
-      return true
-    end
-    return false
-  end
-
-  def self.find_constants(problems)
-    problems.collect {|x| x[:response] - x[:arguments].first }.uniq
-    
-  end
-
-end

data/lib/cauldron/relationship.rb

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

data/spec/cauldron/array_reverse_operator_spec.rb

@@ -1,59 +0,0 @@
-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/numeric_operator_spec.rb

@@ -1,70 +0,0 @@
-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