cauldron 0.1.0

data/lib/core/statement/TheoryStatement.rb

@@ -0,0 +1,60 @@
+# This class represents the general descriptions used inside the three
+# components of theories.  
+#
+# TODO  The statement class this extends is extremely bloated but I 
+#       need to create some complex journeys before I can start to 
+#       trim the fat. 
+#
+class TheoryStatement < Statement
+  
+  def initialize(*parameters)
+    super(*parameters)
+  end
+  
+  # TODO  map_to might replace the need for this method
+  # TODO  How does this work for instance call containers and array access?
+  def replace_theory_variables!(mapping)
+    self.each_with_index do |x,i|
+      if x.kind_of?(TheoryVariable) && mapping.has_key?(x.theory_variable_id)
+        self[i] = mapping[x.theory_variable_id].copy
+        next
+      end
+      self[i].replace_theory_variables!(mapping) if self[i].respond_to?(:replace_theory_variables!)
+    end
+  end
+  
+  # TODO  This method was just nicked from TheoryDependent 
+  # TODO  A similar method exists in Statement
+  # 
+  def map_to(mapping)
+    
+    # Duplicate the current statement before it is rewritten
+    rewritten_statement = self.copy
+    
+    # Find all the containers that contain TheoryVariables
+    # NOTE  The statement is put in an array because select all doesn't include the array itself
+    containers = [rewritten_statement].select_all {|x| x.respond_to?(:has?)}
+    theory_variable_containers = containers.select {|x| x.has? {|y| y.kind_of?(TheoryVariable)}}
+    
+    # Rewrite the statement replacing the values
+    theory_variable_containers.each do |z|
+      z.replace_theory_variables!(mapping)
+    end     
+    
+    return rewritten_statement
+    #return TheoryDependent.new(rewritten_statement,@theory_component_id)
+  end  
+  
+  # TODO  Maybe use a opject to handle the output of the statement.
+  def describe(tab=0)
+    line = ''
+    tab.times {line += "\t" }
+    self.each do |code|
+      line += code.describe
+      break if code.object_id == self.last.object_id
+      line += ' '
+    end
+    return line
+  end  
+  
+end

data/lib/core/statement/TopologicalStatements.rb

@@ -0,0 +1,34 @@
+
+#class TopologicalStatements
+#  include TSort
+#   
+#  def initialize
+#    @dependencies = {}
+#  end
+#  
+#  def add_dependency(task,*relies_on)
+#    @dependencies[task] = relies_on
+#  end
+#  
+#  def tsort_each_node(&block)
+#    @dependencies.each_key(&block)
+#  end
+#  
+#  def tsort_each_child(node,&block)
+#    deps = @dependencies[node]
+#    deps.each(&block) if deps
+#  end
+#  
+#end
+
+# See http://www.ruby-doc.org/stdlib/libdoc/tsort/rdoc/classes/TSort.html#M009366
+class TopologicalStatements < Hash
+  include TSort
+   
+  alias tsort_each_node each_key
+  def tsort_each_child(node, &block)
+    fetch(node).each(&block)
+  end
+
+  
+end

data/lib/core/structure/DeclareNewInstanceStructure.rb

@@ -0,0 +1,49 @@
+# Returns statements that declare new instances of the available classes
+# 
+# Example:
+#   var_a = MethodUsage.new
+#   var_b = RuntimeMethod.new(var_a)
+#
+class DeclareNewInstanceStructure < StatementStructure
+  
+  #
+  # @param  available_classes   Any number of class instances that can be used
+  #                             when generating statements, e.g. MethodUsageClass.new
+  #
+  def initialize(*available_classes)
+    super()
+    available_classes.each {|x| self.push(x)}
+  end
+  
+  # Returns an array of instance declaration statements using
+  # the available variables.
+  #
+  # @param  available     An array of variables that are made available 
+  #                       when declaring new statements.
+  #
+  def statements(available=[])
+    
+    # Get all the various arrangements of parameters at all the lengths (capped at 5)
+    arrangements = [[]]
+    
+    # Add one of each available variable
+    available.each do |x|
+      arrangements.push([x])
+    end
+    
+    # For each arrangement create a new statement declaration
+    results = []
+    
+    # Create a number of declaration statements using the method classes
+    # e.g. Unknown.new,Equal.new,ClassMethodCallContainer.new(MethodUsageClass.new,New.new)
+    self.each do |x|
+      x.class_method_calls(available).each do |y|
+        new_statement = Statement.new(Unknown.new,Equal.new,y)
+        results.push(new_statement)
+      end
+    end
+    
+    return results
+  end 
+  
+end

data/lib/core/structure/DeclareRuntimeMethodStructure.rb

@@ -0,0 +1,34 @@
+# TODO  I think this structure has been super seeded by DeclareVariableAsVariableStructure
+# Example - where the method_a returns a RuntimeMethod instance
+# 
+# var_a = method_a()
+#
+class DeclareRuntimeMethodStructure < StatementStructure
+  
+  def initialize()
+    super([Unknown,Equal,RuntimeMethodParameter])
+  end  
+  
+  # Returns an array of possible statements that can be created
+  # using the available variables.  Currently the only way to 
+  # create runtime method instances is via a separate runtime
+  # method call.
+  #
+  # @param  available     An array of variables that can be used to 
+  #                       to create the statements that declared new
+  #                       runtime variables.
+  #
+  def statements(available=[])
+    return [] if available.empty?
+    def_calls = available.find_all {|x| x.kind_of?(DefCall)}
+    results = []
+    def_calls.each do |x|
+      if x.response.class == RuntimeMethodParameter
+        new_statement = Statement.new(Unknown.new,Equal.new,x.copy)
+        results.push(new_statement)
+      end
+    end
+    return results
+  end
+  
+end

data/lib/core/structure/DeclareVariableAsLiteralStructure.rb

@@ -0,0 +1,31 @@
+#
+# Example
+#
+# var = 6
+# var = 'Shepard'
+# var = []
+# 
+class DeclareVariableAsLiteralStructure < StatementStructure
+  
+  def initialize(*available_literals)
+    super([Unknown,Equal,Literal])
+    @available_literals = available_literals
+  end  
+  
+  # TODO  Write tests for this
+  # Returns an array of possible statements that can be created
+  # given the variables supplied.
+  #
+  # @param  available   An array of possible variables that can be used to generate 
+  #                     new statements.  Although for this structure it is only
+  #                     interested in the literals.
+  #
+  def statements(available=[])
+    combined_available = @available_literals + available
+    return [] if combined_available.empty?
+    literals = combined_available.find_all {|x| x.kind_of?(Literal)}
+    results = literals.collect {|x| Statement.new(Unknown.new,Equal.new,x) }
+    return results
+  end    
+  
+end

data/lib/core/structure/DeclareVariableAsVariableStructure.rb

@@ -0,0 +1,52 @@
+# NOTE: I'm not certain whether these types of strucutres are actually necessary
+# but they did exist when I was using StatementStrucuture2.rb
+# 
+# Example
+#
+# var_b = var_a
+# var_c = var_b
+# var_e = var_b.chop
+
+class DeclareVariableAsVariableStructure < StatementStructure
+  
+  def initialize()
+    super([Unknown,Equal,TypeVariable])
+  end    
+  
+  # Returns an array of statements constructed using the supplied
+  # variables. 
+  #
+  def statements(available=[])
+    return [] if available.empty?
+    variables = available.select {|x| x.kind_of?(TypeVariable)}
+
+    # Generate all the possible direct variable declarations e.g. var_a = var_b
+    direct_declarations =  variables.collect {|x| Statement.new(Unknown.new,Equal.new,x.copy)} 
+    
+    # Generate all the possible instance call declarations - I'm not sure if this will be used in this way
+    results = variables.collect do |x|
+      result = x.returning_instance_calls(available).collect do |y| 
+        Statement.new(Unknown.new,Equal.new,y)
+      end
+    end
+    
+    # TODO  This seems a bit sloppy - I should do it in a nicer way
+    instance_call_declarations = []
+    results.each do |x|
+      x.each {|y| instance_call_declarations.push(y)}
+    end
+    
+    # Find all the possible method calss
+    # TODO  Write tests for this method call bit
+    # TODO  This doesn't allow for parameters
+    available.each do |x|
+      if x.kind_of?(DefCall)
+         instance_call_declarations.push(Statement.new(Unknown.new,Equal.new,x.copy))
+      end
+    end    
+  
+    return direct_declarations.concat(instance_call_declarations)
+    
+  end
+  
+end

data/lib/core/structure/FixnumAdditionStructure.rb

@@ -0,0 +1,56 @@
+# Example
+#   e.g. var_a = var_b + var_c
+#
+class FixnumAdditionStructure < StatementStructure
+  
+  def initialize()
+    super([Unknown,Equal,FixnumVariable,Addition,FixnumVariable])
+  end
+  
+  # Returns an array of statements using the available variables that
+  # follow the structure var = 8 + 6
+  #
+  # @param  available     An array of runtime variables that can be used in the statements
+  #                       construction.
+  #
+  def statements(available=[])
+    
+    # If there aren't any fixnum variables there is nothing to return
+    return [] unless available.any? {|x| x.pass_as?(FixnumVariable)}    
+    
+    # First find just varaibles that can pass as FixnumVariables
+    # NOTE: Currently I am not allowing method calls to be used
+    fixnum_variables = available.find_all {|x| x.pass_as?(FixnumVariable) and !x.kind_of?(DefCall)}
+    
+    # Using the variables constuct statements
+    possible_statements = []
+    fixnum_variables.length.times do |x|
+      fixnum_variables.length.times do |y|
+        new_statement = Statement.new(Unknown.new,Equal.new,fixnum_variables[x].copy,Addition.new,fixnum_variables[y].copy)
+        #new_statement.statement_type = DECLARATION_STATEMENT       
+        possible_statements.push(new_statement)
+      end
+    end
+    
+    # Remove mirror statements - these are additions that are essentially the 
+    # same statement written backwards.
+    # e.g.  var_c = var_a+var_b
+    #       var_d = var_b+var_a
+    possible_statements.copy.each do |x|
+      possible_statements.copy.each do |y|
+        next if x.statement_id == y.statement_id
+        if y.same_not_declared_variables?(x)
+          
+          # If the first variable id is lower than the secound remove it.    
+          if y[2].variable_id < y[4].variable_id
+             possible_statements.delete_if {|z| z.statement_id == y.statement_id}
+          end
+        end
+      end
+    end
+    
+    return possible_statements
+        
+  end
+  
+end

data/lib/core/structure/InstanceCallContainerStructure.rb

@@ -0,0 +1,50 @@
+# Example
+#   e.g. 'test'.chop
+#   e.g. 'test'.chop!
+#
+class InstanceCallContainerStructure < StatementStructure
+
+  def initialize()
+    super()
+  end
+  
+  # Returns an array of possible statements that make an instance 
+  # call.  They don't declare a new variables so to be in any way 
+  # relevant they must be destructive e.g.
+  # 
+  # 'test'.chop   # essential does nothing
+  # 'test'.chop!  # Changes the value  ('test' represents a variable with that value)
+  #
+  def statements(available=[])
+
+    # Exclude method calls for now - avoiding too complex statements
+    available.delete_if {|x| x.kind_of?(DefCall)}
+
+    # Go through each method call available to each of the variables
+    results = []
+    available.copy.each do |subject_var|
+
+      # Duplicate the available variables and exclude the current one
+      # to avoid less predicatable statements.
+      current_available = available.copy.delete_if do |x| 
+        unless(x.kind_of?(Variable) and subject_var.kind_of?(Variable))
+          next false
+        end
+        x.variable_id == subject_var.variable_id
+      end
+
+      # Create statements that use the specified instance calls
+      subject_var.destructive_instance_calls(current_available).each do |inst_call|
+        new_statement = Statement.new(inst_call)
+
+        # TODO  I'm not sure if all the instance calls are modifying - I should may have a StatementTemplate
+        #       class that foces the {:review} to be false.
+        #new_statement.statement_type = MODIFYING_STATEMENT
+        results.push(new_statement)
+      end
+    end
+
+    return results
+  end
+  
+end

data/lib/core/structure/InstanceCallStructure.rb

@@ -0,0 +1,53 @@
+# TODO  I think this class might have been replaced with InstanceCallContainerStructure
+class InstanceCallStructure < Array
+  attr_reader :instance_class, :method_call
+  
+  #
+  #  @param   instance_class  The class of the instance that should be called e.g. StringVariable
+  #  @param   method_call     An instance of the method_call
+  #  @param   parameters      The parameters that the instance method call excepts 
+  # 
+  def initialize(instance_class,method_call,*parameters)
+    # TODO  What are the two parameters an array expects
+    super()
+    
+    # Declare the elements that make up the instance call
+    @instance_class = instance_class
+    @method_call = method_call
+    
+    # Add the parameters to the array 
+    parameters.each do |code|
+      self.push(code)
+    end    
+  end
+  
+  #
+  def instance_calls(available=[])
+    
+    # Create an array of potential instance calls
+    potential_instance_calls = []
+    
+    # Find a variable thats class is @instance_class
+    available.each do |avail|
+      
+      if avail.class == @instance_class
+        
+        # We have a possible instance class
+        # TODO  Try with class and method call mismatch
+        if self.length == 0
+          potential_instance_calls.push(InstanceCallContainer.new(avail.copy,@method_call.copy))
+          next
+        end
+        
+        # Retrieve appropriate values for each of the intance calls parameters
+        
+        
+      end
+      
+    end
+    
+    return potential_instance_calls
+        
+  end
+  
+end

data/lib/core/structure/InstanceMethodCallStructure.rb

@@ -0,0 +1,21 @@
+# This a generic structure that can be used to create any number of 
+# instance method calls.  For example if it was meant to represent 
+# an array instance it might be able to produce the statement:
+# 
+# array.push(some_value)
+# 
+# TODO  This might duplicate the functionality of the InstanceCallContainerStructure 
+#       although I can't remember what I created that for.
+# 
+class InstanceMethodCallStructure < StatementStructure
+  
+  # 
+  # @param  instance_class    The class of the instance that has a method call
+  # @param  method_call       A method call instance that can be called from 
+  #                           instances of the supplied instance_class.
+  # 
+  def initialize(instance_class,method_call)
+
+  end
+  
+end