cauldron 0.1.3 → 0.1.5

data/lib/core/instance_call/InstanceCall.rb

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

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

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

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

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

@@ -1,176 +0,0 @@
-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
-
-class First < InstanceCall
-  
-  def write
-    return '.first'
-  end  
-  
-end

data/lib/core/instance_call/length_equal.rb

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

data/lib/core/kernal/EvalCall.rb

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

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

data/lib/core/literal/Literal.rb

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