cauldron 0.1.0

data/lib/ChainMapping.rb

@@ -0,0 +1,172 @@
+# note about the global mapping=>
+#
+# This method needs to map the theory variables used in one theory to the 
+# rest.  This basically means there is a global theory that has a respective
+# id in each of the other theories in the chain. e.g.
+#
+# +----------+--------+--------+--------+--------+
+# |Global #ID| head   | link#2 | link#3 | link#4 |
+# +----------+--------+--------+--------+--------+
+# |    0     |   1    |   1    |   2    |   89   |
+# +----------+--------+--------+--------+--------+
+# |    1     |   2    |   4    |   6    |   1    |
+# +----------+--------+--------+--------+--------+
+
+class ChainMapping
+  attr_reader :mapping, :history
+  
+  def initialize(mapping={},history=[])
+    @history, @mapping = history, mapping
+  end
+  
+  def copy
+    return ChainMapping.new(@mapping.copy,@history.copy)
+  end
+  
+  # Returns the global id for the this theory variable in this theory.
+  #
+  # @param  theory_id     The id of the theory that is being retreived
+  # @param  variable_id   The id of the theory variable in the context of the single theory
+  #
+  def find_global(theory_instance_id,variable_id)
+    res = @mapping.detect do |key,value|
+      value.has_key?(theory_instance_id) && value[theory_instance_id] == variable_id
+    end
+    return nil if res.nil?
+    return res[0]
+  end
+  
+  def same?(chain_map)
+    return false if @mapping.length != chain_map.mapping.length
+    return false if @history.length != chain_map.history.length
+    return @history == chain_map.history
+  end
+  
+  # Adds a new variable mapping to a global id
+  # TODO  Assigning global_id should probably not be allowed publically
+  #
+  def add_mapping(global_id,theory_instance_id,variable_id)
+    if @mapping[global_id].nil?
+      @mapping[global_id] = {}
+    end
+    # TODO  Write tests to check that the error is raised
+    unless @mapping[global_id][theory_instance_id].nil?
+      if @mapping[global_id][theory_instance_id] != variable_id
+        raise ChainMappingError.new('This global variable has already been defined')
+      end
+    end
+    # TODO  Should check that the theory_id#variable_id has not already been assigned to a global id
+    @mapping[global_id][theory_instance_id] = variable_id
+  end
+  
+  # TODO  I'd like to change global ids to letters for clarity
+  # Returns the next key that hasn't been defined in the mapping
+  def next_free_global_id
+    a = (0..100).to_a.detect() {|x| !@mapping.has_key?(x)}
+    raise StandardError.new('No more free global id') if a.nil?
+    return a
+  end
+  
+  # Returns a string listing all the dependent to result connections 
+  # that have been made.
+  #
+  def display_history
+    @history.each do |x|
+    end
+  end
+  
+  # TODO  This is temporary - it doesn't resolve the issue of the same theory
+  #       being used twice.
+  # Returns all the components that have been sucessfully connected to another
+  # component.
+  #
+  def connected_component_ids
+    @history.inject([]) {|total,x| total += x}
+  end
+  
+  # Either returns an updated chain mapping if the mapping works or returns the 
+  # existing mapping.
+  #
+  def apply_mapping_update(theory_a,component_a_id,theory_b,component_b_id)
+    updated_mapping = copy
+    begin 
+      updated_mapping.connect(theory_a,component_a_id,theory_b,component_b_id)
+    rescue ChainMappingError => e
+      StandardLogger.instance.warning e
+      return self.copy
+    end
+    return updated_mapping
+  end
+  
+  # TODO  I need to include a mapping that doesn't declare a globlal_id.  A global id only needs 
+  #       identified when connecting separate theories.
+
+  # TODO  Mapping is not about theory_component_id it is about what is connected to what and
+  #       when - consider when the same theory is added twice but connected differently.
+  
+  # TODO  This needs wrapped in some transaction incase one of the mappings won't work
+  #       or in the wider context some of the other connections won't work.
+  
+  # Updates the global mapping to connect the two theories so that
+  # they share the same global mapping
+  #
+  # TODO  Need to include the theories instance id  
+  #
+  def connect(theory_a,component_a_id,theory_b,component_b_id)
+     
+     #  Retrieve each of the components
+     component_a = theory_a.find_component(component_a_id)
+     component_b = theory_b.find_component(component_b_id)
+     
+     #  Check that the number of variables match
+     unless component_a.theory_variables.length == component_b.theory_variables.length
+       raise ChainMappingError.new('These components do not have the same number of variables') 
+     end
+     
+     #  Go through each variable and confirm they have the same global mapping
+     component_a.theory_variables.zip(component_b.theory_variables) do |variable_a,variable_b|
+     
+        # Do any of the theory variables already have a global id
+        global_var_a = find_global(theory_a.theory_instance_id,variable_a.theory_variable_id)
+        global_var_b = find_global(theory_b.theory_instance_id,variable_b.theory_variable_id)
+
+        # Nearly variables has been added as global - add new global connections
+        if ([global_var_a,global_var_b].all? {|x| x.nil?})
+          mapping_global_id = next_free_global_id
+          add_mapping(mapping_global_id,theory_a.theory_instance_id,variable_a.theory_variable_id)
+          add_mapping(mapping_global_id,theory_b.theory_instance_id,variable_b.theory_variable_id)          
+        else
+        
+          # If both the global ids are defined then they should be the same value.
+          if([global_var_a,global_var_b].all? {|x| !x.nil? })
+            if global_var_a != global_var_b 
+              raise ChainMappingError.new(
+                'Both global ids have already been defiend but are not equal '+global_var_a.to_s+' and '+global_var_b.to_s
+              )
+            end
+            next
+          end
+        
+          # Get the id of the only defined global id
+          global_id = [global_var_a,global_var_b].detect {|x| !x.nil? } 
+          
+          # Add the mapping for both 
+          add_mapping(global_id,theory_a.theory_instance_id,variable_a.theory_variable_id)
+          add_mapping(global_id,theory_b.theory_instance_id,variable_b.theory_variable_id)
+        end
+      
+    end
+    
+     @history.unshift([theory_a.theory_instance_id,component_a_id,theory_b.theory_instance_id,component_b_id])
+     
+  end
+  
+end
+
+class ChainMappingError < StandardError
+  
+  def initialize(msg)
+    super(msg)
+  end
+  
+end

data/lib/CodeHandler.rb

@@ -0,0 +1,517 @@
+# TODO  Look into matrix
+require "matrix"
+require "tsort"
+
+# A code handler continualy considers how to extend the complexity 
+# of a method in a custom class given the intial starting methods
+# already availble within the class.  
+#
+# It also can refactor the code into separate methods thereby 
+# reusing the same functionality.
+# 
+# Essentially it just tries to create as many uniquely new variables as it
+# can.  Note they are consider unique if the process to create them is 
+# new, NOT whether or not there value is new.
+#
+# TODO  Look up dynamic refactoring
+#
+class CodeHandler
+  
+  attr_reader :runtime_methods
+  attr_writer :default_structures
+  
+  @@CODE_HANDLER_ID = 0
+  
+  def initialize(runtime_methods=[],structures=nil)
+    @runtime_methods = runtime_methods
+    @entrance_method = create_entrance_method
+    @code_handler_id = @@CODE_HANDLER_ID
+    @@CODE_HANDLER_ID += 1
+    
+    # These are the default statement structures if non-are supplied
+    @default_structures = [
+      DeclareVariableAsVariableStructure.new,
+      StatementStructure2.new(StatementStructure2.declared_runtime_method),
+      StatementStructure2.new(StatementStructure2.declared_array),      
+      StatementStructure2.new(StatementStructure2.declared_string_addition),            
+      DeclareNewInstanceStructure.new(MethodUsageClass.new,RuntimeMethodClass.new)
+     ]
+     
+      # If structures are supplied the overwrite the default structures
+      @default_structures = structures unless structures.nil? 
+  end
+  
+  # Returns a string that prints out how the dynamic code for the
+  # code handler currently looks.
+  #
+  def write
+
+    dynamic_code = "class #{class_name}"+"\n"
+    
+    # Include each of the avaialble runtime methods
+    @runtime_methods.each do |x|
+      dynamic_code += x.write(ParametersContainer.new,1)
+    end
+    
+    # Now add the entrance method
+    dynamic_code += @entrance_method.write(ParametersContainer.new,1)
+    
+    dynamic_code += "end"
+    return dynamic_code
+  end
+  
+  # Returns an array of method instances containing various numbers of statements.
+  # 
+  # 1.  At this point we are creating a statement to go straight into a method or 
+  #     into a nested statement.  First we find all the available variables in the 
+  #     context.  For this to work the variables should be saved with a scope.  At
+  #     this point it isn't concerning it's self with the dependencies for the variable.
+  #     It does however have to take into consideration scope.  As such every nested
+  #     statement maintains an array of it's level e.g. [5,7] for a two level nested 
+  #     statement.  This would mean that varibles with a scope level of 5 or 7 would
+  #     be valid consideration.
+  #     
+  # 2.  Next using the variables available to it it constructs a number of different 
+  #     statements.  
+  #
+  # 3.  From this statement it needs to work backwards to construct the full method.
+  #     It does this by finding all the dependencies that have the same scope level.
+  #     After that has been done, if finds and adds all the dependcies on the other 
+  #     scope level.
+  # 
+  # 4.  With the method constructed the value for the new variable can be asscertained.
+  #     The asscertained value gets added to available array.  Also if a variable is 
+  #     overwritten within the nested statement then its value is included with a scope
+  #     value outside the nested statement.  Specifically a scope level the same as the
+  #     variable that was overridden.  The variable simple has a depencey on the nested
+  #     statement.  This allows it to rebuild the statements in the correct order.  It 
+  #     can then check the scopes and wrap the nested statement accordingly.
+  #
+  # @param  count                 The number of itterations to go through when generating new
+  #                               runtime method arrangements.
+  # @param  additional_available  Any additional values that should be made available when 
+  #                               generating statements.
+  #  
+  def itterate(count=1,additional_available=[])
+
+    # Create an array to contain the vessels currently available
+    initial_copied_method = @entrance_method.copy
+    initial_copied_method.clear              
+    vessels = [initial_copied_method]
+    
+    # Create the array to contain the available variables and the initial runtime method calls
+    available = []
+    available += additional_available
+    @runtime_methods.each {|x| available += x.callable_combinations}  
+    
+    # Set the scope id for all the method calls
+    available.each {|x| x.scope_id = initial_copied_method.scope_id}
+    
+    # Maintains all the statements and their dependencies
+    dependencies = StatementDependencies.new
+    
+    # Completed methods
+    results = []
+        
+    # Itterate over the number of times specified
+    count.times do |i|        
+
+      # Keep track of the newly created variables
+      newly_created_variable = []
+      
+      # Keeps track of newly created vessels
+      newly_created_vessels = []
+      
+      # For each vessel create appropriate statements
+      vessels.each do |vessel|
+        
+        # Find potential new statements available to the current vessel
+        new_statement_results = find_possible_new_statements(vessel,available,dependencies)
+
+        # Find the statement dependencies for each statement
+        new_statement_results.each do |y|      
+        
+          # Create the vessel for the new statement
+          new_vessel = vessel.copy                    
+
+          # Create a runtime method with the statement and all the dependencies 
+          copied_method = build_minimalist_method(@entrance_method,y,dependencies)
+
+          # Realise the generated method
+          begin
+            realised_method = copied_method.realise2(ParametersContainer.new,@runtime_methods)
+          rescue ImproperStatementUsageError => e
+            
+            # TODO  I have rejected statements "var = <#statement_variable>.declare_variable" if the statement
+            # variable doesn't represent a declaration statement.  I don't know if this is the right way to
+            # do things.  It might be better to return a NilVariable or prevent it from ever being created.
+            
+            # TODO  I should check this is logged
+            StandardLogger.instance.warning('Method rejeceted')       
+            StandardLogger.instance.warning(e)                   
+            next
+          end       
+          
+          results.push(realised_method)       
+          
+          # TODO  I should determine the nature of the statement and then 
+          #       determine the new variables available.
+          # - I should maybe save structures with statements.    
+          
+          raise StandardError.new('Statement type has not defined for this statement') if y.statement_type.nil?
+
+          # Determine the id of the statement that declares the value
+          #case(y.statement_type)
+          #  when StatementStructure::DECLARATION_STATEMENT
+          if((y.statement_type == StatementStructure::MODIFYING_STATEMENT)or(y.statement_type == StatementStructure::DECLARATION_STATEMENT))
+
+              #declared_variable_id = y.created_variable.variable_id                       
+              variable_uniq_id = y.created_variable.uniq_id                       
+
+              # Find the value of the variable within the realised method and set it's scope
+              #resulting_variable = realised_method.find_variable(declared_variable_id)   
+              resulting_variable = realised_method.find_variable(variable_uniq_id)     
+
+              if y.kind_of?(BlockStatement)
+                resulting_variable.scope_id = y.scope_id
+                resulting_variable.clear
+              else
+                resulting_variable.scope_id = vessel.scope_id
+              end
+              newly_created_variable.push(resulting_variable)          
+          
+              #new_vessel = realised_method.find_statement_that_declares_variable(declared_variable_id)
+              # TODO  Check this works with uniq_id          
+              new_vessel = realised_method.find_statement_that_created_variable(variable_uniq_id)
+              
+              # Find the statement from the typed method that declares the variable
+              # NOTE  I wonder if it would be quicker and safe to add the realised statement here
+              #declaring_statement = realised_method.find_statement_that_declares_variable(declared_variable_id)
+              # TODO  Check this works with uniq_id
+              declaring_statement = realised_method.find_statement_that_created_variable(variable_uniq_id)
+              dependencies.push(declaring_statement)          
+          
+              # If the new statement was a nested statement then add as vessel
+              if y.kind_of?(BlockStatement)
+                new_vessels_scope = [new_vessel.scope_id]
+                new_vessels_scope += vessel.scope
+                new_vessel.scope = new_vessels_scope
+                new_vessel.clear
+                newly_created_vessels.push(new_vessel)
+              end          
+          
+#          when StatementStructure::MODIFYING_STATEMENT:
+    
+#             # exit
+#              # Need to save modified statement;
+#              StandardLogger.instance.warning('I think I need to treat modifying statements as if they declare new variables')
+#              
+#              # TODO  I'm not certain this isn't going to add loads of statement
+#              StandardLogger.instance.info('Statement ID: '+y.statement_id.to_s)              
+#              StandardLogger.instance.info(': '+y.write)              
+#              
+#              # Adding the statement the newly modified statement
+#              dependencies.push(realised_method.select {|stment| stment.statement_id == y.statement_id}.first)
+#            elsif(StatementStructure::USAGE_STATEMENT)  
+            else
+              raise StandardError.new('Unknown statement_type "'+y.statement_type+'" "'+y.write+'"')
+          end
+          
+        end
+          
+      end
+      
+      # Add the new variables to available list
+      # TODO  newly_created_variable is an array - it should be newly_created_variables
+      available += newly_created_variable                         
+      
+      # Add the new vessel to the list
+      vessels += newly_created_vessels      
+         
+    end  
+    return results
+    
+  end
+  
+  def self.reset_global_id
+    #http://www.zenspider.com/Languages/Ruby/QuickRef.html
+    unless $".include?('test/unit.rb')
+      StandardLogger.log 'WARNING: Resetting variable id, this should only be done for tests'
+    end
+    @@CODE_HANDLER_ID = 0
+  end    
+  
+  def class_name
+    return "RuntimeCodeHandler"+@code_handler_id.to_s
+  end
+  
+protected
+  
+  # Returns an array of new statements after removing any statements
+  # that have previously been considered when generating code.
+  #
+  # TODO  This needs re-thought for seanarios when new containers become
+  #       available.
+  #
+  # @param  possible_statements       
+  # @param  considered_statements     
+  #
+  def new_statements(possible_statements,considered_statements)
+        
+    # TODO  I imagine there is a nicer way of doing this method using Procs or 
+    #       passing blocks.
+         
+    results = StatementGroup.new
+    possible_statements.each do |x|
+      
+      # Declare the statement that is being considered - for block statements
+      # e.g. test.each do |x| only the "test.each" bit is considered
+      if x.kind_of?(BlockStatement)
+        subject = x.opening_statement
+      end                
+      subject ||= x                 
+
+      catch(:already_exists) do
+        considered_statements.each do |y|
+          
+          if y.kind_of?(BlockStatement)
+            other = y.opening_statement
+          end
+          other ||= y
+
+          catch(:different_from_this_statement) do
+            
+            # Checks whether the statements are equivalent
+            if subject.equivalent?(other)
+              throw :already_exists
+            end
+            throw :different_from_this_statement 
+          end
+        end
+        results.push(x)
+      end
+    end
+    return results
+  end
+  
+  # Return the next set of available statements given the 
+  # elements avialable.
+  #
+  def next_statements(available=[])
+    
+    # Collect a number of runtime variables 
+    results = StatementGroup.new
+    statement_structures.each do |structure|
+      results += structure.statements(available)
+    end    
+    return results
+  end
+  
+  # Retuns a runtime method instance that is the starting 
+  # point when generating unique variable journeys.
+  #
+  def create_entrance_method
+    return RuntimeMethod.new(MethodUsage.new,NilVariable.new)      
+  end
+  
+  # Returns an array of potential statement structures
+  # e.g.
+  # 
+  # Structure.new(Unknown,Equal,FixnumVariable,Addition,FixnumVariable)
+  # 
+  # TODO  Write more tests for StatementStructure2
+  # TODO  I don't know if I want to declare the structures here.  It might be
+  #       nicer to keep them with the variables.  They need to be with the variables
+  #       since even if they were created by the same StatementStrucutre this is 
+  #       no guarantee that they will have the same the structure. e..g
+  #
+  #       var_a.push(var_b);
+  #
+  def statement_structures
+    return @default_structures
+  end    
+  
+  # Returns the current runtime class instance 
+  def to_runtime_class
+    runtime_class = RuntimeClass.new(class_name)
+    @runtime_methods.each do |x|
+      runtime_class.push x.copy
+    end    
+    runtime_class.push @entrance_method
+    return runtime_class
+  end
+  
+  # Returns an array of statements that need 
+  # DEPENDENCY - check ruby code
+  # TODO  Look up Matrix in ruby p694
+  def requisite_statements_for(entrance_method,statement,journeys)
+    statement.required_variable_ids.each do |x|
+      journeys[x].each do |y|
+        entrance_method.push(y)
+      end
+    end    
+  end 
+  
+  # Returns an array of statements based on the available variables and 
+  # previously created statements.
+  # 
+  def create_statements(available,dependencies,vessel)     
+    
+    # Now attempt to create statements with each of the elements      
+    statements = next_statements(available)
+
+    # Remove out of scope dependencies
+    # If a statement is used in a new scope it should be considered a new statement
+    # NOTE For now I wont allow this
+
+    # Remove statements that may have been considered at previous itteration
+    statements = new_statements(statements,dependencies)    
+    
+    # Remove any statements that simple declare an existing variable var_a = var_b
+    # TODO  With better structures this shouldn't be necessary
+    statements = statements.remove_simple          
+
+    return statements
+  end
+  
+  # Returns an updated array of variables thats scope is with 
+  # the tolerance specified.
+  # 
+  # @param  available     A array of available variables
+  # @param  scope         An array indicating the scope to allow e.g. 
+  #                       [5,7].
+  #
+  def filter_within_scope(available,scope)
+    results = available.find_all {|x| scope.any?{|y| x.scope_id==y} }
+    return results 
+  end
+  
+  # Returns an array of statements in the order of their depenence.  
+  #
+  # @param  dependencies    A statement dependencies instance containing the 
+  #                         depenency structure.    
+  # @param  statement       The most recently added statement that's depenencies
+  #                         need found for.
+  # 
+  def find_prerequisite_statements(dependencies,statement)
+
+    # TODO  Call this method within dependencies
+    # Find the dependcies for the statement - the last one is the current statement
+    required_ids = dependencies.tsort_for_statement(statement)
+    required_ids.pop
+    
+    # Add the dependent statements            
+    results = []
+    required_ids.each do |y|
+      dependencies.each do |z|
+        results.push(z.copy) if z.statement_id == y 
+      end
+    end    
+    return results
+    
+  end
+  
+  # Strips out all the variables that are used as part of the 
+  # the nested statements.  This is to avoid editing variables 
+  # that are being itterated over.  For example
+  # 
+  # var_a = ['test']   
+  # var_a.each do |x|
+  #   var_a.push('test')
+  # end
+  #
+  # @param  vars          An array of in-scope variables (relative to the supplied vessel)
+  # @param  vessel        The nested statement or method thats structure is being considered
+  # @param  dependencies  The dependencey structure of all the statements.
+  # 
+  def strip_dependent_variables(vars,vessel,dependencies)
+    # Go through each nested statement in scope and remove any variables used in the statemnet
+    # this is to prevent variables being itterated over being used in the nested statement.
+    nested_statements = dependencies.find_all {|x| x.kind_of?(BlockStatement)}
+    vessel.scope.each do |used_scope|
+      nested_statement = nested_statements.detect {|x| x.scope_id == used_scope}
+      next if nested_statement.nil?
+      
+      # Find the id of the variable used in the nested statement and remove it as a in_scope_variables
+      # TODO  This presumes allot about the position of the variable in the statement
+      vars.delete_if {|x| x.kind_of?(Variable) && x.variable_id == nested_statement.opening_statement.first.variable.variable_id }
+    end
+    return vars
+  end
+  
+  # Returns an array of possible new statements given the currently 
+  # available variables, scope limitations and statement dependencies. 
+  #
+  # @param  vessel        A vessel is something that contains statements.  This 
+  #                       is either a nested statement or a runtime method.
+  # @param  available     Is an array of all the variables and method calls.  Note
+  #                       this has not been tailored to suit the vessel so some
+  #                       of the variables shouldn't be available.
+  # @param  dependencies  A statement dependencies instance that maintains what statements
+  #                       are dependent on what.
+  #
+  def find_possible_new_statements(vessel,available,dependencies)
+
+    # Filter the array of available variables to only include those within scope. 
+    in_scope_variables = filter_within_scope(available,vessel.scope)
+      
+    # Strip out parent itterating variables 
+    in_scope_variables = strip_dependent_variables(in_scope_variables,vessel,dependencies)
+
+    # Create statements with the available variables  
+    new_statement_results = create_statements(in_scope_variables,dependencies,vessel)    
+
+    # All new statements should have the statement level of the vessel scope_id
+    new_statement_results.each {|x| x.statement_level = vessel.scope_id}        
+    
+    return new_statement_results
+    
+  end
+  
+  # Returns an updated method that includes a specified statement and 
+  # all of its dependencies in the correct order and depth.
+  #
+  # @param  initial_method
+  #
+  def build_minimalist_method(initial_method,statement,dependencies)
+
+    # Find all the pre-requisite statements for the leading statement
+    prerequisite_statements = find_prerequisite_statements(dependencies,statement)                  
+
+    # Create an empty initial method to contain each arrangement
+    constructing_method = initial_method.copy
+    constructing_method.clear          
+
+    # Add all the statement in their scope order
+    prerequisite_statements.copy.each do |remaining_statement|
+      unless remaining_statement.statement_level == constructing_method.scope_id
+        
+        # Find the pre-requiste statement the statement should reside in
+        actual_statement = prerequisite_statements.delete_if {|z| z.statement_id == remaining_statement.statement_id}
+        
+        prerequisite_statements.each do |h|
+          if h.kind_of?(StatementGroup)
+            if h.scope_id == actual_statement.statement_level
+              h.push(actual_statement)
+              break
+            end
+          end
+        end
+        exit
+      end
+    end
+    
+    # Add each pre-requisite statement to the copied method
+    prerequisite_statements.each do |f|
+      constructing_method.push(f)
+    end
+    
+    # Find the statement with the correct statement level and add the new statement
+    container_statement = constructing_method.find_container_at_level(statement.statement_level)
+    container_statement.push(statement)
+    
+    return constructing_method
+        
+  end
+     
+end