cauldron 0.1.5 → 0.1.6

data/lib/cauldron/builder.rb

@@ -0,0 +1,60 @@
+module Cauldron
+
+  class Builder
+
+    attr_reader :composite
+
+    def initialize(composite)
+      @composite = composite
+    end
+
+    def tree
+      root_node = Tree::TreeNode.new("ROOT", "Root Content")
+      line_count = 0
+      composite.operators.each do |x|
+        child_node = Tree::TreeNode.new('CHILD-'+line_count.to_s)
+        root_node << child_node
+        line_count += 1
+      end
+    end
+
+    # NOTE: returns an array of new actualized composites extending the current composite
+    def insertable_operators(examples)
+      actualized_composite = ActualizedComposite.new(composite.clone_solution, examples)
+      h = actualized_composite.histories
+      results = self.class.available_statement_types.inject([]) do |total,x|
+        total += x.instances(h, composite, examples, h.insert_points)
+        total 
+      end
+      #binding.pry
+      results
+    end
+
+    def self.available_statement_types
+      
+      # CURRENT
+      # StatementGenerator.new.build(
+      #   ['A','B', 'AC'],
+      #   [:collect]
+      # )+Cauldron::StatementGenerator.new.build('string',[:chop])
+
+      # TRYING
+      # StatementGenerator.new.build(
+      #   ['A','B', 'AC'],
+      #   [:collect]
+      # )+Cauldron::StatementGenerator.new.build('string',[:chop])+[Cauldron::ArrayCollectTemplate::Template]      
+      [StatementGenerator.new.build_template(
+        ['A','B', 'AC'],
+        :collect
+      ).statement_classes.first]+[Cauldron::StatementGenerator.new.build_template('string',:chop).statement_classes.first]+[Cauldron::ArrayCollectTemplate::Template]+[Cauldron::NumberAdditionTemplate::Template]
+
+      # TODO Not very effient to regenerate the opperators
+      # StatementGenerator.new.build(
+      #   ['A','B', 'AC'],
+      #   [:collect]
+      # )+Cauldron::StatementGenerator.new.build('string',[:chop])+[ArrayReverseOperator]+[StatementGenerator.new.build(3,[:+])]
+    end
+
+  end
+
+end

data/lib/cauldron/caret.rb

@@ -0,0 +1,50 @@
+module Cauldron
+
+  class Caret
+
+    #attr_reader :line, :depth, :total_line
+    attr_reader :total_lines, :current_depth
+
+    def initialize
+      @total_lines, @current_depth = 0, 0 #,@line = 0, 0, 0
+      @lines = { 0 => 0}
+    end
+
+    # TODO This approach will need re-worked to support nesting - in  and out
+    def add_line(depth)
+      unless @lines.has_key?(depth)
+        @lines[depth] = 0
+      end
+
+      @total_lines += 1
+      if @current_depth != depth
+        @current_depth = depth
+      else
+        @lines[depth] += 1
+      end
+
+    end
+
+    def point
+      
+    end
+
+    def line
+      @lines[@current_depth]
+    end
+
+    def step_in
+      @current_depth += 1
+      unless @lines.has_key?(@current_depth)
+        @lines[@current_depth] = 0
+      end      
+      #@line = 0
+    end
+
+    def return_depth(depth)
+      @current_depth = depth
+    end
+
+  end
+
+end

data/lib/cauldron/dynamic_operator.rb

@@ -0,0 +1,90 @@
+module Cauldron
+
+  class DynamicOperator
+
+    include Cauldron::Operator
+
+    attr_reader :indexes
+    attr_accessor :failed_uses
+
+    def initialize(information, sexp_methods)
+      @information, @sexp_methods = information, sexp_methods
+      @failed_uses = []
+      @closed = false
+    end
+
+    def uses_constants?
+      @information[:constants]
+    end
+
+    def indexes=(value)
+      raise StandardError.new('') if @closed
+      @indexes = value
+    end
+
+    def close
+      @closed = true
+    end
+
+    def extend_actualized_composite(x, container, examples, point)
+      cloned_container = container.clone_solution
+      cloned_container.add_statement_at(x, point)
+      cloned_container
+      Cauldron::ActualizedComposite.new(cloned_container, examples)
+    end
+
+    def context_realizable?(context)
+      
+      vars = context.keys.select {|x| x.match(/var\d/) }
+      var_names = vars.collect(&:to_s)
+
+      a = %Q{
+      def function(var0)
+        #{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] })  
+      rescue NoMethodError => e
+        return false
+      rescue StandardError => e
+        puts e
+      end
+      return true
+      
+    end
+
+    def write_to_file(filename)
+      FileUtils.mkdir_p File.join('tmp')
+      File.open( File.join('tmp',filename), 'w+') do |file|
+        file << "class DynamicOperator"+"\n"
+        file << Sorcerer.source(@sexp_methods, indent: true)
+        file << "\n"
+        file << "end"
+      end
+    end
+
+    def rip2
+      %Q{
+      def function(var0)
+        #{Sorcerer.source(to_sexp(Cauldron::Scope.new(['var0'])), indent: true)}
+      end
+      }
+    end
+
+    def rip(composite,examples)
+      Ripper::SexpBuilder.new(
+        %Q{
+        def function(var0)
+          #{composite.to_ruby(examples.scope)}
+        end
+      }).parse      
+    end
+
+  end
+
+end

data/lib/cauldron/dynamic_operator_module.rb

@@ -0,0 +1,140 @@
+module Cauldron
+
+  module DynamicOperatorModule
+
+    def uses_constants?
+      @information[:constants]
+    end
+
+    def indexes=(value)
+      raise StandardError.new('') if @closed
+      @indexes = value
+    end
+
+    def close
+      @closed = true
+    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 context_instances(contexts)
+    #   results = []
+    #   contexts.each do |context|
+    #     results << context.keys.collect(&:to_s).select {|x| x.match(/var\d/) }
+    #   end
+    #   results = results.flatten.uniq
+    #   variable_numbers = results.collect { |x| x.match(/var(\d+)/)[1] }
+    #   variable_numbers.collect { |x| init([x.to_i])}
+    # end
+
+    # def extend_actualized_composite(x, container, examples, point)
+    #   cloned_container = container.clone_solution
+    #   cloned_container.add_statement_at(x, point)
+    #   cloned_container
+    #   Cauldron::ActualizedComposite.new(cloned_container, examples)
+    # 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(var0)
+      #   #{Sorcerer.source(to_sexp(var_names), indent: true)}
+      # end
+      # } 
+      # a = %Q{
+      # def function(var0)
+      #   #{Sorcerer.source(to_sexp(Cauldron::Scope.new(var_names), []), indent: true)}
+      # end
+      # }     
+      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
+      
+
+
+      #o.function(*params.values)
+
+      # a = %Q{
+      # def function(var0)
+      #   #{Sorcerer.source(to_sexp(Cauldron::Scope.new(['var0'])), indent: true)}
+      # end
+      # }      
+    end
+
+    def write_to_file(filename)
+      File.open( File.join('tmp',filename), 'w+') do |file|
+        file << "class DynamicOperator"+"\n"
+        file << Sorcerer.source(@sexp_methods, indent: true)
+        file << "\n"
+        file << "end"
+      end
+    end
+
+    def rip(composite,examples)
+      Ripper::SexpBuilder.new(
+        %Q{
+        def function(var0)
+          #{composite.to_ruby(examples.scope)}
+        end
+      }).parse      
+    end
+
+    # def to_tracking_sexp(operators, scope, caret)
+    #   raise StandardError.new('statement has been instance closed') unless @closed
+    #   to_sexp(scope)
+    # end
+
+    def realizable?(histories, point)
+      parameters = histories.variable_permutations(@indexes.length)
+      parameters.each do |params|
+        begin
+          realize(params)
+        rescue => e
+          puts e
+          failed_uses.push(histories)
+          return false
+        end
+      end
+      true          
+    rescue => e
+      puts e
+      puts e.backtrace
+      # TODO GENERATE RSPEC TEST with arguments
+    end
+
+    def realize(params)
+      o = Object.new
+      o.instance_eval(rip2)
+      o.function(*params.values)
+    end    
+
+  end
+
+end

data/lib/cauldron/example.rb

@@ -0,0 +1,18 @@
+module Cauldron
+
+  class Example
+
+    attr_reader :arguments, :response
+
+    def initialize(hash)
+      @arguments, @response = hash[:arguments], hash[:response]
+      @arguments.freeze
+    end
+
+    def params
+      (0...@arguments.length).collect {|x| 'var'+x.to_s}
+    end
+
+  end
+
+end

data/lib/cauldron/example_set.rb

@@ -0,0 +1,36 @@
+module Cauldron
+
+  class ExampleSet
+
+    attr_reader :examples
+
+    def initialize(examples)
+      @examples = examples
+    end
+
+    def variables
+      args = examples.first.arguments
+      (0...args.length).collect {|x| 'var'+x.to_s}      
+    end
+
+    def all?(&block)
+      examples.all?(&block)
+    end
+
+    def collect(&block)
+      examples.collect(&block)
+    end
+
+    # TODO Might drop - limit access
+    def each_with_index(&block)
+      examples.each_with_index(&block)
+    end
+
+    def scope
+      sexp = Ripper::SexpBuilder.new(examples.first.params.to_s).parse
+      Cauldron::Scope.new(eval(Sorcerer.source(sexp)))
+    end    
+
+  end
+
+end

data/lib/cauldron/histories.rb

@@ -0,0 +1,53 @@
+module Cauldron
+
+  class Histories
+
+    def initialize(results)
+      @results = results
+    end
+
+    def variable_permutations(count)
+      variables = @results.first.logs.first.keys.select { |x| x.match /var/ }
+      v = Hash[*variables.collect {|x| [x,nil]}.flatten]
+
+      @results.collect do |history|
+        history.logs.collect do |a|
+          Hash[*v.keys.collect do |x| 
+            [x, a[x] ] 
+          end.flatten(1)]
+        end
+      end.flatten      
+    end
+
+    def each(&block)
+      @results.each(&block)
+    end 
+
+    def first
+      @results.first
+    end
+
+    def length
+      @results.length
+    end
+
+    def insert_points
+      @results.inject([]) { |total, x| total += x.insert_points; total }.uniq
+    end
+
+    def contexts_at(point)
+      a = []
+      @results.each do |history|
+        a += history.logs.inject([]) do |total,log|
+          if log[:point] == point
+            total << log
+          end
+          total
+        end        
+      end
+      a
+    end    
+
+  end
+
+end