cauldron 0.1.0 → 0.1.1

data/lib/cauldron/pot.rb

@@ -6,60 +6,86 @@ module Cauldron
     VERSION = '0-01'
     
     def initialize()
-      
+      #StandardLogger.instance.level = Logger::FATAL
     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'))}    
+      chains = complete_chains(test_cases)
+      if chains.empty?
+        raise StandardError.new('Failed to generate a chain for this problem')
+      end       
+      
+      # => TODO This probably shouldn't be needed
+      written_chains = chains.collect {|x| x.write}
+      unique_written_chains = written_chains.uniq
+      unique_chains = []
+      chains.each do |x|
+        unless unique_chains.any? {|y| y.write == x.write}
+          unique_chains << x
+        end
+      end
+      chains = unique_chains
+      
+      runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
+      chains.each do |chain|
+
+        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
+          next 
+        end
+        return result      
+      end
+      return nil
+      
+    end
+    
+    def complete_chains(test_cases)
+      
+      theories = saved_theories 
       
-      # 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')
+      real_method = Parser.run('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])     
+      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
-      
+      chains = connector.generate_chains(runtime_method,test_cases,theories)      
+      return chains
+    end
+    
+    def saved_theories
+      saved_theory_file_paths = Dir.glob(File.join(theory_repository_path,'*','dump'))
+      saved_theory_file_paths.collect {|x| Marshal.load(File.open(x,'r'))}        
     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])
+      # 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)}
+      #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)}

data/lib/cauldron/sexp2cauldron.rb

@@ -1,155 +1,138 @@
 require 'rubygems'
+require 'ruby2ruby'
 require 'sexp_processor'
 
 module Cauldron
   
   class Sexp2Cauldron < SexpProcessor
     
+    VARIABLE_EXPRESSION = /var[|_]*(\d+)/
+    
     def initialize
       super
-      self.strict = false
       self.expected = Object   
+      self.auto_shift_type = true
+      self.strict = true      
       @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
-#     
+    def in_context type, &block
+      self.context.unshift type
+      yield
+      self.context.shift
+    end    
+    
+    def process_str(exp)
+      Literal.new(exp.shift)
+    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)
+      if next_exp.to_s.match(VARIABLE_EXPRESSION)
+        s = Statement.new(convert_to_variable(next_exp),Equal.new)
       end
-      
-      if next_exp.kind_of?(Symbol)
-        res = process(exp.shift)
-        s.add res
+      a = process(exp.shift)
+      s.add a
+      return s
+    end    
+    
+    def process_if(exp)
+      inner_statement_sexp = exp.shift 
+      scope = process(exp.shift)   # => The content of the if statement
+      exp.shift
+      open_statement = OpenStatement.new(Statement.new(If.new,Container.new(process(inner_statement_sexp))))
+      open_statement << scope unless scope.nil?
+      return open_statement
+    end    
+    
+    def process_return(exp)
+      return Statement.new(Return.new,process(exp.shift))
+    end
+    
+    def process_call(exp)
+      results = []
+      until exp.empty?
+        atom = exp.shift
+        if atom.to_s.match(VARIABLE_EXPRESSION)
+          results << convert_to_variable(atom)
+          next
+        end
+        if atom == :==
+          results << Equivalent.new
+          next
+        end   
+        next if atom.nil?
+        res = process(atom)
+        next if res.nil?
+        results << res     
       end
-      s
+      return Statement.new(*results)
     end    
     
+    def process_arglist(exp)
+      return process exp.shift
+    end
+    
+    def process_defn(exp)
+      type = exp.shift
+      args = exp.shift
+      scope = exp.shift
+      
+      usage = (args.length==2) ? process(args) : MethodUsage.new
+      method_id = type.to_s.match(/method_(\d)+/)[1]
+      method = RuntimeMethod.new(usage,method_id)
+      statements = process(scope)
+      unless statements.nil?
+        statements.each do |statement|
+          method << statement unless statement.nil?
+        end
+      end
+      return method
+      
+    end
+    
+    def process_args(exp)
+      atom = exp.shift
+      variable_id = atom.to_s.match(VARIABLE_EXPRESSION)[1]
+      param = MethodParameter.new()
+      param.variable_id = variable_id
+      return MethodUsage.new(param)
+    end
+    
+    def process_scope(exp)
+      block = exp.shift
+      res = process(block)
+      return res
+    end
+    
+    def process_block(exp)
+      result = []   
+      until exp.empty?
+        atom = exp.shift
+        next if atom.first == :nil
+        result << process(atom)
+      end
+      return result
+    end
+    
+    def process_lvar(exp)
+      var = exp.shift
+      return convert_to_variable(var)
+    end
+    
+  private
+   
+    def convert_to_variable(variable)
+      return Unknown.new(variable.to_s.match(VARIABLE_EXPRESSION)[1])
+    end
+    
   end
   
   

data/lib/cauldron/terminal.rb

@@ -3,11 +3,12 @@ module Cauldron
   class Terminal
     
     include Cauldron::Conversion
+    include Cauldron::Demos
     
     attr_reader :cases
     
     def initialize(output,auto=true)
-      @output, @cases,@auto = output, [], auto
+      @output, @cases, @auto = output, [], auto
     end
     
     def start
@@ -15,7 +16,8 @@ module Cauldron
       @pot = Cauldron::Pot.new
       @pot.clear
       @output.puts '* Adding example case'      
-      @pot.simmer(demo('1'))
+      #@pot.simmer(demo('1'))
+      @pot.simmer(demo_two)
       
       @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"
@@ -42,78 +44,7 @@ module Cauldron
       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