cauldron 0.1.3 → 0.1.5

data/lib/core/variable/VariableReference.rb

@@ -1,85 +0,0 @@
-# I'm not sure if this is the way to go, but I need some way
-# to handle the case where variables reference variables. 
-#
-# For example:
-#
-#  #
-#  #
-#  def method_8
-#    var_12 = Statement.new(Unknown.new,Equal.new,8.to_declaration) 
-#    var_570 = var_12.declared_variable 
-#  end
-#
-# In this case it is difficult to realise var_570 since it references an 
-# unrealised variable.  I should maybe have created an Unknown class, but
-# it is still an Unknown.
-# 
-class VariableReference
-  include Variable  
-  
-  attr_reader :variable_id
-  
-  # 
-  # @param  referenced_variable_id      
-  #
-  def initialize(var_id,referenced_variable_id)
-    @variable_id = var_id
-    @referenced_variable_id = referenced_variable_id
-    raise StandardError.new('I am getting rid of this')
-  end
-  
-  def copy
-    return VariableReference.new(@variable_id,@referenced_variable_id)
-  end
-  
-  # Returns the variable if the ids matched
-  #
-  # @param  id    The id of the variable that is being looked for
-  #
-  def find_actual_variable(id)
-    return self if @variable_id == id
-    throw :variable_not_found
-  end  
-  
-  #
-  # 
-  #
-  def write()
-    if (@instance_variable)
-      return '@var_'+variable_id.to_s    
-    end
-    return 'var_'+variable_id.to_s    
-  end   
-  
-  def to_literal_string
-    return 'var'  
-  end  
-  
-  def realised?
-    return false
-  end  
-  
-  # TODO  Write tests for this
-  # Returns an array of desctructive instance calls given the available
-  # variables.
-  # 
-  # @param  available     An array of other variables that can be used as
-  #                       parameters. 
-  #
-  def destructive_instance_calls(available=[])
-    
-    # Find the variable it references
-    available_variables = available.select {|x| x.kind_of?(Variable)}
-
-    not_found = lambda{raise StandardError.new('Unable to find variable with id '+@referenced_variable_id.to_s)}
-    referenced_variable = available_variables.detect(not_found) {|x| x.variable_id == @referenced_variable_id}
-      
-    # Duplicate the referenced variable and update it's variable id
-    duplicated_var = referenced_variable.copy
-    duplicated_var.variable_id = @variable_id
-    
-    return duplicated_var.destructive_instance_calls(available)
-    
-  end    
-  
-end

data/lib/error/FailedToFindStatementContainerError.rb

@@ -1,7 +0,0 @@
-class FailedToFindStatementContainerError < StandardError
-  
-  def initialize(msg='')
-    super(msg)
-  end
-    
-end

data/lib/error/FailedToFindStatementError.rb

@@ -1,7 +0,0 @@
-class FailedToFindStatementError < StandardError
-  
-  def initialize(msg)
-    super(msg)
-  end
-  
-end

data/lib/error/FailedToFindVariableError.rb

@@ -1,7 +0,0 @@
-class FailedToFindVariableError < StandardError
-  
-  def initialize(msg)
-    super(msg)
-  end
-  
-end

data/lib/error/FailedToLiteraliseError.rb

@@ -1,7 +0,0 @@
-class FailedToLiteraliseError < StandardError
-  
-  def initialize(msg)
-    super(msg)
-  end
-  
-end

data/lib/error/FailedVariableMatch.rb

@@ -1,7 +0,0 @@
-class FailedVariableMatch < StandardError
-  
-  def initialize(msg)
-    super(msg)
-  end
-  
-end

data/lib/error/ImproperStatementUsageError.rb

@@ -1,7 +0,0 @@
-class ImproperStatementUsageError < StandardError
-  
-  def initialize(msg)
-    super(msg)
-  end
-  
-end

data/lib/error/IncompatiableRequirementsError.rb

@@ -1,7 +0,0 @@
-class IncompatiableRequirementsError < StandardError
-  
-  def initialize(msg)
-    super(msg)
-  end
-  
-end

data/lib/error/InvalidStatementError.rb

@@ -1,7 +0,0 @@
-class InvalidStatementError < StandardError
-  
-  def initialize(msg)
-    super(msg)
-  end
-  
-end

data/lib/error/MethodSizeError.rb

@@ -1,7 +0,0 @@
-class MethodSizeError < StandardError
-  
-  def initialize(msg)
-    super(msg)
-  end
-  
-end

data/lib/error/RuntimeSyntaxError.rb

@@ -1,7 +0,0 @@
-class RuntimeSyntaxError < StandardError
-  
-  def initialize(msg='')
-    super(msg)
-  end
-  
-end

data/lib/error/UnexpectedStatementTypeError.rb

@@ -1,7 +0,0 @@
-class UnexpectedStatementTypeError < StandardError
-  
-  def initialize(msg)
-    super(msg)
-  end
-  
-end

data/lib/error/UnknownStatementType.rb

@@ -1,7 +0,0 @@
-class UnknownStatementType < StandardError
-  
-  def initialize(msg)
-    super(msg)
-  end
-  
-end

data/lib/error/UnliteralisableError.rb

@@ -1,7 +0,0 @@
-class UnliteralisableError < StandardError
-  
-  def initialize(msg)
-    super(msg)  
-  end
-  
-end

data/lib/implemented_chain.rb

@@ -1,35 +0,0 @@
-# This represents a chain that doesn't contain any theory variables.  All the variables
-# have been replaced with intrinsic/real values.
-#
-class ImplementedChain
-  
-  attr_reader :mapping
-  # 
-  #
-  # 
-  def initialize(nodes,mapping)
-    @nodes, @mapping = nodes, mapping
-  end
-  
-  def each(&block)
-    @nodes.each(&block)
-  end  
-  
-  # TODO  Note sure how I feel about this direct access
-  def [](index)
-    return @nodes[index]
-  end  
-  
-  def length
-    return @nodes.length
-  end  
-  
-  def describe(tab=0)
-    return @nodes.inject('') {|total,x| total += x.describe}
-  end
-  
-  def write(tab=0)
-    return @nodes.inject('') {|total,x| total += x.write}
-  end  
-  
-end

data/lib/intrinsic/IntrinsicLastRuntimeMethod.rb

@@ -1,20 +0,0 @@
-# This represents any reference to main runtime method instance 
-# within theories.
-#
-class IntrinsicLastRuntimeMethod  < IntrinsicObject
-  include Token
- 
-  def initialize(intrinsic_object_id=nil)
-    @intrinsic_object_id = intrinsic_object_id
-    super()
-  end
-  
-  def write
-    return 'last_runtime_method'
-  end
-  
-  def describe
-    return '<last_runtime_method>'
-  end
-  
-end

data/lib/intrinsic/IntrinsicLiteral.rb

@@ -1,26 +0,0 @@
-class IntrinsicLiteral < IntrinsicObject
-  include Token
-  
-  def initialize(value,intrinsic_object_id=nil)
-    @intrinsic_object_id = intrinsic_object_id
-    super()
-    @value = value
-  end
-  
-  def write
-    @value.write
-  end  
-  
-  def describe
-    @value.describe
-  end  
-  
-  def copy
-    return IntrinsicLiteral.new(@value,@intrinsic_object_id)
-  end    
-  
-  def literal
-    return @value
-  end
-  
-end

data/lib/intrinsic/IntrinsicObject.rb

@@ -1,22 +0,0 @@
-class IntrinsicObject
-  
-  attr_reader :intrinsic_object_id
-  
-  def initialize
-    generate_intrinsic_object_id
-  end
-  
-  @@intrinsic_object_id = 0
-  
-  def generate_intrinsic_object_id
-    if @intrinsic_object_id.nil?
-      @intrinsic_object_id = @@intrinsic_object_id
-      @@intrinsic_object_id += 1
-    end
-  end    
-  
-  def copy
-    return self.class.new(@intrinsic_object_id)
-  end    
-  
-end

data/lib/intrinsic/IntrinsicRuntimeMethod.rb

@@ -1,27 +0,0 @@
-# This represents any reference to main runtime method instance 
-# within theories.
-#
-class IntrinsicRuntimeMethod  < IntrinsicObject
-  include Token
- 
-  def initialize(intrinsic_object_id=nil)
-    @intrinsic_object_id = intrinsic_object_id 
-    super()
-  end
-  
-  def write
-    return 'runtime_method'
-  end
-  
-  def describe
-    return '<runtime_method>'
-  end
-  
-  def ==(val)
-    if val.kind_of?(IntrinsicRuntimeMethod)
-      return true if self.intrinsic_object_id == val.intrinsic_object_id
-    end
-    super(val)
-  end
-  
-end

data/lib/intrinsic/IntrinsicTestCases.rb

@@ -1,17 +0,0 @@
-class IntrinsicTestCases < IntrinsicObject
-  include Token
-  
-  def initialize(intrinsic_object_id=nil)
-    @intrinsic_object_id = intrinsic_object_id 
-    super()
-  end
-  
-  def write
-    return 'test_cases'
-  end  
-  
-  def describe
-    return '<test_cases>'
-  end  
-  
-end

data/lib/logger/StandardLogger.rb

@@ -1,62 +0,0 @@
-class StandardLogger
-  include Singleton
-  
-  def initialize
-    @log = Logger.new(STDOUT)
-    @log.level = Logger::INFO
-    @log.datetime_format = "%H:%M:%S"
-    
-    # TODO  Include option to print to file as well see Logger class to
-    #       allow this.
-    # or
-    # http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc/index.html
-  end
-  
-  def info(msg)
-    @log.info(msg)
-  end
-  
-  def code(msg)
-    @log.info("\n"+msg)
-  end
-  
-  def error(msg)
-    @log.error("\033[0;31m\ "+msg+"\033[00m\ ")
-  end
-  
-  def warning(msg)
-    error(msg)
-  end
-  
-  def deprecated(msg)
-    error(msg)
-  end
-  
-  # TODO  Do this properly with method missing etc
-  def method_missing(sym, *args, &block)
-    @log.send sym, *args, &block
-  end  
-  
-  # Prints out the code that lead to the current error being raised.
-  #
-  # @param  trace   An array of lines each of which should be printed out
-  #
-  def backtrace(trace)
-    trace.each do |t|
-      @log.error("\033[0;33m\ "+t+"\033[00m\ ")
-    end
-  end
-  
-#
-#red = "\0123" # character code
-#white = "\0223"
-#
-#
-## http://ubuntuforums.org/showthread.php?t=470626
-## http://kpumuk.info/ruby-on-rails/colorizing-console-ruby-script-output/
-## http://en.wikipedia.org/wiki/ANSI_escape_code#Codes
-##
-#print "#{red} ERROR: IT BROKE #{white}"
-#print "other stuff"
-  
-end

data/lib/required.rb

@@ -1,222 +0,0 @@
-$LOC = File.join(['']) if $LOC.nil?
-
-require 'rubygems'
-
-require 'tsort'
-require 'pp'
-require 'set'
-require 'ruby2ruby'
-require 'ruby_parser'
-require 'logger'
-require 'singleton'
-require 'yaml'
-require 'fileutils'
-
-require $LOC+File.join(['ruby_code','Object'])
-require $LOC+File.join(['ruby_code','String'])
-require $LOC+File.join(['ruby_code','Fixnum'])
-require $LOC+File.join(['ruby_code','Array'])
-require $LOC+File.join(['ruby_code','NilClass'])
-require $LOC+File.join(['ruby_code','Hash'])
-require $LOC+File.join(['ruby_code','Symbol'])
-
-require $LOC+File.join(['core','kernal','LocalVariablesCall'])
-require $LOC+File.join(['core','kernal','EvalCall'])
-
-require $LOC+File.join(['core','runtime_method','ParametersContainer'])
-require $LOC+File.join(['core','runtime_method','WriteParameters'])
-require $LOC+File.join(['core','runtime_method','ActsAsRuntimeMethod'])
-
-require $LOC+File.join(['core','declaration','Declaration'])
-require $LOC+File.join(['core','declaration','LiteralDeclaration'])
-require $LOC+File.join(['core','declaration','VariableDeclaration'])
-
-require $LOC+File.join(['core','variable','VariableIncluded'])
-
-require $LOC+File.join(['core','tracking','ActsAsTrackable'])
-require $LOC+File.join(['core','tracking','Step'])
-
-require $LOC+File.join(['core','TheoryGenerator'])
-require $LOC+File.join(['core','Token'])
-require $LOC+File.join(['core','CTestCase'])
-require $LOC+File.join(['core','BlockToken'])
-require $LOC+File.join(['core','ActsAsCode'])
-require $LOC+File.join(['core','PrintVariables'])
-require $LOC+File.join(['core','Container'])
-require $LOC+File.join(['core','statement','ActsAsStatement'])
-require $LOC+File.join(['core','statement','Statement'])
-require $LOC+File.join(['core','tracking','History'])
-require $LOC+File.join(['core','statement','StatementGroup'])
-require $LOC+File.join(['core','runtime_method','RuntimeMethod'])
-require $LOC+File.join(['core','runtime_method','RealisedRuntimeMethod'])
-require $LOC+File.join(['core','tracking','RuntimeTrackingMethod'])
-require $LOC+File.join(['core','syntax','Code'])
-require $LOC+File.join(['core','MethodUsage'])
-require $LOC+File.join(['core','call_container','CallContainer'])
-require $LOC+File.join(['core','InstanceCallContainer'])
-
-require $LOC+File.join(['core','assignment','Assignment'])
-require $LOC+File.join(['core','assignment','Equivalent'])
-require $LOC+File.join(['core','assignment','Equal'])
-require $LOC+File.join(['core','assignment','NotEqual'])
-
-require $LOC+File.join(['core','class_method_call','RuntimeClassMethodCall'])
-require $LOC+File.join(['core','class_method_call','New'])
-
-require $LOC+File.join(['core','instance_call','InstanceCall'])
-require $LOC+File.join(['core','instance_call','Times'])
-require $LOC+File.join(['core','instance_call','Push'])
-require $LOC+File.join(['core','instance_call','ArrayEach'])
-require $LOC+File.join(['core','instance_call','DeclaredVariable'])
-require $LOC+File.join(['core','instance_call','ArrayLength'])
-require $LOC+File.join(['core','instance_call','Chop'])
-require $LOC+File.join(['core','instance_call','Copy'])
-require $LOC+File.join(['core','instance_call','StringLength'])
-require $LOC+File.join(['core','instance_call','Params'])
-require $LOC+File.join(['core','instance_call','length_equal'])
-require $LOC+File.join(['core','instance_call','instance_calls'])
-
-require $LOC+File.join(['core','method_call','ClassCall'])
-require $LOC+File.join(['core','method_call','DefCall'])
-require $LOC+File.join(['core','method_call','AvailableVariablesCall'])
-require $LOC+File.join(['core','method_call','ToDeclarationCall'])
-require $LOC+File.join(['core','method_call','MethodNameCall'])
-require $LOC+File.join(['core','method_call','EvaluateClassCall'])
-
-require $LOC+File.join(['error','IncompatiableRequirementsError'])
-require $LOC+File.join(['error','FailedToFindStatementError'])
-require $LOC+File.join(['error','FailedToFindStatementContainerError'])
-require $LOC+File.join(['error','RuntimeSyntaxError'])
-require $LOC+File.join(['error','MethodSizeError'])
-require $LOC+File.join(['error','FailedToFindVariableError'])
-require $LOC+File.join(['error','UnknownStatementType'])
-require $LOC+File.join(['error','FailedVariableMatch'])
-require $LOC+File.join(['error','FailedToLiteraliseError'])
-require $LOC+File.join(['error','UnexpectedStatementTypeError'])
-require $LOC+File.join(['error','UnliteralisableError'])
-require $LOC+File.join(['error','InvalidStatementError'])
-require $LOC+File.join(['error','ImproperStatementUsageError'])
-
-require $LOC+File.join(['core','requirement','Requirement'])
-
-require $LOC+File.join(['core','statement','HackStatement'])
-require $LOC+File.join(['core','statement','DeclarationStatement'])
-require $LOC+File.join(['core','statement','OpenStatement'])
-require $LOC+File.join(['core','statement','ArrayAccess'])
-require $LOC+File.join(['core','statement','HashAccess'])
-require $LOC+File.join(['core','statement','TopologicalStatements'])
-require $LOC+File.join(['core','statement','TheoryStatement'])
-
-require $LOC+File.join(['MappingValues'])
-require $LOC+File.join(['Mapping'])
-
-require $LOC+File.join(['core','statement','BlockStatement'])
-require $LOC+File.join(['core','statement','SingleLineBlockStatement'])
-
-require $LOC+File.join(['core','literal','Literal'])
-require $LOC+File.join(['core','literal','Raw'])
-require $LOC+File.join(['core','literal','RuntimeMethodLiteral'])
-require $LOC+File.join(['core','literal','StatementLiteral'])
-
-require $LOC+File.join(['core','runtime_class','ClassName'])
-require $LOC+File.join(['core','runtime_class','ClassCallClass'])
-require $LOC+File.join(['core','runtime_class','ClassEvaluationClass'])
-require $LOC+File.join(['core','runtime_class','RequirementClass'])
-require $LOC+File.join(['core','runtime_class','InstanceCallClass'])
-require $LOC+File.join(['core','runtime_class','ThisClass'])
-require $LOC+File.join(['core','runtime_class','StringClass'])
-require $LOC+File.join(['core','runtime_class','FixnumClass'])
-require $LOC+File.join(['core','runtime_class','RuntimeMethodClass'])
-require $LOC+File.join(['core','runtime_class','MethodUsageClass'])
-require $LOC+File.join(['core','runtime_class','UnknownClass'])
-require $LOC+File.join(['core','runtime_class','StatementClass'])
-require $LOC+File.join(['core','runtime_class','ReturnClass'])
-require $LOC+File.join(['core','runtime_class','RuntimeClassClass'])
-require $LOC+File.join(['core','runtime_class','DefCallClass'])
-require $LOC+File.join(['core','runtime_class','MethodParameterClass'])
-require $LOC+File.join(['core','runtime_class','EqualClass'])
-require $LOC+File.join(['core','runtime_class','LiteralClass'])
-require $LOC+File.join(['core','runtime_class','RuntimeClass'])
-require $LOC+File.join(['core','runtime_class','ArrayClass'])
-require $LOC+File.join(['core','runtime_class','StringLengthClass'])
-require $LOC+File.join(['core','runtime_class','StringVariableClass'])
-require $LOC+File.join(['core','runtime_class','InstanceCallContainerClass'])
-require $LOC+File.join(['core','runtime_class','runtime_class'])
-require $LOC+File.join(['core','runtime_class','class_names'])
-
-require $LOC+File.join(['core','variable','Variable'])
-require $LOC+File.join(['core','variable','BaseVariable'])
-require $LOC+File.join(['core','variable','BlockVariable'])
-require $LOC+File.join(['core','variable','VariableContainer'])
-require $LOC+File.join(['core','variable','MethodUsageVariable'])
-require $LOC+File.join(['core','variable','TypeVariable'])
-require $LOC+File.join(['core','variable','RuntimeMethodParameter'])
-require $LOC+File.join(['core','variable','StatementVariable'])
-require $LOC+File.join(['core','variable','MethodParameter'])
-require $LOC+File.join(['core','variable','Unknown'])
-require $LOC+File.join(['core','variable','FixnumVariable'])
-require $LOC+File.join(['core','variable','StringVariable'])
-require $LOC+File.join(['core','variable','StepVariable'])
-require $LOC+File.join(['core','variable','ArrayVariable'])
-require $LOC+File.join(['core','variable','NilVariable'])
-require $LOC+File.join(['core','variable','VariableReference'])
-require $LOC+File.join(['core','variable','UnknownVariable'])
-
-require $LOC+File.join(['core','syntax','Return'])
-require $LOC+File.join(['core','syntax','syntax'])
-require $LOC+File.join(['core','syntax','Boolean'])
-require $LOC+File.join(['core','syntax','True'])
-require $LOC+File.join(['core','syntax','False'])
-require $LOC+File.join(['core','syntax','Subtract'])
-require $LOC+File.join(['core','syntax','Nil'])
-require $LOC+File.join(['core','syntax','Addition'])
-require $LOC+File.join(['core','syntax','Do'])
-require $LOC+File.join(['core','syntax','If'])
-require $LOC+File.join(['core','syntax','BlockContainer'])
-require $LOC+File.join(['core','syntax','This'])
-
-require $LOC+File.join(['theory','TheoryVariable'])
-require $LOC+File.join(['theory','TheoryComponent'])
-require $LOC+File.join(['theory','TheoryDependent'])
-require $LOC+File.join(['theory','TheoryAction'])
-require $LOC+File.join(['theory','TheoryResult'])
-require $LOC+File.join(['Theory'])
-require $LOC+File.join(['theory','TheoryConnector'])
-require $LOC+File.join(['theory','TheoryChainValidator'])
-require $LOC+File.join(['theory','TheoryImplementation'])
-require $LOC+File.join(['theory','ActionImplementation'])
-require $LOC+File.join(['theory','theory_collection'])
-
-require $LOC+File.join(['intrinsic','IntrinsicObject'])
-require $LOC+File.join(['intrinsic','IntrinsicLiteral'])
-require $LOC+File.join(['intrinsic','IntrinsicRuntimeMethod'])
-require $LOC+File.join(['intrinsic','IntrinsicTestCases'])
-require $LOC+File.join(['intrinsic','IntrinsicLastRuntimeMethod'])
-
-require $LOC+File.join(['logger','StandardLogger'])
-
-require $LOC+File.join(['util','StatementCheck'])
-require $LOC+File.join(['util','CodeEvaluation'])
-require $LOC+File.join(['util','MethodEvaluation'])
-require $LOC+File.join(['util','ClassEvaluation'])
-require $LOC+File.join(['util','DeclarationStatementEvaluation'])
-require $LOC+File.join(['util','System'])
-require $LOC+File.join(['util','MethodTester'])
-require $LOC+File.join(['util','MethodValidation'])
-require $LOC+File.join(['util','Parser'])
-require $LOC+File.join(['util','StringToTheory'])
-require $LOC+File.join(['util','MethodWriter'])
-
-require $LOC+File.join(['core','ClassMethodCallContainer'])
-
-require $LOC+File.join(['CodeHandler'])
-require $LOC+File.join('Chain')
-require $LOC+File.join('UnifiedChain')
-require $LOC+File.join('PartialChain')
-require $LOC+File.join('implemented_chain')
-require $LOC+File.join('ChainMapping')
-
-# TEST HELPERS
-require $LOC+File.join(['theories'])
-require $LOC+File.join(['cauldron','util','home'])
-require $LOC+File.join(['cauldron','pot'])