cauldron 0.1.3 → 0.1.5

data/lib/core/runtime_class/StringClass.rb

@@ -1,23 +0,0 @@
-class StringClass < ClassName
-  
-	def initialize
-    super 
-	end
-
-  def write(context=nil)
-    return 'String'
-  end  
-  
-  def copy
-    return StringClass.new
-  end
-
-  def value
-    return String
-  end
-
-  def declaration_statement
-    return ClassMethodCallContainer.new(StringClass.new,New.new)
-  end
-  
-end

data/lib/core/runtime_class/StringLengthClass.rb

@@ -1,19 +0,0 @@
-class StringLengthClass
-  
-  def initialize
-    super
-  end
-  
-  def write
-    return 'StringLength'    
-  end
-  
-  def describe
-    return 'StringLength'    
-  end  
-  
-  def copy
-    return StringLengthClass.new
-  end  
-  
-end

data/lib/core/runtime_class/StringVariableClass.rb

@@ -1,19 +0,0 @@
-class StringVariableClass < ClassName
-  
-  def initialize
-    super
-  end
-  
-  def write(context=nil)
-    return 'StringVariable'
-  end  
-  
-  def copy
-    return StringVariableClass.new
-  end
-  
-  def value
-    return StringVariable
-  end      
-  
-end

data/lib/core/runtime_class/ThisClass.rb

@@ -1,15 +0,0 @@
-class ThisClass < ClassName
-  
-  def initialize
-    super
-  end
-  
-  def write
-    return 'This'
-  end
-  
-  def copy
-    return ThisClass.new
-  end  
-  
-end

data/lib/core/runtime_class/UnknownClass.rb

@@ -1,23 +0,0 @@
-class UnknownClass < ClassName
-  
-  def initialize
-    super 
-  end
-
-  def write(context=nil)
-    return 'Unknown'
-  end  
-  
-  def copy
-    return UnknownClass.new
-  end
-
-  def value
-    return Unknown
-  end
-
-  def declaration_statement
-    return ClassMethodCallContainer.new(Unknown.new,New.new)
-  end
-  
-end

data/lib/core/runtime_class/class_names.rb

@@ -1,95 +0,0 @@
-class EquivalentClass < ClassName
-  
-  def initialize
-    super
-  end
-  
-  def write(context=nil)
-    return 'Equivalent'
-  end  
-  
-end
-
-class OpenStatementClass < ClassName
-  
-  def initialize
-    super
-  end
-  
-  def write(context=nil)
-    return 'OpenStatement'
-  end  
-  
-end
-
-class BlockStatementClass < ClassName
-  
-  def initialize
-    super
-  end
-  
-  def write(tab=0)
-    return 'BlockStatement'
-  end  
-  
-end
-
-class ContainerClass < ClassName
-  
-  def initialize
-    super
-  end
-  
-  def write(tab=0)
-    return 'Container'
-  end  
-  
-end
-
-class SubtractClass < ClassName
-  
-  def initialize
-    super
-  end
-  
-  def write(tab=0)
-    return 'Subtract'
-  end  
-  
-end
-
-class TimesClass < ClassName
-  
-  def initialize
-    super
-  end
-  
-  def write(tab=0)
-    return 'Times'
-  end  
-  
-end
-
-class ChopClass < ClassName
-  
-  def initialize
-    super
-  end
-  
-  def write(tab=0)
-    return 'Chop'
-  end  
-  
-end
-
-class IfClass < ClassName
-  
-  def initialize
-    super
-  end
-  
-  def write(tab=0)
-    return 'If'
-  end  
-  
-end

data/lib/core/runtime_class/runtime_class.rb

@@ -1,123 +0,0 @@
-class TheoryStatementClass < ClassName
-  
-  def initialize
-    super
-  end
-  
-  def write(context=nil)
-    return 'TheoryStatement'
-  end  
-  
-  def copy
-    return TheoryStatementClass.new
-  end
-  
-  def value
-    return TheoryStatement
-  end
-  
-  # TODO  I'm not sure if this is needed
-  def declaration_statement
-    return ClassMethodCallContainer.new(TheoryStatementClass.new,New.new)
-  end  
-  
-  def class_method_calls(available=[])
-  end  
-  
-end
-
-class ParserClass < ClassName
-  
-  def initialize
-    super
-  end
-  
-  def write(context=nil)
-    return 'Parser'
-  end  
-  
-  def copy
-    return ParserClass.new
-  end
-  
-  def value
-    return parser
-  end
-  
-  # TODO  I'm not sure if this is needed
-  def declaration_statement
-    return ClassMethodCallContainer.new(ParserClass.new,New.new)
-  end  
-  
-  def class_method_calls(available=[])
-  end  
-  
-end
-
-class AdditionClass < ClassName
-  
-  def initialize
-    super
-  end
-  
-  def write(context=nil)
-    return 'Addition'
-  end  
-  
-  def copy
-    return AdditionClass.new
-  end
-  
-  def value
-    return Addition.class
-  end
-  
-  def declaration_statement
-    return ClassMethodCallContainer.new(AdditionClass.new,New.new)
-  end  
-  
-  def class_method_calls(available=[])
-  end  
-  
-end
-
-class CTestCaseClass < ClassName
-  
-  def initialize
-    super
-  end
-  
-  def write(context=nil)
-    return 'CTestCase'
-  end  
-  
-  def value
-    return CTestCase.class
-  end
-  
-  def declaration_statement
-    return ClassMethodCallContainer.new(CTestCaseClass.new,New.new)
-  end    
-  
-end
-
-class FixnumClass < ClassName
-  
-  def initialize
-    super
-  end
-  
-  def write(context=nil)
-    return 'Fixnum'
-  end  
-  
-  def value
-    return CTestCase.class
-  end
-  
-  def declaration_statement
-    return ClassMethodCallContainer.new(FixnumClass.new,New.new)
-  end    
-  
-end
-

data/lib/core/runtime_method/ActsAsRuntimeMethod.rb

@@ -1,293 +0,0 @@
-
-module ActsAsRuntimeMethod
-  include WriteParameters
-  
-  # Returns a variable instance with the id specified.  This essential just finds the varialbe
-  # at the last line of the method.
-  # 
-  # @param  id  The uniq id of the variable that is being looked for - this should be the unique
-  #             variable id.
-  #
-  def find_variable(uniq_id)
-    
-    # TODO  I don't know if progressively building up the method is necessary now
-    
-    # TODO  This method can probably be just used in StatementGroup and shared between nested statement 
-    #       and runtime method.
-    self.each do |x|
-
-      # TODO  SHould be unique variable id
-      if x.kind_of?(Statement)
-        if x.created_variable.uniq_id == uniq_id
-          temp = x.find_actual_variable(uniq_id)
-          return temp.copy
-        end
-        next
-      end
-      if x.kind_of?(BlockStatement)
-        begin 
-          # TODO  Write tests for this using uniq_id
-          return x.find_variable(uniq_id)
-          # TODO   Should have a custom FailedToFindVariable error or similar
-        rescue StandardError
-          next
-        end
-      end
-    end
-    raise FailedToFindVariableError.new('Unable to find variable '+uniq_id.to_s+' in method '+method_id.to_s)
-  end  
-  
-  # TODO  Write tests esp when I start to bring out varients of the same variable
-  #
-  def find_statement_that_declares_variable(variable_id)
-    self.each do |x|
-      if x.kind_of?(Statement)
-        if x.declared_variable_id == variable_id then return x.copy end
-        next
-      end
-      if x.kind_of?(BlockStatement)
-        begin 
-          return x.find_statement_that_declares_variable(variable_id)
-        rescue StandardError
-          next
-        end
-      end
-    end
-    raise StandardError.new('Failed to find statement that declared variable '+variable_id.to_s)
-  end  
-  
-  def find_statement_that_created_variable(uniq_id)
-    self.each do |x|
-      if x.kind_of?(Statement)
-        if x.created_variable.uniq_id == uniq_id then return x.copy end
-        next
-      end
-      if x.kind_of?(BlockStatement)
-        begin 
-          return x.find_statement_that_created_variable(variable_id)
-        rescue StandardError
-          next
-        end
-      end
-    end
-    raise StandardError.new('Failed to find statement that created variable with uniq id '+uniq_id.to_s)    
-  end
-  
-  def method_name
-    return 'method_'+@method_id.to_s
-  end  
-  
-  # Writes out the runtime method for general use.  If the parameters are supplied 
-  # then they are used, otherwise the methods usage parameters are used.
-  #
-  # @param  params      
-  # @param  tab 
-  # @param  additional_comments
-  #
-  def write(params=nil,tab=0,additional_comments=nil)
-    
-    # Check that the paramters have been defined for the method before it can be written
-    # raise_if_parameters_missing
-    raise StandardError.new('Incorrect use of write ') if params.kind_of?(Fixnum)
-      
-    line = "\n"    
-    tab.times {|x| line += "  " }
-    line += "#\n"
-
-    if params.nil?
-
-      @usage.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    
-      
-    else
-      
-      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
-      
-    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 += basic_write(tab)
-
-  end
-  
-  def basic_write(tab=0)
-    line = ''
-    line += 'def '+method_name 
-    
-    #line += write_params(@parameters)
-    line += write_params(@usage)
-    line += "\n"
-    
-    # Write out any statements within the method
-    self.each do |statement|
-      line += statement.write(tab+1)+"\n"
-    end
-    
-    # Close the method
-    tab.times {|x| line += "  " }
-    line += "end"+"\n"
-    
-    return line    
-  end  
-  
-  # [DEBUG] Does the same as the write method but includes the uniq_id
-  #
-  # TODO  This duplicates allot of the code in write 
-  #
-  def write_with_uniq_id(params=nil,tab=0,additional_comments=nil)
-    
-    # Check that the paramters have been defined for the method before it can be written
-    # raise_if_parameters_missing
-    raise StandardError.new('Incorrect use of write ') if params.kind_of?(Fixnum)
-      
-    line = "\n"    
-    tab.times {|x| line += "  " }
-    line += "#\n"
-
-    if params.nil?
-
-      @usage.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    
-      
-    else
-      
-      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
-      
-    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_name 
-    
-    #line += write_params(@parameters)
-    line += write_params(@usage)
-    line += "\n"
-    
-    # Write out any statements within the method
-    self.each do |statement|
-      line += statement.write_with_uniq_id(tab+1)+"\n"
-    end
-    line += "\n" if self.empty?
-    
-    # Close the method
-    tab.times {|x| line += "  " }
-    line += "end"+"\n"
-    
-    return line    
-    
-  end
-  
-  # Returns an array of variables currently available in the 
-  # method.  Essentially this is all the variables after the 
-  # last statement.  This is a little crude since it doesn't 
-  # take into account if statements or loops.
-  #
-  def available_variables(params=[])
-    
-    # raise StandardError.new('The parameters have not been set for this method') if @parameters.nil? 
-    collected_variables = []
-    collected_variables += params
-    self.each do |statement|
-      
-        # Nested statements don't provide any variables for the end of the method
-        next if statement.kind_of?(BlockStatement)
-        next if statement.kind_of?(OpenStatement)
-      
-        statement.each_variable do |var|
-          unless collected_variables.any? {|known_var| known_var.variable_id == var.variable_id}
-            collected_variables.push(var.copy)
-          end
-        end
-    end
-    return collected_variables
-    
-  end  
-  
-end