cauldron 0.1.0

data/lib/core/instance_call/DeclaredVariable.rb

@@ -0,0 +1,18 @@
+class DeclaredVariable <InstanceCall
+  
+  def initialize    
+  end
+  
+  def write
+    return '.declared_variable'
+  end
+  
+  def copy
+    return DeclaredVariable.new
+  end
+  
+  def destructive?
+    return false
+  end
+  
+end

data/lib/core/instance_call/InstanceCall.rb

@@ -0,0 +1,77 @@
+
+class InstanceCall < Array
+  
+  def initialize(*parameters)
+    super()
+    parameters.each do |param|
+      self.push(param)
+    end
+  end
+  
+  def copy
+    return self.class.new
+  end
+  
+  def requirements
+    raise StandardError.new('Requirements have not been defined for '+self.class.to_s+'')
+  end
+  
+  def write
+    raise StandardError.new('"write" has not been defined for '+self.class.to_s+'')
+  end
+
+  def to_literal_string
+    return write
+  end  
+  
+  def use(*parameters)
+    raise StandardError.new('"use" has not been defined for '+self.class.to_s+'')
+  end
+  
+  def response
+    raise StandardError.new('"response" has not been defined for '+self.class.to_s+'')
+  end
+  
+  # Returns true or false depending on whether the method call is 
+  # destructive or not.  Destructive calls would be chop! or
+  # .push(x) since they change the value of the subject.
+  #
+  def destructive?
+    raise StandardError.new('"destructive?" has not been defined for '+self.class.to_s+'')
+  end
+  
+  # Returns a more detailed explaination than 'write' of the method call.
+  def describe
+    return write
+  end
+  
+  def to_literal_string
+    return write
+  end
+  
+  def to_declaration
+    return VariableDeclaration.new(self.class.to_s)
+  end
+  
+  def closure
+    return ['(',')']
+  end    
+  
+  # Returns true if the method call can safely used with the 
+  # literal provided.  Otherwise it returns false.
+  #
+  def valid_syntax?(literal)
+      
+    # Check that a literal has been passed through
+    raise StandardError.new('Only a literal value can be directly evaluated') unless literal.kind_of?(Literal) 
+    
+    # Create the statement that uses the code
+    statement = literal.write+'.'+self.write
+
+    # Use the test and check for syntax error
+    return true if(StatementCheck.new.valid_syntax?(statement))
+    return false
+    
+  end
+  
+end

data/lib/core/instance_call/Params.rb

@@ -0,0 +1,15 @@
+class Params < InstanceCall
+  
+  def initialize
+    super
+  end
+  
+  def write
+    return '.params'
+  end
+  
+  def copy
+    return Params.new
+  end
+  
+end

data/lib/core/instance_call/Push.rb

@@ -0,0 +1,20 @@
+
+class Push <InstanceCall
+  
+  def initialize
+    
+  end
+  
+  def write
+    return '.push'
+  end
+  
+  def copy
+    return Push.new
+  end
+  
+  def destructive?
+    return true
+  end
+  
+end

data/lib/core/instance_call/StringLength.rb

@@ -0,0 +1,32 @@
+class StringLength < InstanceCall
+  
+  def initialize
+    super
+    
+    @use_requirements = [
+      Requirement.new(InstanceCallContainer.new(This.new,ClassCall.new), Equal.new , StringClass.new)
+    ]    
+    
+  end
+  
+  def write
+    return '.length'
+  end
+  
+  def copy
+    return StringLength.new
+  end
+  
+  def requirements
+    @use_requirements.each {|req| yield req}
+  end
+  
+  def use(val)
+    return val.length
+  end  
+  
+  def to_literal_string
+    return write
+  end
+  
+end

data/lib/core/instance_call/Times.rb

@@ -0,0 +1,20 @@
+
+class Times < InstanceCall
+  
+  def initialize
+    
+  end
+  
+  def write
+    return '.times'
+  end
+  
+  def copy
+    return Times.new
+  end
+  
+  def destructive?
+    return false
+  end
+  
+end

data/lib/core/instance_call/instance_calls.rb

@@ -0,0 +1,168 @@
+class Value < InstanceCall
+  
+  def initialize
+    super
+  end
+  
+  def write
+    return '.value'
+  end
+  
+  def copy
+    # TODO  Move this to the InstanceCall class
+    return Value.new
+  end
+  
+end 
+
+class AllPass < InstanceCall
+  
+  def initialize
+    super
+  end
+  
+  def write
+    return '.all_pass?'
+  end
+  
+  def copy
+    return AllPass.new
+  end
+  
+end
+
+class Realise < InstanceCall
+  
+  def initialize
+    super
+  end 
+  
+  def write
+    return '.realise2'
+  end
+  
+  def copy
+    return Realise.new
+  end
+  
+end
+
+class Pass < InstanceCall
+  
+  def write
+    return '.pass?'
+  end
+  
+  def copy
+    return Pass.new
+  end
+  
+  def accessor?
+    return false
+  end
+  
+end
+
+class Run < InstanceCall
+  
+  def write
+    return '.run'
+  end
+  
+  def copy
+    return Run.new
+  end
+  
+end
+
+class KindOf < InstanceCall
+  
+  def write
+    return '.kind_of?'
+  end
+  
+  def copy
+    return KindOf.new
+  end
+  
+  def param_count
+    return 1
+  end
+  
+  def possible_params
+    return %w{String Fixnum CTestCase}
+  end
+  
+end
+
+class HistoryCall < InstanceCall
+  
+  def write
+    return '.history'
+  end
+  
+  def copy
+    return HistoryCall.new
+  end
+  
+end
+
+class History2Call < InstanceCall
+  
+  def write
+    return '.history2'
+  end
+  
+  def copy
+    return History2Call.new
+  end
+  
+end
+
+class Any < InstanceCall
+  
+  def write
+    return '.any?'
+  end
+  
+  def copy
+    return Any.new
+  end
+  
+end
+
+class Include < InstanceCall
+  
+  def write
+    return '.include?'
+  end
+  
+  def copy
+    return Include.new
+  end
+  
+end
+
+class StatementID < InstanceCall
+  
+  def write
+    return '.statement_id'
+  end
+  
+end
+
+class Last < InstanceCall
+  
+  def write
+    return '.last'
+  end
+
+end
+
+class Select < InstanceCall
+  
+  def write
+    return '.select'
+  end
+
+end

data/lib/core/instance_call/length_equal.rb

@@ -0,0 +1,15 @@
+class LengthEqual < InstanceCall
+  
+  def initialize
+    
+  end
+  
+  def write 
+    return '.length ='
+  end
+  
+  def copy
+    return LengthEqual.new
+  end  
+  
+end

data/lib/core/kernal/EvalCall.rb

@@ -0,0 +1,15 @@
+class EvalCall
+  
+  def initialize(content)
+    @content = content
+  end
+  
+  def write
+    return 'eval('+@content+')'  
+  end
+  
+  def copy
+    return EvalCall.new(@content.dup)
+  end
+  
+end

data/lib/core/kernal/LocalVariablesCall.rb

@@ -0,0 +1,15 @@
+class LocalVariablesCall
+  
+  def initialize
+    
+  end
+  
+  def write
+    return 'local_variables'
+  end
+  
+  def copy
+    return LocalVariablesCall.new
+  end
+  
+end

data/lib/core/literal/Literal.rb

@@ -0,0 +1,111 @@
+# The literal class represents a variable that doesn't reference
+# a different variable.  For example 'any string' or 889.
+#
+# Scope - a literal strictly speaking doesn't need a scope id since
+#         its scope will always be the root of the runtime method
+#         therefore allowing it to be created anywhere.  
+#
+class Literal
+  include Token
+    
+  attr_reader :value, :scope_id
+  attr_writer :scope_id  
+  
+  def initialize(value)
+    super()
+    
+    # Check the datatype of the literal
+    case value.class.to_s
+      when 'String'
+      when 'Numeric'
+      when 'NilClass'
+      when 'Array'
+      when 'Fixnum'
+      when 'Symbol'
+    else
+      raise UnliteralisableError.new('Unknown literal data type: '+value.class.to_s)        
+    end
+    
+    # Declare the accessable variable
+    @value = value
+  end
+  
+  def write()
+    if @value.class.to_s == 'String' then return safe_quote(@value) end
+    if @value.class.to_s == 'Symbol' then return @value.write end
+    if @value.kind_of?(Array)  
+      return @value.write
+    end
+    return @value.to_s
+  end
+  
+  def describe
+    return write
+  end
+  
+  def copy
+    return Literal.new(@value)
+  end
+  
+  def copy_requirements
+    return [Requirement.new(This.new,Equal.new,Literal.new(@value.clone))]
+  end
+  
+  # Check whether this variable can use the specifed method
+  # call.
+  #
+  def allowed? method_call
+    return StatementCheck.new.valid_syntax?(self.write+'.'+method_call.write)
+  end
+  
+  # Returns a statement that declares a literal
+  #
+  def declaration_statement
+    return Statement.new(ClassMethodCallContainer.new(LiteralClass.new,New.new,@value))        
+  end
+  
+  def creation
+    return 'Literal.new('+@value.creation+')'
+  end
+  
+  def to_literal_string
+    return write
+  end
+  
+  def to_declaration
+    return LiteralDeclaration.new(@value)
+  end
+  
+  def equivalent?(to)
+    return false unless to.class == self.class
+    if @value.kind_of?(Array)
+      @value.zip(to.value) do |x,y|
+        return false unless x.equivalent?(y)
+      end
+      return true
+    else
+      return true if @value == to.value
+    end
+    return false
+  end
+  
+  # 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=[])
+    return []
+  end  
+  
+protected   
+  
+  # NOTE: There is a bash command 'quote' that might be useful if this approach
+  #       doesn't work out.
+  #
+  def safe_quote(string)
+    return "'"+string+"'"
+  end
+  
+end