cauldron 0.1.3 → 0.1.5

data/lib/core/statement/StatementGroup.rb

@@ -1,157 +0,0 @@
-class StatementGroup < Array
-  attr_reader :scope, :scope_id, :statement_level
-  attr_writer :scope, :scope_id, :statement_level
-  
-  # The scope id is used to determine what variables are available with the nested statement
-  @@scope_id = 0    
-  
-  alias :array_push :push    
-  
-  def initialize(*statements)
-    super()
-    statements.each {|x| self.push(x)}
-    
-    # Update the scope id for the nested statement
-    @scope_id = @@scope_id
-    @@scope_id += 1
-    
-    @scope = [@scope_id]
-    
-  end
-  
-  def cauldron_method_calls
-    return ['.statement_id']
-  end    
-  
-  def write(tab=0)
-    line = ''
-    self.each {|x| line += x.write(tab)+"\n" }
-    return line
-  end    
-  
-  def describe(tab=0)
-    line = ''
-    #self.each {|x| line += x.describe(tab)+"\n" }
-    self.each do |x| 
-      line += x.describe(tab)+"\n"
-    end
-    return line
-  end    
-  
-  # Removes any statements that simple re-declare an existing statement
-  # e.g var_a = var_b.
-  #
-  def remove_simple
-    results = StatementGroup.new
-    self.each do |x|
-      results.push x unless x.is_simple?
-    end
-    return results
-  end
-  
-  def push(*entries)
-    self.entries.each do |x|
-      x.scope = [@scope_id]
-    end
-    #super.array_push(*entries)
-    entries.each do |y|
-      
-      # TODO  Oddly super.array_push seems to add it twice - might investigate
-      #super.array_push(y)
-      array_push(y)
-    end
-  end
-  
-  # TODO  This method name doesn't suit what it returns
-  def statement_id
-    return @scope_id
-  end
-  
-  # Returns a statement container (either a runtime method or a nested statement)
-  # thats scope is the statement level specified.  This means that any statements
-  # with the statement level specified should reside directly in the statement
-  # container.
-  #
-  # @param  statement_level   The statement level the statement group should 
-  #                           contain statements at.
-  #
-  def find_container_at_level(statement_level)
-    return self if scope_id == statement_level
-    self.each do |x|
-      if x.kind_of?(StatementGroup)
-        begin
-          return x.find_container_at_level(statement_level)
-        rescue FailedToFindStatementContainerError => e
-          next
-        end
-        #result = x.find_container_at_level(statement_level)
-        #return result unless result.nil?
-      end
-    end
-    raise FailedToFindStatementContainerError.new('Failed to find containing statement with id '+statement_level.to_s)
-    #return nil
-    #raise StandardEror.new('There is no container at level '+)
-  end
-  
-  # Returns the statement thats id matches that supplied.
-  #
-  # @param  id    The id of the statement should exist in the runtime method
-  #
-  def find_statement(id)
-    self.each do |x|    
-      begin 
-        return x.find_statement(id)
-      rescue FailedToFindStatementError => e
-        next
-      end
-    end
-    raise FailedToFindStatementError.new('Couldn\'t find statement with id '+id.to_s)
-  end  
-  
-  # Returns an array of all the runtime method instances that are
-  # required for this statement group.  This is essentially the 
-  # runtime methods referenced in DefCalls.
-  #
-  def find_all_required_runtime_methods
-    results = []
-    self.each do |x|
-      results += x.find_all_required_runtime_methods
-    end
-    return results
-  end
-  
-  def copy 
-    result = self.class.new(*self.collect {|x| x.copy })
-    result.scope_id = scope_id
-    result.scope = scope
-    result.statement_level = statement_level
-    return result
-  end
-  
-  # Identify any of the contained statements that override an 
-  # existing variable. 
-  # 
-  # @param  already_declared      An array of previously declared variable ids in the 
-  #                               following format. [{:variable_id=>43},{:variable_id=>12}, ..]
-  #
-  def identify_overriding_statements(already_declared=[])
-    self.each do |x|
-      x.identify_overriding_statements(already_declared)
-    end
-  end  
-  
-  # Returns an array of overriding statements that reside inside
-  # this statement group.  A overriding statement is a statement that 
-  # re-declares or modifies a previously declared variable.
-  #
-  # @param  overriding_statements   An array of statements that have been overriden
-  #                                 within the statement group.
-  #
-  def find_overriding_statements(overriding_statements=[])
-    self.each do |x|
-      x.find_overriding_statements(overriding_statements)
-    end
-    return overriding_statements
-  end  
-  
-end

data/lib/core/statement/StatementStructure2.rb

@@ -1,224 +0,0 @@
-# Move this class to the structure folder
-# 
-# TODO  This is more a StatementStructureFactory
-class StatementStructure2 < Array
-  
-#  attr_reader :declared_fixnum
-#  
-#  @@DECLARED_FIXNUM = 'declared_fixnum'
-#  DECLARE_STRING = 'declared_string'
-#  DECLARE_STRING_ADDITION = 'declared_string_addition'
-  TIMES_ON_FIXNUM = 'times_on_fixnum'
-  
-  # TODO  I don't think I really need to pass the parameters anymore
-  def initialize(name)
-    # TODO  What are the two parameters an array expects
-    super()
-    
-    @structure_name = name
-
-    # Add the parameters to the array 
-    structure().each do |code|
-      self.push(code)
-    end    
-  end
-  
-  # var = 'test'+'ing'
-  def StatementStructure2.declared_string_addition
-    return 'declared_string_addition'
-  end
-  
-  def StatementStructure2.times_on_fixnum
-    return 'times_on_fixnum'
-  end
-  
-  def StatementStructure2.declared_array
-    return 'declared_array'
-  end
-  
-  def StatementStructure2.declared_runtime_method
-    return 'declared_runtime_method'
-  end
-  
-  # var = 5+8
-  def StatementStructure2.declared_fixnum_addition
-    return 'declared_fixnum_addition'
-  end
-  
-  def StatementStructure2.declared_statement
-    return 'declared_statement'
-  end
-  
-  def structure
-    case @structure_name
-#      when StatementStructure2.declared_fixnum
-#        return [Unknown,Equal,FixnumVariable]
-#      when StatementStructure2.declared_string
-#        return [Unknown,Equal,StringVariable]
-      when StatementStructure2.declared_array
-        return [Unknown,Equal,ArrayVariable]
-      when StatementStructure2.declared_runtime_method
-        return DeclareRuntimeMethodStructure.new()
-      when StatementStructure2.declared_string_addition
-        return [Unknown,Equal,StringVariable,Addition,StringVariable]
-      when StatementStructure2.declared_fixnum_addition
-        return FixnumAdditionStructure.new()
-      when StatementStructure2.declared_statement
-        return DeclareStatementStructure.new()
-    else
-      raise StandardError.new('Unknown statement structure "'+@structure_name+'"')
-    end
-  end
-  
-  # Returns an array of possible statements that can be
-  # created to follow the structure of the statement.
-  #
-  # Any method calls are considered as their returned value. So
-  # a method that returns a string is just considered as a 
-  # RuntimeVariable with a string class requirement.
-  #  
-  def statements(available=[])
-    
-    # Retrieve the statements for 
-    if(@structure_name==StatementStructure2.times_on_fixnum)
-      return fixnum_times_statements(available)
-    end
-    
-    # Create an array of statements that gets extended
-    partial_statements = [Statement.new]
-    
-    # Go through each element of the statement structure
-    self.each do |statement_element|
-      
-      # Creates an array of updated statements
-      updated_statements = []
-      
-      # If it is an unknown variable just add it 
-      if(statement_element == Unknown)
-          partial_statements = add_unknown_variable(partial_statements)
-          next
-      end
-      
-      # Just include it if it's a = sign
-      if(statement_element == Equal)or(statement_element == Addition)
-      
-          # Go through each element in the partial statements and add a copy of the new element
-          partial_statements.each do |partial|              
-            copied_statement = partial.copy
-            copied_statement.push(statement_element.new)
-            updated_statements.push copied_statement
-          end
-          partial_statements = updated_statements          
-          next
-      end      
-      
-      # Go through each of the available elements and see if they meet the statement elements
-      available.each do |avail|
-        
-        # If any of the values match - include them in the statement
-        if avail.kind_of?(statement_element)
-          
-          # Go through each element in the partial statements and add a copy of the new element
-          partial_statements.each do |partial|              
-            copied_statement = partial.copy
-            copied_statement.push(avail.copy)
-            updated_statements.push copied_statement
-          end
-              
-        end
-        
-        # Now see what instance calls are available to the passed avail
-        if avail.kind_of?(Variable)
-          
-          # Retrieve any instance calls available for that variable
-          # TODO  Availabe should not include the variable with the same id
-          instance_calls = avail.instance_calls(available)
-          instance_calls.each do |x|
-
-            if x.response.class == statement_element
-                
-              partial_statements.each do |partial|              
-                copied_statement = partial.copy
-                copied_statement.push(x.copy)
-                updated_statements.push copied_statement
-              end                            
-                
-            end
-          end
-              
-        end
-        
-        # If it is a definition call then check against the response value
-        if avail.kind_of?(DefCall)
-          if avail.response.class == statement_element
-            partial_statements.each do |y|
-              copied_statement = y.copy
-              copied_statement.push(avail.copy)
-              updated_statements.push copied_statement
-            end
-          end
-        end
-        
-      end
-      
-      partial_statements = updated_statements
-      
-    end
-    
-#    # Save the structure used to create the statement - this structure type will 
-#    # become deprecated soom.
-#    partial_statements.each do |x|
-#      x.structure = self.class
-#    end
-
-    return partial_statements     
-     
-  end
- 
-  # Returns a general description of the statement to 
-  # indicate whether it declares a new variable or 
-  # modifies an existing variable or nothing.
-  #
-  def self.statement_type
-    #raise StandardError.new('This method should be overridden "'+self.to_s+'"')
-    StandardLogger.instance.warning('This method should be used')
-    #return StatementStructure.DECLARATION_STATEMENT
-    return 'declaration_statement'
-  end 
-
-protected 
-  
-  # TODO Write tests
-  # Adds a unknown variable to each statement in the supplied 
-  # array and returns the result.
-  #
-  def add_unknown_variable(current_statements)
-    results = []
-    current_statements.each do |x|              
-      copied = x.copy
-      copied.push(Unknown.new)
-      results.push copied
-    end    
-    return results
-  end
-  
-  # Get the possible .times statements from the available
-  # fixnum variables 
-  #
-  def fixnum_times_statements(available=[])
-    
-    # If there aren't any fixnum variables there is nothing to return
-    return [] unless available.any? {|x| x.kind_of?(FixnumVariable)}
-
-    # Use each of the fixnum variables
-    results = []
-    available.find_all {|x| x.kind_of?(FixnumVariable) }.each do |y|  
-      new_statement = BlockStatement.new(Statement.new(InstanceCallContainer.new(y.copy,Times.new)),BlockContainer.new(BlockVariable.new))
-      new_statement.structure = self.class
-      results.push(new_statement)
-    end
-
-    return results
-  end
-  
-end

data/lib/core/statement/TheoryStatement.rb

@@ -1,68 +0,0 @@
-# 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
-    self
-  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  
-  
-  # => 
-  # => map [<TheoryVariable>=><TheoryVariable>]
-  def replace_variables_alt!(map)
-    self.each do |x|
-      x.replace_variables_alt!(map)
-    end
-  end
-  
-  # TODO  Maybe use a opject to handle the output of the statement.
-  def describe(tab=0)
-    line = ''
-    tab.times {line += "  " }
-    self.each do |code|
-      line += code.describe
-      break if code.object_id == self.last.object_id
-    end
-    return line
-  end  
-  
-end