cauldron 0.1.0

data/lib/cauldron/conversion.rb

@@ -0,0 +1,15 @@
+module Cauldron
+  
+  module Conversion
+    
+    def convert_to_example(values)
+      CTestCase.new(values[0...(values.length-1)],values.last)
+    end
+    
+    def separate_values(csv)
+      csv.split(',').inject([]) {|total,x| total <<  eval(x) }
+    end    
+    
+  end
+  
+end

data/lib/cauldron/pot.rb

@@ -0,0 +1,134 @@
+module Cauldron
+
+  class Pot
+    include ContainsTheories  
+    
+    VERSION = '0-01'
+    
+    def initialize()
+      
+    end
+    
+    def brew(test_cases)
+      
+      # * Load each of the theories from the directory
+      saved_theory_file_paths = Dir.glob(File.join(theory_repository_path,'*','dump'))
+      theories = saved_theory_file_paths.collect {|x| Marshal.load(File.open(x,'r'))}    
+      
+      # Prepare the theory chain connector
+      runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))    
+      tc = Parser.run('test_cases')
+      tc_index_0 = IntrinsicLiteral.new(0)
+      tc_index_1 = IntrinsicLiteral.new(1)
+      param_0 = IntrinsicLiteral.new(0)
+      real_method = Parser.run('runtime_method')
+      
+      # TODO  Still need to include last_real_method
+      last_real_method = Parser.run('last_runtime_method')
+      
+      # Create the thoery connector and the values available 
+      # TODO  These values should actually be retreived progressively
+      potential_values = MappingValues.new([tc,tc_index_0,tc_index_1,param_0,real_method])     
+      connector = TheoryConnector.new(potential_values)        
+      
+      # Attempt to generate a complete chain for the solution
+      chains = connector.generate_chains(runtime_method,test_cases,theories) 
+      if chains.empty?
+        raise StandardError.new('Failed to generate a chain for this problem')
+      end       
+      
+      # Now validate each of the chains to check they work
+      # chains.each do |chain|
+        # chain_permutations = chain.unify_chain.implementation_permuatations(runtime_method,test_cases,Mapping.new)
+      # end
+      # TEMP just concentrate of one implementation_permutation
+      implementation_permutations = chains.first.unify_chain.implementation_permuatations(runtime_method,test_cases,Mapping.new)
+      
+      # Go through each of the permutations and create the runtime method for the chain
+      validator = TheoryChainValidator.new
+      result = validator.build(runtime_method,test_cases,implementation_permutations)
+      return result
+      
+    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)}
+           
+    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
+      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 
+  
+    # Check that the home directory exists  
+    def home
+      realHome = ["HOME", "HOMEPATH"].detect {|h| ENV[h] != nil}
+      if not realHome
+        StandardLogger.instance.warning "Couldn't detect a home directory"
+      end
+      return ENV[realHome]  
+    end
+    
+    # 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)
+      raise StandardError.new('Directory already exists - how as this happened?') if File.exists?(theory_path)
+      
+      # 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')
+    end
+    
+    def theory_repository_path
+      File.join(home,'cauldron',VERSION,'theories')
+    end  
+    
+  end
+end

data/lib/cauldron/sexp2cauldron.rb

@@ -0,0 +1,156 @@
+require 'rubygems'
+require 'sexp_processor'
+
+module Cauldron
+  
+  class Sexp2Cauldron < SexpProcessor
+    
+    def initialize
+      super
+      self.strict = false
+      self.expected = Object   
+      @debug[:lasgn] = nil
+      @unsupported_checked = true
+    end
+    
+    def process_lit(exp)
+      type = exp.shift
+      val = exp.shift
+      return Literal.new(val)
+    end
+    
+    # def in_context type, &block
+      # # puts '-------------------------- in_context'
+      # # warn 'kadsjflkasj kldasfj lasdkfj ldksaf'
+      # # puts type
+      # # puts block_given?
+      # # pp self.context
+      # # puts @debug.has_key?(type)
+      # # pp &block
+      # # puts '--------------------999999999999999'
+      # self.context.unshift type
+#   
+      # yield
+#   
+      # self.context.shift
+    # end    
+    
+    # def process(exp)
+        # puts '--------------------------------calling process===================>'
+        # return nil if exp.nil?
+        # exp = self.rewrite(exp) if self.context.empty?
+        # puts '-------------------@unsupported_checked--------->>>>>>>>>>>.'
+        # puts @unsupported_checked
+        # puts '-------------------@unsupported_checked--------->>>>>>>>>>>.'
+        # unless @unsupported_checked then
+          # m = public_methods.grep(/^process_/) { |o| o.to_s.sub(/^process_/, '').to_sym }
+          # supported = m - (m - @unsupported)
+#     
+          # raise UnsupportedNodeError, "#{supported.inspect} shouldn't be in @unsupported" unless supported.empty?
+#     
+          # @unsupported_checked = true
+        # end
+#     
+        # result = self.expected.new
+#     
+        # type = exp.first
+        # raise "type should be a Symbol, not: #{exp.first.inspect}" unless
+          # Symbol === type
+#     
+        # in_context type do
+#           
+          # puts '==============================IN COTEXT('+exp.to_s+') ====================== '
+#           
+          # if @debug.has_key? type then
+            # str = exp.inspect
+            # puts "// DEBUG: #{str}" if str =~ @debug[type]
+          # end
+#     
+          # exp_orig = nil
+          # exp_orig = exp.deep_clone if $DEBUG or
+            # @debug.has_key? type or @exceptions.has_key?(type)
+#     
+          # raise UnsupportedNodeError, "'#{type}' is not a supported node type" if
+            # @unsupported.include? type
+#     
+          # if @debug.has_key? type then
+            # str = exp.inspect
+            # puts "// DEBUG (rewritten): #{str}" if str =~ @debug[type]
+          # end
+#     
+          # # now do a pass with the real processor (or generic)
+          # meth = @processors[type] || @default_method
+          # if meth then
+#     
+            # if @warn_on_default and meth == @default_method then
+              # warn "WARNING: Using default method #{meth} for #{type}"
+            # end
+#     
+            # exp.shift if @auto_shift_type and meth != @default_method
+#             
+            # puts 'Calling method ----------'+meth.to_s
+            # result = error_handler(type, exp_orig) do
+              # self.send(meth, exp)
+            # end
+#     
+            # raise SexpTypeError, "Result must be a #{@expected}, was #{result.class}:#{result.inspect}" unless @expected === result
+#     
+            # self.assert_empty(meth, exp, exp_orig) if @require_empty
+          # else
+            # unless @strict then
+              # until exp.empty? do
+                # sub_exp = exp.shift
+                # sub_result = nil
+                # if Array === sub_exp then
+                  # sub_result = error_handler(type, exp_orig) do
+                    # process(sub_exp)
+                  # end
+                  # raise "Result is a bad type" unless Array === sub_exp
+                  # raise "Result does not have a type in front: #{sub_exp.inspect}" unless Symbol === sub_exp.first unless sub_exp.empty?
+                # else
+                  # sub_result = sub_exp
+                # end
+                # result << sub_result
+              # end
+#     
+              # # NOTE: this is costly, but we are in the generic processor
+              # # so we shouldn't hit it too much with RubyToC stuff at least.
+              # #if Sexp === exp and not exp.sexp_type.nil? then
+              # begin
+                # result.sexp_type = exp.sexp_type
+              # rescue Exception
+                # # nothing to do, on purpose
+              # end
+            # else
+              # msg = "Bug! Unknown node-type #{type.inspect} to #{self.class}"
+              # msg += " in #{exp_orig.inspect} from #{caller.inspect}" if $DEBUG
+              # raise UnknownNodeError, msg
+            # end
+          # end
+#           
+          # puts '--------------------------------DONE ---------------------- context'
+#           
+        # end
+#     
+        # result
+      # end
+#     
+    # => Overwritten method
+    def process_lasgn(exp)
+      exp.shift
+      next_exp = exp.shift
+      if next_exp.to_s.match(/var(\d+)/)
+        s = Statement.new(Unknown.new($1),Equal.new)
+      end
+      
+      if next_exp.kind_of?(Symbol)
+        res = process(exp.shift)
+        s.add res
+      end
+      s
+    end    
+    
+  end
+  
+  
+end

data/lib/cauldron/terminal.rb

@@ -0,0 +1,120 @@
+module Cauldron
+  
+  class Terminal
+    
+    include Cauldron::Conversion
+    
+    attr_reader :cases
+    
+    def initialize(output,auto=true)
+      @output, @cases,@auto = output, [], auto
+    end
+    
+    def start
+      @output.puts 'Starting....'
+      @pot = Cauldron::Pot.new
+      @pot.clear
+      @output.puts '* Adding example case'      
+      @pot.simmer(demo('1'))
+      
+      @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 "'cat','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)
+      if input =~ /^RUN$/
+         @output.puts @pot.brew(@cases).basic_write
+      else
+        @cases << convert_to_example(separate_values(input))
+      end
+    end
+
+   # => ==========================================================================
+    
+    def convert_to_cauldron_test_cases(cases)
+      cases.inject([]) do |total,x|
+        cauldron_case = CTestCase.new
+        cauldron_case[:params] = x[0]
+        cauldron_case[:output] = x[1]
+        total << cauldron_case
+      end
+    end    
+    
+    def demo(id)
+      
+        @demo_1_test_cases = convert_to_cauldron_test_cases(
+          [
+            [['sparky'],'sparky'],
+            [['kel'],'kel']
+          ]
+        )
+        
+        # Create demonstration #2
+        demo_2_test_case_1 = CTestCase.new 
+        demo_2_test_case_1[:params] = ['something']
+        demo_2_test_case_1[:output] = 'exists'
+        demo_2_test_case_2 = CTestCase.new
+        demo_2_test_case_2[:params] = ['my willpower']
+        demo_2_test_case_2[:output] = 'does not exist'
+        demo_2_test_cases = [
+          demo_2_test_case_1,demo_2_test_case_2
+        ] 
+        
+        # Create demo #1 chain
+        #   Create the head for the chain
+        head = Theory.new([],nil,[])    
+        
+        link_one_action = TheoryAction.new(
+          TheoryStatement.new(StringToTheory.run('Statement.new(Return.new,var2.params[var3])')),
+          StringToTheory.run('var1.statement_id')
+        )
+        # NOTE: I need to add one result so the theory can be flagged as complete - I might not need it 
+        #       to be complete -
+        link_one_result = TheoryResult.new(StringToTheory.run("if(var1.all_pass?(var2))\nreturn true\nend"))
+        link_one = Theory.new([],link_one_action,[link_one_result])
+        chain = Chain.new
+        chain = chain.add_link(head).first
+        chain = chain.add_link(
+          link_one,
+          {
+            1=>IntrinsicRuntimeMethod.new,
+            2=>IntrinsicTestCases.new,
+            3=>IntrinsicLiteral.new(0)
+          }
+        ).first
+        
+        # Now implement the chain
+        implemented_chain = chain.implement
+        
+        # TODO  It should generate the values too.(TheoryGenerator)
+        @demo_1 = {
+          :initial_method=>RuntimeMethod.new(MethodUsage.new(MethodParameter.new)),
+          :test_cases=>@demo_1_test_cases,
+          :chain=>chain,
+          :values=>{}
+        }  
+        
+        if id == '1'
+          return @demo_1
+        end
+      
+      end    
+
+  end
+  
+end

data/lib/cauldron/theory_factory.rb

@@ -0,0 +1,10 @@
+
+
+module Cauldron
+  
+  class TheoryFactory
+    
+    
+  end
+  
+end

data/lib/core/ActsAsCode.rb

@@ -0,0 +1,25 @@
+#
+# This module is used in the various code containers used in Cauldren
+#
+module ActsAsCode
+  
+  # Returns a string description of the statement with any of tokens replaced with 
+  # token markers.
+  # 
+  # So var_1 = var_2 + 3
+  #
+  # becomes a = b + c
+  #
+  # The order of replacement is important, the first token becomes a, the second b
+  # and so forth.
+  # 
+  def write_structure
+      # TODO  Not sure how to handle duplicate literals
+      output = self.write
+      self.tokens.zip(('a'..'z').to_a) do |x,y|
+        output.gsub!(x.write,y)
+      end      
+      return output
+  end   
+   
+end