cauldron 0.1.0

data/lib/intrinsic/IntrinsicObject.rb

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,27 @@
+# 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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,62 @@
+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

@@ -0,0 +1,236 @@
+$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(['core','structure','StatementStructure'])
+require $LOC+File.join(['core','structure','FixnumAdditionStructure'])
+require $LOC+File.join(['core','statement','StatementStructure2'])
+require $LOC+File.join(['core','structure','InstanceCallStructure'])
+require $LOC+File.join(['core','structure','InstanceCallContainerStructure'])
+require $LOC+File.join(['core','structure','DeclareRuntimeMethodStructure'])
+require $LOC+File.join(['core','structure','DeclareNewInstanceStructure'])
+require $LOC+File.join(['core','structure','DeclareVariableAsLiteralStructure'])
+require $LOC+File.join(['core','structure','DeclareVariableAsVariableStructure'])
+require $LOC+File.join(['core','structure','ReturnStructure'])
+
+require $LOC+File.join(['ScopeDependencies'])
+require $LOC+File.join(['MappingValues'])
+require $LOC+File.join(['Mapping'])
+
+require $LOC+File.join(['core','statement','StatementDependencies'])
+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','IfStatementClass'])
+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','IfContainer'])
+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('implemented_chain')
+require $LOC+File.join('ChainMapping')
+
+# TEST HELPERS
+require $LOC+File.join(['theories'])
+
+require $LOC+File.join(['cauldron','pot'])

data/lib/ruby_code/Array.rb

@@ -0,0 +1,95 @@
+class Array
+  
+  def cauldron_method_calls
+    # TODO  Need to follow sexp more for ArrayAccess - I shouldn't need a class to contain the array and value
+    #result = self.length.times.collect {|x| '['+x.to_s+']'}
+    #result = self.length.times.collect {|x| ArrayAccess.new(self.copy,x)}
+    result = ['.length','.any?','[]']
+    return result
+  end
+  
+  def to_var(id=nil,unique_id=nil)
+    raise StandardError.new('No to_var method has been created for '+self.class.to_s) unless self.class.to_s == 'Array'
+    # TODO I'm not sure whether it's best to save the literal value or variable value
+    result = []
+    self.each {|x| result.push(x.copy)}    
+    replicate = ArrayVariable.new(*result) {{:variable_id => id,:uniq_id=>unique_id}}
+    return replicate
+  end  
+  
+  # Returns the array as a declaration string
+  # e.g.  ['lions','tigers','bears'] becomes "['lion','tigers','bears']"
+  #
+  def to_declaration
+    raise StandardError.new('No to_declaration method has been created for '+self.class.to_s) unless self.class.to_s == 'Array'
+    return LiteralDeclaration.new(self.clone)
+  end
+
+  def write
+    raise StandardError.new('No "write" method has been created for '+self.class.to_s) unless self.class.to_s == 'Array'
+    line = '['    
+    self.each do |x|
+      line += x.write
+      unless x.object_id == self.last.object_id then line += ', ' end
+    end
+    line += ']'
+    return line    
+  end
+
+  def copy
+    raise StandardError.new('No "copy" method has been created for '+self.class.to_s) unless self.class.to_s == 'Array'    
+    result = []
+    self.each {|x| result.push(x.copy) }
+    return result
+  end
+  
+  def to_literal
+    return Literal.new(self.copy.collect {|x| x.to_literal})  
+  end
+  
+  # This is a variation on the 'any?' except if the array contains an array
+  # it continue the search into that array.
+  # 
+  # @param  &block    The block that evaluates if something exists in the array
+  #
+  # TODO  This method could probably be cleaned up a bit
+  #
+  def contains?(&block)
+    self.each do |x|
+      if x.respond_to?(:contains?) 
+        if x.contains?(&block)
+          return true
+        end
+      end
+      return true if block.call(x)
+    end
+    return false
+  end
+  
+  # Returns all the elements that match the selection criteria just 
+  # like the select method.  However if it contains an array it
+  # will seach the array as well.
+  # 
+  # @param  results       An array of current results that match the requirement
+  #                       of the block.
+  # @param  block         .
+  #
+  def select_all(results=[],&block)
+    self.each do |x|
+      if block.call(x)
+        results.push(x)
+      end
+      if x.respond_to?(:select_all) 
+        x.select_all(results,&block)  
+      end
+    end
+    return results
+  end  
+  
+  def to_intrinsic
+    # TODO  SHould be all? not any?
+    return IntrinsicTestCases.new if self.any? {|x| x.kind_of?(CTestCase)}  
+    raise StandardError.new('Can not be converted to intrinsic instance '+self.class.to_s)
+  end
+  
+end