cauldron 0.1.0 → 0.1.1

data/lib/core/ClassMethodCallContainer.rb

@@ -41,5 +41,19 @@ class ClassMethodCallContainer < CallContainer
     end
     return true 
   end
+  
+  def replace_variables_alt!(map)
+    @parameters.each_with_index do |x,i|
+      if x.kind_of?(TheoryVariable)
+        map.each do |key,value|
+          if x.theory_variable_id == key.theory_variable_id
+            @parameters[i] = value
+          end
+        end
+      else
+        x.replace_variables_alt!(map)
+      end
+    end  
+  end
  
 end

data/lib/core/Container.rb

@@ -16,13 +16,24 @@ class Container
     end
   end     
 
+  def subst_variable!(id,var)
+    @tokens.each_with_index do |token,i|
+      if token.kind_of?(Variable) && id == token.variable_id
+        @tokens[i] = var
+      end
+      if token.kind_of?(Statement)
+        token.subst_variable!(id,var)
+      end
+    end
+    self
+  end
+
   def write(tab=0)
     line = '('
     tab.times {line += "\t" }
     @tokens.each do |code|
       line += code.write
       break if code.object_id == @tokens.last.object_id
-      line += ' '
     end
     return line+')'
   end
@@ -33,7 +44,6 @@ class Container
     @tokens.each do |code|
       line += code.describe
       break if code.object_id == @tokens.last.object_id
-      line += ' '
     end
     return line+')'
   end  

data/lib/core/InstanceCallContainer.rb

@@ -21,7 +21,7 @@ class InstanceCallContainer < CallContainer
   #  
   def initialize(subject,method_call,*params)
     raise StandardError.new('Use ClassMethodCallContainer here') if subject.kind_of?(ClassName)
-    super(subject,method_call,*params)    
+    super(subject,method_call,*params)        
   end
   
   def write_with_uniq_id
@@ -248,6 +248,32 @@ class InstanceCallContainer < CallContainer
     end
     return true
   end
+  
+  def replace_variables_alt!(map)
+    if @subject.kind_of?(TheoryVariable)
+      map.each do |key,value|
+        if @subject.theory_variable_id == key.theory_variable_id
+          @subject = value
+          break
+        end
+      end
+    elsif(@subject.kind_of?(StringLengthClass))
+    else
+      @subject.replace_variables_alt!(map)
+    end
+    
+    @parameters.each_with_index do |x,i|
+      if x.kind_of?(TheoryVariable)
+        map.each do |key,value|
+          if x == key
+            @parameters[i] = value
+          end
+        end
+      else
+        @parameters.replace_variables_alt!(map)
+      end
+    end
+  end
     
 protected
 
@@ -262,9 +288,9 @@ protected
     copied_subject = @subject.copy
     
     # Retrieve any requirements associated with the method call
-    @method_call.requirements do |req|
-      copied_subject.push(req)
-    end
+    # @method_call.requirements do |req|
+      # copied_subject.push(req)
+    # end
     return copied_subject
     
   end

data/lib/core/TheoryGenerator.rb

@@ -17,14 +17,7 @@ class TheoryGenerator
     #   * Create the values array [{:value=>x,:statement=>:step=>}]
     master_theories = []
     chain.each_theory_progression(initial_runtime_method,test_cases) do |implemented_theory,theory|
-    
-      # TODO  Include this as a test to confirm an exception is raised
-      # QUICK:  Adding a new value in the test cases :after so it changes the output
-      #         and the variable mapping - the error should be picked up.
-#      if implemented_theory.accessor_values[:after][1]
-#        implemented_theory.accessor_values[:after][1].push({:params=>["pip"],:output=>"pip"})
-#      end
-      
+          
       dependent_accessors = retrieve_accessors(implemented_theory.accessor_values[:before],creation_history)
       result_accessors = retrieve_accessors(implemented_theory.accessor_values[:after],creation_history)
       
@@ -279,7 +272,7 @@ class TheoryGenerator
         actions << TheoryAction.new(
           TheoryStatement.new(
             StringToTheory.run(
-              "OpenStatement.new(IfContainer.new(#{x[:statement].write},Equivalent.new,#{y[:statement].write}))"
+              "OpenStatement.new(Statement.new(If.new,Container.new(#{x[:statement].write},Equivalent.new,#{y[:statement].write})))"
             )
           ),
           StringToTheory.run(z[:statement].write)

data/lib/core/assignment/Equal.rb

@@ -8,7 +8,7 @@ class Equal < Equivalent
   end
   
   def write()
-    return '='
+    return ' = '
   end
   
   def describe

data/lib/core/assignment/Equivalent.rb

@@ -6,7 +6,7 @@ class Equivalent < Assignment
   end
   
   def write
-    return '=='
+    return ' == '
   end
   
   def copy

data/lib/core/assignment/NotEqual.rb

@@ -8,7 +8,7 @@ class NotEqual < Assignment
   end
   
   def write()
-    return '!='
+    return ' != '
   end
   
 end

data/lib/core/call_container/CallContainer.rb

@@ -48,7 +48,13 @@ class CallContainer < Array
      @parameters.select_all(results,&block)
      return results
   end
-
+  
+  def map_to(mapping)
+    a = copy
+    a.replace_theory_variables!(mapping)
+    return a
+  end
+  
   def replace_theory_variables!(mapping)
     @parameters.each_with_index do |x,i|
       if x.kind_of?(TheoryVariable) && mapping.has_key?(x.theory_variable_id)

data/lib/core/instance_call/Chop.rb

@@ -2,11 +2,6 @@ class Chop <InstanceCall
   
   def initialize
     super
-    
-    @use_requirements = [
-      Requirement.new(InstanceCallContainer.new(This.new,ClassCall.new), Equal.new , StringClass.new)
-    ]
-    
   end
   
   def write
@@ -17,10 +12,6 @@ class Chop <InstanceCall
     return Chop.new
   end
   
-  def requirements
-    @use_requirements.each {|req| yield req}
-  end
-  
   def use(val)
     return val.chop
   end

data/lib/core/instance_call/instance_calls.rb

@@ -166,3 +166,11 @@ class Select < InstanceCall
   end
 
 end
+
+class First < InstanceCall
+  
+  def write
+    return '.first'
+  end  
+  
+end

data/lib/core/instance_call/length_equal.rb

@@ -5,7 +5,7 @@ class LengthEqual < InstanceCall
   end
   
   def write 
-    return '.length ='
+    return '.length = '
   end
   
   def copy

data/lib/core/requirement/Requirement.rb

@@ -10,6 +10,7 @@ class Requirement < Array
   alias :array_push :push
   
   def initialize(*parameters)
+    #raise StandardError.new('---------------------This is redundant')
     super()
     parameters.each do |param|
       self.push param

data/lib/core/runtime_class/class_names.rb

@@ -22,18 +22,6 @@ class OpenStatementClass < ClassName
   
 end
 
-class IfContainerClass < ClassName
-  
-  def initialize
-    super
-  end
-  
-  def write(context=nil)
-    return 'IfContainer'
-  end  
-  
-end
-
 class BlockStatementClass < ClassName
   
   def initialize
@@ -92,4 +80,16 @@ class ChopClass < ClassName
     return 'Chop'
   end  
   
+end
+
+class IfClass < ClassName
+  
+  def initialize
+    super
+  end
+  
+  def write(tab=0)
+    return 'If'
+  end  
+  
 end

data/lib/core/runtime_method/ActsAsRuntimeMethod.rb

@@ -2,7 +2,6 @@
 module ActsAsRuntimeMethod
   include WriteParameters
   
-  # TODO  Write tests
   # Returns a variable instance with the id specified.  This essential just finds the varialbe
   # at the last line of the method.
   # 
@@ -10,10 +9,6 @@ module ActsAsRuntimeMethod
   #             variable id.
   #
   def find_variable(uniq_id)
-    #return find_variable_at_line(id,self.length)
-    #statement_count
-    # TODO  I don't know whether I should be using statement_count, self.length or line_count
-    #return find_variable_at_line(id,self.length)
     
     # TODO  I don't know if progressively building up the method is necessary now
     
@@ -61,7 +56,6 @@ module ActsAsRuntimeMethod
     raise StandardError.new('Failed to find statement that declared variable '+variable_id.to_s)
   end  
   
-  # TODO  Write tests
   def find_statement_that_created_variable(uniq_id)
     self.each do |x|
       if x.kind_of?(Statement)
@@ -172,7 +166,6 @@ module ActsAsRuntimeMethod
     self.each do |statement|
       line += statement.write(tab+1)+"\n"
     end
-    line += "\n" if self.empty?
     
     # Close the method
     tab.times {|x| line += "\t" }

data/lib/core/runtime_method/RuntimeMethod.rb

@@ -11,6 +11,7 @@ class RuntimeMethod < StatementGroup
   
   attr_reader :method_id, :method_return, :usage
   attr_writer :method_id
+    
   
   alias :statement_group_push :array_push
   
@@ -24,13 +25,16 @@ class RuntimeMethod < StatementGroup
   #                         parameters.length
   # @param  method_return   The response variable to return or nil if nothing is returned
   #
-  def initialize(usage,method_return=nil,*statements)  
+  #def initialize(usage,method_return=nil,*statements)
+  def initialize(usage,method_id=nil,*statements)      
     super(*statements)
     
     # Set the method id for the generated method
-    @method_id = @@METHOD_ID
-    
-    @@METHOD_ID += 1
+    if method_id.nil?
+      @@METHOD_ID += 1
+      method_id = @@METHOD_ID
+    end 
+    @method_id = method_id
     
     # Save how the method should be used
     @usage = usage
@@ -79,6 +83,42 @@ class RuntimeMethod < StatementGroup
     )  
   end
   
+  def reset_ids!
+    copied_method = copy
+    copied_method.method_id = '0'
+    unique_variable_ids = variables.collect {|x| x.variable_id}.uniq
+    reset_variable_ids = (0...unique_variable_ids.length)
+    mapping = {}
+    unique_variable_ids.zip(reset_variable_ids.to_a) do |var_id,reset_id|
+      mapping[var_id] = reset_id
+    end
+    
+    method_parameters = []
+    @usage.each do |x|
+      method_parameters.push(MethodParameter.new(mapping[x.variable_id]))
+    end
+    usage = MethodUsage.new(*method_parameters)
+    
+    copied_method.usage = usage
+    
+    replacement_mapping = {}
+    mapping.each do |var_id,reset_id|
+      replacement_mapping[var_id] = Unknown.new(reset_id)
+    end
+    
+    copied_method.each do |statement|
+      replacement_mapping.each do |var_id,value|
+        statement.subst_variable!(var_id,value)
+      end
+    end
+    
+    copied_method
+  end
+  
+  def variables
+    return @usage
+  end
+  
   # Returns an array of variables that are available at a particular line
   # in the method.
   # 
@@ -105,7 +145,6 @@ class RuntimeMethod < StatementGroup
 
     concept.each_unknown do |unknown|
       
-      #temp = gets
       # Go through each of the varialbes and see if they could be the unknown
       available_variables.each do |var|
 
@@ -328,9 +367,8 @@ class RuntimeMethod < StatementGroup
 
   # Returns a duplicate method but without any statements in it
   #
-  def copy_base
-    copied_method = RuntimeMethod.new(@usage.copy,@method_return.copy)      
-    copied_method.method_id = method_id 
+  def copy_base     
+    copied_method = RuntimeMethod.new(@usage.copy,method_id) 
     return copied_method
   end      
   
@@ -376,8 +414,12 @@ class RuntimeMethod < StatementGroup
   # Returns a statement that declares the runtime method instance.
   # e.g. RuntimeMethod.new(MethodUsage.new,ResponseVariable.new)
   #
-  def declaration_statement
-    new_runtime_method = ClassMethodCallContainer.new(RuntimeMethodClass.new,New.new,@usage.declaration_statement,@method_return.declaration_statement)    
+  def declaration_statement    
+    new_runtime_method = ClassMethodCallContainer.new(
+                            RuntimeMethodClass.new,
+                            New.new,
+                            @usage.declaration_statement
+    )
     return Statement.new(new_runtime_method)
   end
   
@@ -535,7 +577,7 @@ class RuntimeMethod < StatementGroup
     copied = self.copy.trackify(params,tracking_method)
     
     # Create a method to call the method and return the results
-    process_method = RuntimeMethod.new(MethodUsage.new,History.new)
+    process_method = RuntimeMethod.new(MethodUsage.new)
     track_statement = Statement.new( DefCall.new(NilVariable.new,copied,*params.collect {|x|  x.value} ) )
     process_method << track_statement
     return_statement = Statement.new( Return.new,instance_tracking_variable )
@@ -545,7 +587,7 @@ class RuntimeMethod < StatementGroup
     # TODO  This might need to have a number pre-fixed (I'm not certain it's overwritten)
     # runtime_class = RuntimeClass.new('Temporary'+rand(1000).to_s,tracking_method,copied,process_method,*additional_methods)
     runtime_class = RuntimeClass.new('Temporary',tracking_method,copied,process_method,*additional_methods)  
-    result = ClassEvaluation.new.evaluate_class(runtime_class,process_method.method_name,self)
+    result = ClassEvaluation.new.evaluate_class(runtime_class,process_method.method_name)
     return result 
   end
   
@@ -780,38 +822,10 @@ class RuntimeMethod < StatementGroup
     return IntrinsicRuntimeMethod.new()
   end
   
-private  
+protected
+  
+  def usage=(usage)
+    @usage = usage
+  end
   
-#  # TODO  Not sure this is needed
-  # This returns an array of variables and def_calls by replacing
-  # any supplied runtime_method instances with def_calls.
-  #
-  def convert_methods_to_def_calls(available)
-    updated_available = []
-    available.each do |x|
-      if(x.kind_of?(RuntimeMethod))
-        
-        # Create a copy of available values (removing the call for this method)
-        copied_available = available.collect! {|x| x.copy}
-
-        # Separate the variables from the runtime method
-        copied_avialable_vars = copied_available.find_all {|y| y.kind_of?(Variable)}        
-
-        # Separate the runtime method calls from the variables excluding the current method
-        copied_avialable_methods = copied_available.find_all {|y| y.kind_of?(RuntimeMethod)}        
-        copied_avialable_methods.delete_if {|y| y.method_id == x.method_id }
-        
-        # Combine the two so that the method used is excluded to prevent recursive calls                        
-        safe_copied_available = copied_avialable_methods+copied_avialable_vars
-        
-        # Convert any runtime method instances to def_call instances
-        updated_available += x.callable_combinations(safe_copied_available)
-        
-      else
-        updated_available.push(x)
-      end
-    end    
-    return updated_available    
-  end    
-    
 end