cauldron 0.1.3 → 0.1.5

data/lib/util/ClassEvaluation.rb

@@ -1,44 +0,0 @@
-
-# Used to make calls to a dynamically written class.
-#
-class ClassEvaluation
-  @@count = 0
-  
-  def evaluate_class(runtime_class,runtime_call)    
-    return evaluate_class_2(runtime_class,runtime_call)
-  end
-  
-  def evaluate_class_2(runtime_class,runtime_call,*params)
-    
-    # Create file to include the test method
-    file = Tempfile.new(runtime_class.class_name+'.rb')
-    @@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 file.path
-    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.info(runtime_class.write)
-      raise e
-    ensure 
-      file.close
-      file.unlink
-    end  
-    
-  end
-  
-  
-end

data/lib/util/CodeEvaluation.rb

@@ -1,39 +0,0 @@
-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
-    
-    begin
-      
-      # Create file to include the test method 
-      file = Tempfile.new("runtime_code_evaluation_#{@@COUNT}.rb")
-      
-      # 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 file.path
-  
-      return eval("RuntimeCodeEvaluation#{@@COUNT}.new.check")
-    ensure 
-      file.close
-      file.unlink      
-    end
-  end
-  
-end

data/lib/util/DeclarationStatementEvaluation.rb

@@ -1,32 +0,0 @@
-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
-    file = Tempfile.new("runtime_declaration_statement_evaluation.rb")   
-    
-    # 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      
-        
-  ensure 
-      file.close
-      file.unlink          
-  end
-  
-end

data/lib/util/MethodEvaluation.rb

@@ -1,49 +0,0 @@
-# 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    
-    file = Tempfile.new("runtime_method_evaluation.rb")      
-    
-    # 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 file.path
-
-    # Use the evaluated paramaters with the evaluated runtime method
-    return eval("#{class_name}.new."+runtime_method.method_name+"(*evaluated_parameters)")
-  ensure 
-      file.close
-      file.unlink          
-  end
-  
-end

data/lib/util/MethodTester.rb

@@ -1,71 +0,0 @@
-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

@@ -1,149 +0,0 @@
-# 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>
-    s = Statement.new(
-      If.new,
-      Container.new(
-        InstanceCallContainer.new(
-          var_3,
-          EvaluateClassCall.new,
-          var_2,
-          InstanceCallContainer.new(var_1,MethodNameCall.new)
-        ),
-        Raw.new(condition)      
-      )
-    )
-    os = OpenStatement.new(s)
-    os << Statement.new(Return.new,True.new)
-    test_method.push(os)
-    
-    #test_method.push(s)
-    
-    # 6.  return false  
-    test_method.push(
-      Statement.new(
-        Return.new,
-        False.new
-      )
-    )
-    return test_method
-  end
-  
-end

data/lib/util/MethodWriter.rb

@@ -1,66 +0,0 @@
-# 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 += "  " }
-    line += "#\n"
-
-    params.each_with_index do |var,i|       
-      tab.times {|x| line += "  " }
-      line += "#  @param  "
-    
-      # 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 += "  " }
-        line_prefix = "#      "
-        
-      end
-      
-    end
-    
-    # Add some some additional comment if supplied
-    unless additional_comments.nil?
-      tab.times {|x| line += "  " }
-      line += "#"
-      tab.times {|x| line += "  " }
-      line += additional_comments+"\n"
-    end    
-    
-    tab.times {|x| line += "  " }
-    line += "#\n"               
-    
-    tab.times {|x| line += "  "}
-    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 += "  " }
-    line += "end"+"\n"
-    
-    return line    
-  end
-  
-end