cauldron 0.1.0

data/lib/core/runtime_class/ArrayClass.rb

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

data/lib/core/runtime_class/ClassCallClass.rb

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

data/lib/core/runtime_class/ClassEvaluationClass.rb

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

data/lib/core/runtime_class/ClassName.rb

@@ -0,0 +1,18 @@
+class ClassName < Array
+
+	def initialize
+	end
+  
+  def describe
+    return write
+  end
+  
+  def to_literal_string
+    return self.write
+  end
+  
+  def copy
+    return self.class.new
+  end    
+  
+end

data/lib/core/runtime_class/DefCallClass.rb

@@ -0,0 +1,21 @@
+# TODO  Come up with a better solution that all these bloody classes!
+class DefCallClass < ClassName
+  
+  def initialize
+    super 
+  end
+
+  def write(context=nil)
+    return 'DefCall'
+  end
+  
+  # TODO  Decide whether this should be ReturnClass.new or Return.new see FixnumClass
+  def copy
+    return DefCallClass.new
+  end
+
+  def value
+    return DefCall
+  end
+  
+end

data/lib/core/runtime_class/EqualClass.rb

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

data/lib/core/runtime_class/FixnumClass.rb

@@ -0,0 +1,15 @@
+class FixnumClass < ClassName
+  
+	def initialize
+    super 
+	end
+
+  def write(context=nil)
+    return 'Fixnum'
+  end
+
+  def value
+    return Fixnum
+  end
+
+end

data/lib/core/runtime_class/IfStatementClass.rb

@@ -0,0 +1,12 @@
+# TODO  I Don't think this class exists
+class IfStatementClass < ClassName
+  
+  def initialize
+    super
+  end
+  
+  def write(context=nil)
+    return 'IfStatement'
+  end  
+  
+end

data/lib/core/runtime_class/InstanceCallClass.rb

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

data/lib/core/runtime_class/InstanceCallContainerClass.rb

@@ -0,0 +1,16 @@
+class InstanceCallContainerClass < ClassName
+  
+  def initialize(*params)
+    super
+    params.each {|x| self.push(x)}
+  end
+  
+  def copy
+    return InstanceCallContainerClass.new
+  end  
+  
+  def write(context=nil)
+    return 'InstanceCallContainer'
+  end  
+  
+end

data/lib/core/runtime_class/InstanceClassCallClass.rb

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

data/lib/core/runtime_class/LiteralClass.rb

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

data/lib/core/runtime_class/MethodParameterClass.rb

@@ -0,0 +1,27 @@
+class MethodParameterClass < ClassName
+  
+  def initialize
+    super
+  end
+  
+  def write(context=nil)
+    return 'MethodParameter'
+  end  
+  
+  def copy
+    return MethodParameterClass.new
+  end
+  
+  def value
+    return MethodParameter
+  end    
+  
+  # Returns an array of class methods call for the MethodUsage.  For example
+  #
+  # ClassMethodCallContainer.new(MethodUsageClass.new,New.new)
+  #
+  def class_method_calls(available=[])
+    return [ClassMethodCallContainer.new(MethodParameterClass.new,New.new)]
+  end  
+  
+end

data/lib/core/runtime_class/MethodUsageClass.rb

@@ -0,0 +1,27 @@
+class MethodUsageClass < ClassName
+  
+  def initialize
+    super
+  end
+  
+  def write(context=nil)
+    return 'MethodUsage'
+  end  
+  
+  def copy
+    return MethodUsageClass.new
+  end
+  
+  def value
+    return MethodUsage
+  end
+  
+  # Returns an array of class methods call for the MethodUsage.  For example
+  #
+  # ClassMethodCallContainer.new(MethodUsageClass.new,New.new)
+  #
+  def class_method_calls(available=[])
+    return [ClassMethodCallContainer.new(MethodUsageClass.new,New.new)]
+  end
+  
+end

data/lib/core/runtime_class/RequirementClass.rb

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

data/lib/core/runtime_class/ReturnClass.rb

@@ -0,0 +1,21 @@
+# TODO  Come up with a better solution that all these bloody classes!
+class ReturnClass < ClassName
+  
+  def initialize
+    super 
+  end
+
+  def write(context=nil)
+    return 'Return'
+  end
+  
+  # TODO  Decide whether this should be ReturnClass.new or Return.new see FixnumClass
+  def copy
+    return ReturnClass.new
+  end
+
+  def value
+    return Return
+  end
+  
+end

data/lib/core/runtime_class/RuntimeClass.rb

@@ -0,0 +1,30 @@
+# TODO  I'm not sure this shuld be here - it doesn't represent a runtime class - RuntimeClassClass does this
+class RuntimeClass < Array
+  attr_reader :class_name
+  #
+  # @param  name          The name of the runtime class
+  # @param  parameters    
+  #
+  def initialize(name,*parameters)
+    super()
+    
+    # Save a name for the runtime class
+    @class_name = name
+    
+    # Add the parameters to the array 
+    parameters.each do |x|
+      self.push(x.copy)
+    end    
+  end
+  
+  def write
+    result = ''
+    result += "class #{@class_name}"+"\n"
+    self.each do |x|
+      result += x.write
+    end
+    result += 'end'
+    return result
+  end
+  
+end

data/lib/core/runtime_class/RuntimeClassClass.rb

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

data/lib/core/runtime_class/RuntimeMethodClass.rb

@@ -0,0 +1,34 @@
+class RuntimeMethodClass < ClassName
+  
+  def initialize
+    super
+  end
+  
+  def write(context=nil)
+    return 'RuntimeMethod'
+  end  
+  
+  def copy
+    return RuntimeMethodClass.new
+  end
+  
+  def value
+    return RuntimeMethod
+  end
+  
+  # TODO  I'm not sure if this is needed
+  def declaration_statement
+    return ClassMethodCallContainer.new(RuntimeMethodClass.new,New.new)
+  end
+  
+  # Returns an array of class methods call for the RuntimeMethod.  For example
+  #
+  # ClassMethodCallContainer.new(RuntimeMethodClass.new,New.new,x)
+  #   - where x is a MethodUsage instance
+  #
+  def class_method_calls(available=[])
+    method_usage_variables = available.select {|x| x.kind_of?(MethodUsageVariable)}
+    return method_usage_variables.collect {|x| ClassMethodCallContainer.new(RuntimeMethodClass.new,New.new,x)}
+  end  
+  
+end

data/lib/core/runtime_class/StatementClass.rb

@@ -0,0 +1,53 @@
+class StatementClass < ClassName
+  
+  def initialize
+    super
+  end
+  
+  def write(context=nil)
+    return 'Statement'
+  end  
+  
+  def copy
+    return StatementClass.new
+  end
+  
+  def value
+    return Statement
+  end
+  
+  # Returns an array of class methods call for Statement.  For example
+  #
+  # ClassMethodCallContainer.new(StatementClass.new,New.new(Unknown.new,Equal.new,x))
+  #
+  def class_method_calls(available=[])
+
+    # NOTE: I could create a LiteralDeclarationDeclaration
+    fixnum_declarations = available.select{|y| y.kind_of?(Literal)}.collect do |x|
+      ClassMethodCallContainer.new(
+        StatementClass.new,
+        New.new,
+        ClassMethodCallContainer.new(UnknownClass.new,New.new),
+        ClassMethodCallContainer.new(EqualClass.new,New.new),
+        InstanceCallContainer.new(x.to_declaration,ToDeclarationCall.new)
+      )
+    end
+    
+    # Create ClassMethodCallContainer.new(StatementClass.new,New.new(Unknown.new,Equal.new,InstanceCallContainer.new(unknown_var,StringLength)))
+    # TODO  This uses UnknownVariable but we don't know if the UnknownVariable is a string or not
+    available_unknown_variables = available.select_all {|x| x.kind_of?(UnknownVariable)}
+    string_length_statement = available_unknown_variables.collect do |x|
+      ClassMethodCallContainer.new(
+        StatementClass.new,
+        New.new,
+        ClassMethodCallContainer.new(UnknownClass.new,New.new),
+        ClassMethodCallContainer.new(EqualClass.new,New.new),
+        #InstanceCallContainer.new(x,StringLength.new)
+        ClassMethodCallContainer.new(InstanceCallContainerClass.new(),New.new,x, ClassMethodCallContainer.new(StringLengthClass.new,New.new))
+      )
+    end 
+    
+    return fixnum_declarations+string_length_statement
+  end  
+  
+end