cauldron 0.1.5 → 0.1.6

data/cucumber.yml

@@ -0,0 +1,8 @@
+# config/cucumber.yml
+##YAML Template
+# https://github.com/cucumber/cucumber/wiki/cucumber.yml
+---
+default: --profile main
+html_report: --format progress --format html --out=features_report.html
+bvt: --tags @bvt
+main: --tags ~@wip

data/features/chop.feature

@@ -0,0 +1,23 @@
+Feature: Using String#chop
+
+  Scenario: Using chop example
+    Given I'm using the chop example
+    When I generate a solution
+    Then the solution should include:
+      """
+      def function(var0)
+        var1 = var0.collect do |var2|
+          var2.chop
+        end
+      end
+      """                
+
+  Scenario: Using simple chop example
+    Given I'm using the simple chop example
+    When I generate a solution
+    Then the solution should include:
+      """
+      def function(var0)
+        var0.chop
+      end
+      """      

data/features/create_dynamic_statements.feature

@@ -0,0 +1,14 @@
+Feature: Using dynamic method
+
+  @wip
+  Scenario: Using the collect and + 7 example
+    Given I'm using the collect and plus 7 example
+    When I generate a solution
+    Then the solution should include:
+      """
+      def function(var0)
+        var1 = var0.collect do |var2|
+          var2 + 7
+        end
+      end
+      """ 

data/features/generate_known_solution.feature

@@ -0,0 +1,42 @@
+Feature: Cauldron generates single parameter methods
+
+  Cauldron can generate runtime methods that accepts one parameters
+
+  @announce @slow_process
+  Scenario: Chop the last character off a string
+    Given a file named "launch.rb" with:
+      """
+      $LOAD_PATH.unshift File.expand_path( File.join(['..','..','lib']) )
+      require 'cauldron'
+      cauldron = Cauldron::Pot.new
+      puts cauldron.solve [{arguments: ['Sparky'], response: 'Spark'}, {arguments: ['Kel'], response: 'Ke'}]
+      """   
+    When I run `ruby launch.rb` interactively
+    Then the output should contain:
+      """
+      def function(var0)
+        var0.chop
+      end
+      """
+
+  @announce @slow_process @wip
+  Scenario: Chop the last character off a string
+    Given a file named "launch.rb" with:
+      """
+      $LOAD_PATH.unshift File.expand_path( File.join('lib') )
+      require 'cauldron'
+      cauldron = Cauldron::Pot.new
+      puts cauldron.solve [
+        {arguments: [['Sparky', 'Kels']], response: ['Spark', 'Kel']}, 
+        {arguments: [['Pip','Rowe']], response: ['Pi','Row']}
+      ]
+      """   
+    When I run `ruby launch.rb` interactively
+    Then the output should contain:
+      """
+      def function(var0)
+        var2 = var0.collect do |var1|
+          var1.chop
+        end
+      end
+      """

data/features/generate_new_statement.feature

@@ -0,0 +1,20 @@
+Feature: Cauldron generates single parameter methods
+
+  Cauldron can generate runtime methods that accepts one parameters
+
+  @announce @slow_process @wip
+  Scenario: Using statements that require a constant
+    Given a file named "launch.rb" with:
+      """
+      $LOAD_PATH.unshift File.expand_path( File.join('lib') )
+      require 'cauldron'
+      cauldron = Cauldron::Pot.new
+      puts cauldron.solve [{arguments: [8], response: 4}, {arguments: [12], response: 8}]
+      """   
+    When I run `ruby launch.rb` interactively
+    Then the output should contain:
+      """
+      def function(var0)
+        var0 - 4
+      end
+      """

data/features/step_definitions/cauldron_steps.rb

@@ -28,4 +28,51 @@ Then /^I should receive a runtime method like this "([^"]*)"$/ do |runtime_metho
   output.messages.should include(runtime_method_statement)
 end
 
+Given(/^I'm using the chop example$/) do
+  #pending # Write code here that turns the phrase above into concrete actions
+  @pot = Cauldron::Pot.new
+  @examples = [
+    {arguments: [['Sparky', 'Kels']], response: ['Spark', 'Kel']}, 
+    {arguments: [['Pip','Rowe']], response: ['Pi','Row']}
+  ]
+end
+
+Given(/^I'm using the simple chop example$/) do
+  @pot = Cauldron::Pot.new
+  @examples = [
+    {arguments: ['Andy'], response: 'And'}, 
+    {arguments: ['Kels'], response: 'Kel'}
+  ]
+end
+
+Given(/^I'm using the reverse example$/) do
+  @pot = Cauldron::Pot.new
+  @examples = [
+    {arguments: [['Sparky', 'Kels']], response: ['Kels', 'Sparky']}
+  ]  
+end
+
+Given(/^I'm using the collect and \+ (\d+) example$/) do |arg1|
+  @pot = Cauldron::Pot.new
+  @examples = [
+    {arguments: [[5,7]], response: [10, 12]},
+    {arguments: [[9,15]], response: [14, 20]}
+  ]    
+end
+
+Given(/^I'm using the collect and plus (\d+) example$/) do |arg1|
+  @pot = Cauldron::Pot.new
+  @examples = [
+    {arguments: [[5,7]], response: [12, 14]},
+    {arguments: [[9,15]], response: [16, 22]}
+  ] 
+end
+
+When(/^I generate a solution$/) do
+  @solution = @pot.solve @examples
+end
+
+Then(/^the solution should include:$/) do |string|
+  @solution.should include(string)
+end
 

data/features/support/env.rb

@@ -2,7 +2,7 @@ $LOAD_PATH << File.expand_path('../../../lib',__FILE__)
 
 #require 'ruby-debug'
 require 'cauldron'
-
+require 'pry'
 require 'aruba/cucumber'
 # See https://github.com/cucumber/aruba/blob/master/lib/aruba/cucumber.rb for the available steps
 

data/features/use_existing_statements.feature

@@ -0,0 +1,23 @@
+Feature: Using Array#reverse
+
+  Scenario: Using chop example
+    Given I'm using the reverse example
+    When I generate a solution
+    Then the solution should include:
+      """
+      def function(var0)
+        var0.reverse
+      end
+      """
+
+  Scenario: Using the collect and + 5 example
+    Given I'm using the collect and + 5 example
+    When I generate a solution
+    Then the solution should include:
+      """
+      def function(var0)
+        var1 = var0.collect do |var2|
+          var2 + 5
+        end
+      end
+      """    

data/lib/cauldron.rb

@@ -5,14 +5,50 @@ require 'logger'
 require 'yaml'
 require 'ruby2ruby'
 require 'ruby_parser'
-#require 'ruby-debug'
+require 'sorcerer'
+
+require 'pry_tester'
+require 'pry'
+
+# http://stackoverflow.com/questions/18732338/trying-to-require-active-support-in-gem
+require "active_support/all"
+
+require 'tree'
 
 require 'core/string'
 
 require 'cauldron/pot'
+require 'cauldron/caret'
+require 'cauldron/example'
+require 'cauldron/example_set'
 require 'cauldron/terminal'
-require 'cauldron/relationship'
+require 'cauldron/scope'
+require 'cauldron/histories'
+require 'cauldron/history'
+require 'cauldron/tracer'
+require 'cauldron/operator'
+require 'cauldron/statement_generator'
+require 'cauldron/dynamic_operator'
+require 'cauldron/operator/numeric_operator'
+require 'cauldron/operator/concat_operator'
+require 'cauldron/operator/array_reverse_operator'
+require 'cauldron/operator/hash_key_value_operator'
+require 'cauldron/operator/string_asterisk_operator'
+require 'cauldron/operator/to_s_operator'
+require 'cauldron/operator/var_collect_operator'
 require 'cauldron/if_relationship'
-require 'cauldron/numeric_operator'
-require 'cauldron/concat_operator'
-require 'cauldron/array_reverse_operator'
+
+require 'cauldron/template_base'
+
+require 'cauldron/array_collect_template/default'
+require 'cauldron/array_collect_template/template'
+
+require 'cauldron/number_addition_template/template'
+require 'cauldron/number_addition_template/add_five'
+
+require 'cauldron/dynamic_operator_module'
+
+require 'cauldron/solution/one'
+require 'cauldron/actualized_composite'
+require 'cauldron/solution/composite'
+require 'cauldron/builder'

data/lib/cauldron/actualized_composite.rb

@@ -0,0 +1,35 @@
+module Cauldron
+
+  class ActualizedComposite
+
+    attr_reader :examples, :composite
+
+    # Might include the insert point here too
+    def initialize(composite,examples)
+      @composite, @examples = composite, examples
+    end
+
+    def histories
+      results = @examples.collect do |example|
+                  @composite.record(example)
+                end                
+      Cauldron::Histories.new(results)
+    end
+
+    def extend_solution
+      builder = Builder.new(composite)
+      builder.insertable_operators(examples)
+    end
+
+    def solution?(problems)
+      # TODO Should not need to 
+      composite.solution?(examples)
+    end
+
+    def to_ruby
+      composite.to_ruby(examples.scope)
+    end    
+
+  end
+
+end

data/lib/cauldron/array_collect_template/default.rb

@@ -0,0 +1,95 @@
+module Cauldron
+
+  module ArrayCollectTemplate
+
+    class Default
+
+      attr_reader :indexes
+
+      def initialize(indexes)
+        @indexes = indexes
+      end      
+
+      def context_realizable?(context)
+        
+        vars = context.keys.select {|x| x.match(/var\d/) }
+        var_names = vars.collect(&:to_s)
+        
+        first_variable = 'var'+@indexes[0].to_s
+
+        a = %Q{
+        def function(#{first_variable})
+          #{Sorcerer.source(to_sexp(Cauldron::Scope.new(var_names), []), indent: true)}
+        end
+        }       
+        
+        o = Object.new
+        o.instance_eval(a)
+
+        begin
+          #o.function(*vars.collect {|x| context[x] })  
+          o.function context[first_variable.to_sym]
+        rescue NoMethodError => e
+          return false
+        rescue StandardError => e
+          puts e
+          return false
+        end
+        return true
+   
+      end
+
+      def to_sexp(scope, children)
+        scope_var = scope.new_variable!
+        first_variable = 'var'+@indexes[0].to_s
+        [:method_add_block, 
+          [:call, 
+            [:vcall, 
+              # [:@ident, scope[@indexes[0]] ]], 
+              [:@ident, first_variable ]], 
+              :".", 
+              [:@ident, "collect"]
+          ], 
+          unless children.empty?
+            [:brace_block, 
+              [:block_var, 
+                [:params, [[:@ident, scope_var]]]], 
+                [
+                  :stmts_add, 
+                  [:stmts_new], 
+                  # TODO Shouild probably be passing the children through here
+                  children.first.content.to_sexp(scope, [])
+                ]
+            ]
+          else
+            [:brace_block, 
+              [:block_var, 
+                [:params, [[:@ident, scope_var]]], 
+                [:stmts_add, [:stmts_new]]
+              ]
+            ]        
+          end
+        ]    
+      end
+
+      def to_ruby(scope, operators)
+        Sorcerer.source to_sexp(scope, operators)
+      end
+
+      def clone_statement
+        # TODO Need to clone the sexp methods
+        # o = DynamicOperator.new(@information, @sexp_methods)
+        # o.instance_eval(Sorcerer.source(@sexp_methods, indent: true))
+        # o
+        self.class.new(@indexes.clone)
+      end
+
+      def branch?
+        true
+      end                   
+
+    end
+
+  end
+
+end

data/lib/cauldron/array_collect_template/template.rb

@@ -0,0 +1,57 @@
+module Cauldron
+
+  module ArrayCollectTemplate
+
+    class Template < Cauldron::TemplateBase
+
+      def self.instances(histories, composite, examples, insert_points)
+
+        # TEMP
+        unless examples.class == ExampleSet
+          raise StandardError.new('Examples should be an example')
+        end
+
+        # Print out each insertable statements
+        scope = examples.scope
+
+        # self.init([0]).to_ruby(scope)
+        # - this will print out "var0.chop"
+
+        # Get the variables available at each point
+        results = []
+
+        insert_points.each do |point|
+
+          # Find the variables at a particular point
+          # TODO Change to test
+          contexts = histories.contexts_at(point)
+          composites = context_instances(contexts)
+
+          composites.each do |x|
+            if contexts.all? { |context| x.context_realizable?(context) }
+              #binding.pry
+              results << extend_actualized_composite(x, composite, examples, point)
+            end
+            #results << extend_actualized_composite(x, composite, examples, point)
+          end
+        end
+
+        results
+      end
+
+      def self.context_instances(contexts)
+        temp = []
+        contexts.each do |context|
+          temp << context.keys.collect(&:to_s).select {|x| x.match(/var\d/) }
+        end
+        results = temp.flatten.uniq
+        
+        variable_numbers = results.collect { |x| x.match(/var(\d+)/)[1] }
+        variable_numbers.collect { |x| Cauldron::ArrayCollectTemplate::Default.new([x.to_i])}
+      end      
+
+    end
+
+  end
+
+end