cauldron 0.1.0

data/lib/util/ClassEvaluation.rb

@@ -0,0 +1,68 @@
+# Used to make calls to a dynamically written class.
+#
+class ClassEvaluation
+  #include WriteParameters
+  @@count = 0
+  
+  # TODO  What is original_method about - can I get rid of it.  I need to 
+  #       pass through parameters. 
+  #
+  def evaluate_class(runtime_class,runtime_call,original_method=nil)
+    
+    # Create file to include the test method
+    #filepath = $LOC+File.join(['tmp','runtime_class_evaluation.rb'])    
+    filepath = $LOC+File.join(['tmp',runtime_class.class_name+'.rb'])        
+    file = File.open(filepath,'w+')
+    @@count += 1
+    
+    # Include the sytax for the statement in the file
+    file << runtime_class.write
+    file.close
+
+    # Load the newly created class and check the statement
+    load filepath
+    begin 
+      return eval("#{runtime_class.class_name}.new.#{runtime_call}")
+    rescue NameError => e
+      StandardLogger.instance.error(original_method.write()) unless original_method.nil?
+      StandardLogger.instance.info(runtime_class.write)
+      raise e
+    end
+    
+  end
+  
+  # TODO  This duplicates allot of the code above
+  def evaluate_class_2(runtime_class,runtime_call,*params)
+    
+    # Create file to include the test method
+    #filepath = $LOC+File.join(['tmp','runtime_class_evaluation.rb'])    
+    filepath = $LOC+File.join(['tmp',runtime_class.class_name+'.rb'])        
+    file = File.open(filepath,'w+')
+    @@count += 1
+    
+    # Include the sytax for the statement in the file
+    file << runtime_class.write
+    file.close
+
+    # Load the newly created class and check the statement
+    load filepath
+    begin 
+      # TODO  Make this more generic
+      case params.length 
+        when 0
+          return eval("#{runtime_class.class_name}.new.#{runtime_call}")
+        when 1
+          return eval("#{runtime_class.class_name}.new.#{runtime_call}(params[0])")
+      else
+        raise StandardError.new('Can only handle one parameter right now')
+      end
+    rescue NameError => e
+      StandardLogger.instance.error(original_method.write()) unless original_method.nil?
+      StandardLogger.instance.info(runtime_class.write)
+      raise e
+    end    
+    
+  end
+  
+  
+end

data/lib/util/CodeEvaluation.rb

@@ -0,0 +1,35 @@
+class CodeEvaluation
+  
+  # TODO  I should cap the number of CodeEvaluation classes that can be created
+  @@COUNT = 0
+  
+  # Generates a class and dumps the passed in code into the 
+  # a runtime method within the class and then runs it.
+  #
+  # @param  code    Ruby code as a string
+  # 
+  def evaluate_code(code)  
+    @@COUNT += 1
+    
+    # Create file to include the test method
+    filepath = $LOC+File.join(['tmp',"runtime_code_evaluation_#{@@COUNT}.rb"])
+    file = File.open(filepath,'w+')
+    
+    # Include the sytax for the statement in the file
+    file << "class RuntimeCodeEvaluation#{@@COUNT}"+"\n"
+    file << "\t"+'def check'+"\n"
+    code.each_line do |l|
+      file << "\t\t"+l+"\n"
+    end
+    file << "\t"+'end'+"\n"
+    file << 'end'
+    file.close
+    
+    # Load the newly created class and check the statement
+    load filepath
+
+    return eval("RuntimeCodeEvaluation#{@@COUNT}.new.check")      
+    
+  end
+  
+end

data/lib/util/DeclarationStatementEvaluation.rb

@@ -0,0 +1,31 @@
+class DeclarationStatementEvaluation
+  
+  # NOTE  It might improve performance if this was a singleton
+  def evaluate(written_statement,runtime_methods=[])
+    
+    # Create file to include the test method
+    filepath = $LOC+File.join(['tmp','runtime_declaration_statement_evaluation.rb'])    
+    file = File.open(filepath,'w+')
+    
+    # Include the sytax for the statement in the file
+    file << 'class RuntimeDeclarationStatementEvaluation'+"\n"
+    file << "\t"+'def check'+"\n"
+    file << written_statement
+    file << "\t"+'end'+"\n"
+    
+    # Add and associated runtime methods
+    runtime_methods.each do |x|
+      file << x.write
+    end    
+    
+    file << 'end'
+    file.close
+    
+    # Load the newly created class and check the statement
+    load filepath
+    return RuntimeDeclarationStatementEvaluation.new.check      
+        
+    
+  end
+  
+end

data/lib/util/MethodEvaluation.rb

@@ -0,0 +1,49 @@
+# This class is used to evaluate runtime variables.
+
+class MethodEvaluation
+  @@COUNTER = 0
+  
+  def evaluate_method(runtime_method,params,additional_methods=[])
+
+    # Create file to include the runtime method
+    filepath = $LOC+File.join(['tmp','runtime_method_evaluation.rb'])    
+    #filepath = $LOC+File.join(['tmp','runtime_method_evaluation_'+@@COUNTER.to_s+'.rb'])        
+    file = File.open(filepath,'w+')    
+    
+    # A new class name is created otherwise previously declared method names are peristent.
+    # e.g. if a "RuntimeMethodEvaluation" was created with the method_a it would still 
+    #      be available even if the class was overridden.
+    class_name = 'RuntimeMethodEvaluation'+@@COUNTER.to_s
+    @@COUNTER += 1
+    # TODO  I shouldn't just be incrementing the counter number - these are separate classes
+    file_content = ''
+    
+    # Include the sytax for the statement in the file
+    file_content << 'class '+class_name+"\n"
+    file_content << runtime_method.write(
+      ParametersContainer.new,1,
+      "This is the method that is being evaluated using '#{class_name}.new.#{runtime_method.method_name}"
+    ) 
+    
+    # And any additional methods and close the file
+    additional_methods.each do |x|
+      file_content << x.write(ParametersContainer.new,1)
+    end
+    file_content << "\n"+'end'       
+    file << file_content
+    file.close 
+
+    evaluated_parameters = []
+    params.each do |x|
+      evaluated_parameters.push(x.value)
+    end
+  
+    # Load the generated class
+    load filepath
+
+    # Use the evaluated paramaters with the evaluated runtime method
+    return eval("#{class_name}.new."+runtime_method.method_name+"(*evaluated_parameters)")
+    
+  end
+  
+end

data/lib/util/MethodTester.rb

@@ -0,0 +1,71 @@
+module MethodTester
+  
+  # Returns a runtime method instance that will call the supplied 
+  # runtime method and then test the result against the test 
+  # runtime method.
+  #
+  # @param  solution_method                 This is the method that should generate a runtime
+  #                                         method instance that can be used and produce results
+  #                                         that satisfy the requirements.
+  # @param  return_value_evaluation_method  This method is used to evaluate the result return
+  #                                         from using the solution method.
+  #
+  def access_method(solution_method,return_value_evaluation_method)
+    
+    # Construct the method to test the generated runtime method
+    testing_method = RuntimeMethod.new(MethodUsage.new)
+    generated_instance = Unknown.new
+    
+    # Create the call that captures what is returned by the test method
+    testing_method << Statement.new(generated_instance,Equal.new,DefCall.new(nil,solution_method))
+    
+    # Return the result of the "is_runtime_method_test"
+    testing_method << Statement.new(Return.new,DefCall.new(nil,return_value_evaluation_method,generated_instance))        
+    
+    return testing_method
+    
+  end  
+  
+  # Returns the results of calling the runtime method with the parameters 
+  # provided.
+  # 
+  # @param  runtime_method    A runtime method instance with on or more parameters
+  #
+  def use_runtime_method(runtime_method,params=ParametersContainer.new)
+#      MethodEvaluation.new.evaluate_method(
+#                requirement_testing_method,
+#                ParametersContainer.new,
+#                [reqs,copied_method]+@runtime_methods
+#              )      
+    access_method = RuntimeMethod.new(MethodUsage.new)  
+    access_method.push(Statement.new(Return.new,DefCall.new(nil,runtime_method,*params)))
+    return MethodEvaluation.new.evaluate_method(
+      access_method,
+      ParametersContainer.new,
+      [runtime_method]
+    )
+  end
+  
+  # Generates a class that contains the passed through method and then
+  # calls the passed method using the params provided.
+  #
+  # So if the supplied runtime_method would when written looked like
+  # 
+  # def method_7
+  #   return true
+  # end
+  #
+  # It would then be put into the class and "method_7" would be called using 
+  # the passed parameters.
+  #
+  # @param  runtime_method    A runtime method instance with zero of more parameters
+  #
+  # 
+  def use_runtime_method_2(runtime_method,*params)
+    runtime_class = RuntimeClass.new('RuntimeMethodTester',runtime_method)
+    ClassEvaluation.new.evaluate_class_2(runtime_class,runtime_method.method_name,*params)
+    # return ClassEvaluation.new.evaluate_class(runtime_method,runtime_method.method_name)  
+    
+  end
+  
+end

data/lib/util/MethodValidation.rb

@@ -0,0 +1,145 @@
+# The method generator is passed a number of runtime method instances that it uses
+# to test the runtime methods it generates.  Those that pass the tests are approved
+# those that don't are rejected.  
+#
+# Creating these runtime method instance is a bit verbose so I've created this 
+# class to generate them based on the condition passed through.  
+#
+class MethodValidation
+   include MethodTester
+  
+  # Returns a runtime method instance that expects to be passed 
+  # a runtime method instance and evaluate an attribute of the 
+  # instance. 
+  #
+  # For example it might be passed the condition=> ".kind_of?(RuntimeMethod)" 
+  # and would generate a runtime method instance that would be written like
+  # the following.
+  #
+  # def method_0(var)
+  #   return true if var.kind_of?(RuntimeMethod)
+  #   return false
+  # end
+  # 
+  def self.generate_attribute_test(condition)
+    method_var = MethodParameter.new
+    test_method = RuntimeMethod.new(MethodUsage.new(method_var))  
+    test_method.push(HackStatement.new(
+      'return true if '+method_var.write+condition
+    ))
+    test_method.push(Statement.new(Return.new,False.new))      
+    return test_method
+  end
+  
+  # Returns a runtime method instance that expects a runtime 
+  # method instance as a parameter.  It will then use the passed
+  # in runtime method instance as runtime code and evaluate the
+  # response from the using the method.
+  #
+  # So if it was passed the condition=>' == "Dad"' and the params
+  # => ['Dad'] it would generate a runtime method instance that 
+  # would write() like the following.
+  # 
+  #  def method_8(var_0)
+  #    var_1 = RuntimeMethod.new(MethodUsage.new) 
+  #    var_1.push(Statement.new(Return.new,DefCall.new(nil,var_0,*<params>))) 
+  #    var_2 = RuntimeClass.new('TempClassName',var_0,var_1) 
+  #    return true if ClassEvaluation.new.evaluate_class(var_2,var_1.method_name)  <condition>
+  #    return false 
+  #  end
+  #
+  def self.generate_response_test(condition,params)
+    method_var = MethodParameter.new
+    test_method = RuntimeMethod.new(MethodUsage.new(method_var))  
+    
+    # Create the enterance runtime method
+    # 1.  var_1 = RuntimeMethod.new(MethodUsage.new)
+    var_1 = Unknown.new
+    test_method.push(
+      Statement.new(
+        var_1,
+        Equal.new,
+        ClassMethodCallContainer.new(
+          RuntimeMethodClass.new,
+          New.new,
+          ClassMethodCallContainer.new(MethodUsageClass.new,New.new)
+        )
+      )
+    )
+    # 2.   var_1.push(Statement.new(Return.new,DefCall.new(nil,var_0,*<params>))) 
+    test_method.push(
+      Statement.new(
+        InstanceCallContainer.new(
+          var_1,
+          Push.new,
+          ClassMethodCallContainer.new(
+            StatementClass.new,
+            New.new,
+            ClassMethodCallContainer.new(
+              ReturnClass.new,
+              New.new
+            ),
+            ClassMethodCallContainer.new(
+              DefCallClass.new,
+              New.new,
+              Nil.new,
+              method_var,
+              *params
+            )
+          )
+        )
+      )
+    )
+    # 3.  var_2 = RuntimeClass.new('TempClassName',var_0,var_1) 
+    var_2 = Unknown.new
+    test_method.push(
+      Statement.new(
+        var_2,
+        Equal.new,
+        ClassMethodCallContainer.new(
+          RuntimeClassClass.new,
+          New.new,
+          'TempClassName'.to_literal,
+          method_var,
+          var_1
+        )
+      )
+    )
+    # 4.  var_3 = ClassEvaluation.new
+    var_3 = Unknown.new
+    test_method.push(
+      Statement.new(
+        var_3,
+        Equal.new,
+        ClassMethodCallContainer.new(
+          ClassEvaluationClass.new,
+          New.new        
+        )
+      )
+    )
+    # 5.  return true if var_3.evaluate_class(var_2,var_1.method_name)<condition>
+    test_method.push(
+      Statement.new(
+        Return.new,
+        True.new,
+        If.new,
+        InstanceCallContainer.new(
+          var_3,
+          EvaluateClassCall.new,
+          var_2,
+          InstanceCallContainer.new(var_1,MethodNameCall.new)
+        ),
+        Raw.new(condition)
+      )
+    )
+    # 6.  return false  
+    test_method.push(
+      Statement.new(
+        Return.new,
+        False.new
+      )
+    )
+    return test_method
+  end
+  
+end

data/lib/util/MethodWriter.rb

@@ -0,0 +1,66 @@
+# TODO  This instance should replace the write method in ActsAsRuntimeMethod
+
+class MethodWriter
+  include WriteParameters
+  
+  def initialize
+    
+  end
+  
+  def write(params,statements,tab=0,method_id=0,additional_comments='')
+
+    line = "\n"    
+    tab.times {|x| line += "\t" }
+    line += "#\n"
+
+    params.each_with_index do |var,i|       
+      tab.times {|x| line += "\t" }
+      line += "#\t@param\t"
+    
+      # Get a description of the requirements (this can multiple lines)
+      line_prefix = ''
+    
+      desc = var.describe(tab)
+      desc.each_line do |l|
+        line += line_prefix+l
+        
+        # Assides the first line pre-fix a "#      " to the start
+        (tab-1).times {|x| line += "\t" }
+        line_prefix = "#\t\t\t"
+        
+      end
+      
+    end
+    
+    # Add some some additional comment if supplied
+    unless additional_comments.nil?
+      tab.times {|x| line += "\t" }
+      line += "#"
+      tab.times {|x| line += "\t" }
+      line += additional_comments+"\n"
+    end    
+    
+    tab.times {|x| line += "\t" }
+    line += "#\n"               
+    
+    tab.times {|x| line += "\t"}
+    line += 'def method_'+method_id.to_s 
+    
+    #line += write_params(@parameters)
+    line += write_params(params)
+    line += "\n"
+    
+    # Write out any statements within the method
+    statements.each do |statement|
+      line += statement.write(tab+1)+"\n"
+    end
+    line += "\n" if statements.empty?
+    
+    # Close the method
+    tab.times {|x| line += "\t" }
+    line += "end"+"\n"
+    
+    return line    
+  end
+  
+end