cauldron 0.1.3 → 0.1.5

data/features/cauldron_new_approach.feature

@@ -0,0 +1,46 @@
+Feature: Cauldron generates single parameter methods
+
+  Cauldron can generate runtime methods that accepts one parameters
+  
+  NOTE: it creates the file in tmp/aruba/launch.rb - so that loading path needs to be changed
+        - use @pause to see if it's working.
+
+  #TODO Change the method name
+
+  @announce @slow_process
+  Scenario: Method returns the passed in value
+    Given a theory named "example_1.yml" with:
+      """
+      dependents:
+        -
+          "if RUNTIME_METHOD.kind_of?(RuntimeMethod)
+            return true
+          end"
+        -
+          "if ARG_1 == OUTPUT
+            return true
+          end"
+      action:
+        statement: "return x"
+        values:
+          x: ARG_1
+        position: RUNTIME_METHOD.first.statement_id
+      results:
+        -
+          RUNTIME_METHOD.all_pass(ARG_1)
+      """ 
+    And a file named "launch.rb" with:
+      """
+      $LOAD_PATH.unshift File.expand_path( File.join('lib') )
+      require 'cauldron'
+      cauldron = Cauldron::Pot.new
+      cauldron.load_theory File.join('theories','example_1.yml')
+      cauldron.generate [["sparky","sparky"],["kel","kel"]]
+      """   
+    When I run `ruby launch.rb` interactively
+    Then the output should contain:
+      """
+      def extend_function_test_method(var1)
+        return var1
+      end
+      """

data/features/step_definitions/cauldron_steps.rb

@@ -6,6 +6,17 @@
   # end
 # end
 
+Given /^a theory named "([^"]*)" with:$/ do |file_name, string|
+  steps %Q{
+    Given a file named "#{file_name}" with:
+      """
+      #{string}
+      """
+  }
+  FileUtils.mkdir_p(File.join(home,'cauldron','tmp'))
+  FileUtils.cp File.join('.',file_name), File.join(home,'cauldron','tmp',file_name)
+end
+
 When /^I add a case with a param "([^"]*)" and an expected output of "([^"]*)"$/ do |param, output|
   #@terminal.submit("'"+param+,"'+output+'"')  
   @terminal.submit("'#{param}','#{output}'")

data/features/step_definitions/terminal_steps.rb

@@ -1,6 +1,4 @@
 
-include Cauldron::Conversion
-
 Given /^that the terminal has been created$/ do
   @terminal = Cauldron::Terminal.new(output)
   @terminal.start

data/features/support/env.rb

@@ -1,8 +1,10 @@
 $LOAD_PATH << File.expand_path('../../../lib',__FILE__)
 
+#require 'ruby-debug'
 require 'cauldron'
 
 require 'aruba/cucumber'
+# See https://github.com/cucumber/aruba/blob/master/lib/aruba/cucumber.rb for the available steps
 
 class Output
   
@@ -18,4 +20,12 @@ end
 
 def output
   @output ||= Output.new
-end
+end
+
+def home
+  realHome = ["HOME", "HOMEPATH"].detect {|h| ENV[h] != nil}
+  if not realHome
+    raise "Couldn't detect a home directory"
+  end
+  return ENV[realHome]  
+end 

data/features/support/hooks.rb

@@ -12,4 +12,9 @@ end
 
 Before do
   @dirs = ["."]
+end
+
+After do
+  tmp_directory = File.join(home,'cauldron','tmp')
+  FileUtils.rm_r(tmp_directory) if File.exists?(tmp_directory) 
 end

data/lib/cauldron.rb

@@ -1,12 +1,18 @@
 require 'rubygems'
-require 'tempfile'
+require "bundler/setup"
 
-require 'cauldron/util/home'
-require 'cauldron/util/saver'
+require 'logger'
+require 'yaml'
+require 'ruby2ruby'
+require 'ruby_parser'
+#require 'ruby-debug'
 
-require 'required'
+require 'core/string'
 
-require 'cauldron/sexp2cauldron'
-require 'cauldron/conversion'
-require 'cauldron/demos'
+require 'cauldron/pot'
 require 'cauldron/terminal'
+require 'cauldron/relationship'
+require 'cauldron/if_relationship'
+require 'cauldron/numeric_operator'
+require 'cauldron/concat_operator'
+require 'cauldron/array_reverse_operator'

data/lib/cauldron/array_reverse_operator.rb

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

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

@@ -0,0 +1,37 @@
+class IfRelationship < Relationship
+
+  # TODO Need to change to IfSolution probably
+
+  def initialize(problems)
+    @problems = problems
+  end
+
+  def to_ruby
+
+    # Add the arguments
+    args = @problems.first[:arguments]
+    variables = (0...args.length).collect {|x| 'var'+x.to_s}
+    result = ''
+    @problems.each_with_index do |x,i|
+      result += '  if '+variables[0].to_s+' == '+quote(x[:arguments][0])+"\n"
+      result += '    return '+quote(x[:response])+"\n"
+      result += '  end'+"\n"
+    end    
+    result
+  end
+
+  def self.match?(problems)
+    true
+  end
+
+protected
+
+  # TODO Not Dry - method used in Pot
+  def quote(value)
+    if value.kind_of?(String)
+      return "'#{value}'"
+    end
+    value.to_s
+  end
+
+end

data/lib/cauldron/numeric_operator.rb

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

@@ -1,174 +1,66 @@
 module Cauldron
 
   class Pot
-    
-    include Cauldron::Util::Home
-    include ContainsTheories
-      
-    
-    VERSION = '0-1-1'
-    
-    def initialize()
-      StandardLogger.instance.level = Logger::FATAL
-    end
-    
-    # Returns a runtime method that meets the requirements of the test cases.
-    def brew(test_cases)
-      
-      exclude = []
-      chains = next_chains(test_cases,exclude)  
-      if chains.empty?
-        raise StandardError.new('Failed to generate a chain for this problem A')
-      end       
-      
-      runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
-      chains.each do |chain|
-        if chain_valid?(chain,test_cases.copy)
-          validator = TheoryChainValidator.new
-          unified_chain = chain.unify_chain
-          implementation_permutations = unified_chain.implementation_permuatations(runtime_method.copy,test_cases.copy,Mapping.new)
-          return validator.build(runtime_method.copy,test_cases.copy,implementation_permutations)
-        end
-      end    
-      chains.each do |chain|
-        exclude << chain.theories_sequence
-      end
 
-      chains = next_chains(test_cases,exclude)  
-      if chains.empty?
-        raise StandardError.new('Failed to generate a chain for this problem')
-      end        
-      chains.each do |chain|
-        if chain_valid?(chain,test_cases.copy)
-          validator = TheoryChainValidator.new
-          unified_chain = chain.unify_chain
-          implementation_permutations = unified_chain.implementation_permuatations(runtime_method.copy,test_cases.copy,Mapping.new)
-          return validator.build(runtime_method.copy,test_cases.copy,implementation_permutations)
-        end
-      end        
-      raise StandardError.new('Failed to generate a valid runtime method C '+chains.length.to_s)
-      
-    end
-    
-    def chain_valid?(chain,test_cases)
-      if chain.kind_of?(Array)
-        raise StandardError.new('should be a chain '+chain.first.class.to_s) 
-      end
-      runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
-      unified_chain = chain.unify_chain
-      implementation_permutations = unified_chain.implementation_permuatations(runtime_method.copy,test_cases.copy,Mapping.new)
-      
-      # Go through each of the permutations and create the runtime method for the chain
-      validator = TheoryChainValidator.new
-      begin 
-        result = validator.build(runtime_method.copy,test_cases.copy,implementation_permutations)
-      rescue StandardError => e
-        StandardLogger.instance.warning e 
-        return false
-      end
-      return true      
-    end
-    
-    def next_chains(test_cases,exclude=[])
-      theories = saved_theories
-      
-      res = theories.collect {|x| x.theory_id }
-      runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))    
-
-      potential_values = MappingValues.new([])
-      connector = TheoryConnector.new(potential_values)        
-      
-      # Attempt to generate a complete chain for the solution
-      chains = connector.generate_chains(runtime_method,test_cases,theories,exclude)      
-      return chains
+    def solve(problems)
+
+      # Identify the relationship
+      relationship = find_relationship(problems)
+
+      # Generate if statements
+      result = ''
+
+      # Add the arguments
+      args = problems.first[:arguments]
+      variables = (0...args.length).collect {|x| 'var'+x.to_s}
+      result = 'def function('+variables.join(',')+')'+"\n"
+      result << relationship.to_ruby
+      result += 'end'
+
+      result
+
     end
-    
-    def saved_theories
-      # => TODO This needs to cached to prevent error
-      if @cached_saved_theories.nil? 
-        saved_theory_file_paths = Dir.glob(File.join(theory_repository_path,'*','dump'))
-        @cached_saved_theories = saved_theory_file_paths.collect {|x| Marshal.load(File.open(x,'r'))}
+
+  protected
+
+    def quote(value)
+      if value.kind_of?(String)
+        return "'#{value}'"
       end
-      @cached_saved_theories
-    end
-    
-    def simmer(demo)
-      raise StandardError.new('This demo does not work') unless demo_works?(demo)
-      
-      # Generate a master theory for each stage of the runtime method when following the theory chains
-      # generator = TheoryGenerator.new
-      # master_theories = generator.master_theories(
-        # demo[:chain],
-        # demo[:initial_method],
-        # demo[:test_cases]
-      # )
-      
-      # Add each of the theories in the chain to cauldron
-      #master_theories.each {|x| save_theory(x,master_repository_path)}
-      
-      # Save each of the simple versions of the theory
-      demo[:chain].each {|x| save_theory(x,theory_repository_path)}
-           
+      value.to_s
     end
-    
-    # Uses the chain in the demo to construct a runtime method and then checks that 
-    # the runtime method indeed solves the example supplied.
-    #
-    def demo_works?(demo)
-      begin 
-        runtime_method = TheoryChainValidator.new.build(
-                                                          demo[:initial_method],
-                                                          demo[:test_cases],
-                                                          [demo[:chain].implement]
-                                                        )
-      rescue StandardError => e
-        StandardLogger.instance.warning e
-        return false
+
+    def find_relationship(problems)     
+
+      operations = [NumericOperator, ConcatOperator, ArrayReverseOperator]
+
+      # Try each possible operation
+      operations.each do |operation_class|
+
+        # Are all the problems viable for this operation
+        if problems.all? {|x| operation_class.viable?(x[:arguments],x[:response]) }
+          possible_constants = operation_class.find_constants(problems)
+          possible_constants.each do |constant|
+            operator = operation_class.new(constant)
+
+            # Does the operator always result in the correct solution
+            if problems.all? {|x| operator.successful?(x) }
+              return operator
+            end
+          end
+        end
+
       end
-      return true
-    end
-   
-    # Removes all the saved theories to start a fresh
-    def clear
-      cauldron_repository_paths = File.join(home,'cauldron',VERSION,'*')
-      FileUtils.rm_r Dir.glob(cauldron_repository_paths)
-    end
-    
-  private 
-    
-    # Saves the generic theory to file.  This theory will have minimal 
-    # dependents and results.
-    #
-    def save_theory(theory,repository)
-      
-      # Define the theory's directory
-      theory_path = File.join(repository,theory.theory_id.to_s)
-      if File.exists?(theory_path)
-        StandardLogger.instance.warning theory_path+' already exists'
-        #raise StandardError.new('Directory already exists - how as this happened? '+theory.theory_id.to_s) if File.exists?(theory_path)
-        return
+
+      if IfRelationship.match? problems
+        return IfRelationship.new(problems)
       end
-      
-      # Save a file containing the theory
-      FileUtils.mkdir_p(theory_path)
-      dump_file = File.open(File.join(theory_path,'dump'),'w+')
-      data = Marshal.dump(theory)
-      dump_file << data
-      dump_file.close       
-      
-      desc_file = File.open(File.join(theory_path,'desc'),'w+')
-      desc_file << theory.write
-      desc_file.close    
-           
-    end
-    
-    def master_repository_path
-      File.join(home,'cauldron',VERSION,'master-theories')
+      IfRelationShip.new(problems)
     end
     
-    def theory_repository_path
-      File.join(home,'cauldron',VERSION,'theories')
-    end  
-    
   end
-end
+  
+end
+
+# Package Gem
+# http://www.zenspider.com/projects/hoe.html