cauldron 0.1.3 → 0.1.5

data/lib/core/variable/BlockVariable.rb

@@ -1,92 +0,0 @@
-# This is an odd sort of variable because it's actual value
-# continually changes when used.  It needs to have a variable
-# id to prevent a duplicate variable being created.
-#
-class BlockVariable < BaseVariable
-  
-  attr_writer :realised
-  
-  def initialize
-    super()
-    
-    @realised = false
-  end
-  
-  # Returns a duplicate of the block variable.
-  # 
-  def copy 
-    # @uniq_id should probably be cloned or something
-    result = self.class.new() {{:variable_id => self.variable_id,:uniq_id=>@uniq_id, :uniq_id_history=>@uniq_id_history.copy}}
-    result.instance_variable = @instance_variable
-    self.each do |x|
-      result.push(x)
-    end
-    result.realised = @realised
-    return result    
-  end
-  
-  # Returns a string representing the block variable but with all the
-  # values of the block variable as well
-  def write_with_value
-    #return self.write+'('+self.inject {|line,x| line += x.value.write+} +')'
-    l  = self.write+'('
-    self.each do |x|
-      l += x.value.write
-      l += '|' unless x.object_id == self.last.object_id
-    end
-    l += ')'
-    return l
-  end
-  
-  # Returns the flag indicating whether the blockvariable had been
-  # realised yet.  I can't just use whether all the contained variables
-  # are realised as an indication because the block variable may be 
-  # empty.  This would indicate either the block itself has no
-  # itterations or it hadn't been realised yet.
-  #
-  def realised?
-    return @realised
-  end
-  
-  # Returns a duplicate block variable where all values for the block 
-  # variable are included.
-  #
-  def realise(method_map)
-    x = method_map.find_realised_variable(self.variable_id,self.uniq_id,self.class.to_s)
-    # Flag the block variable as realised - this needs to be done maually oterwise empty
-    # blocks would flaged as realsied.    
-    x.realised = true
-
-    return x
-  end
-  
-  # Returns true if the block variable can be used as the specified variable
-  # type otherwise it returns false.  It can be used as the specified variable
-  # type if all the variables it contains are of that type.
-  # 
-  # @param  variable_type     The variable type that the block variable is expected 
-  #                           to act like e.g. FixnumVariable.
-  # 
-  def pass_as?(variable_type)
-    return self.all? {|x| x.pass_as?(variable_type)}
-  end
-  
-  # This simple returns the block variable.  It is a quick hack so that
-  # InstanceCallContainers and variables can be treated in the same way although
-  # it is a bit clunck and confusing.
-  #
-  def variable
-    return self
-  end
-  
-  # This writes block variable as a literal.  Now for normal variables this is
-  # fine as var_a might become '8' etc.  However block variables have multiple
-  # values.  I'm not sure why this is need so for now it will just display
-  # the first block variable.
-  #
-  def to_literal_string
-    if empty? then return '' end
-    return self.first.to_literal_string
-  end  
-  
-end

data/lib/core/variable/FixnumVariable.rb

@@ -1,35 +0,0 @@
-class FixnumVariable < TypeVariable
-  
-  def initialize(val,id=nil)
-    super(val,id)
-  end
-  
-  def to_declaration
-    return VariableDeclaration.new('FixnumVariable',@value.to_declaration)
-  end  
-  
-  # # TODO  I wan't to get rid of this call entirly
-  # def copy_contextual_variable
-    # return copy
-  # end    
-  
-  # Returns true if the variable type is Fixnum,  this is used 
-  # to determine whether a BlockVariable or VariableContainer 
-  # can be used as a particular variable type. 
-  #
-  def pass_as?(variable_type)
-    return true if variable_type==FixnumVariable
-    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  
-  
-end

data/lib/core/variable/HistoryVariable.rb

@@ -1,8 +0,0 @@
-class HistoryVariable < BaseVariable
-  
-  def initialize(val)
-    @value = val
-    super()
-  end
-  
-end

data/lib/core/variable/MethodParameter.rb

@@ -1,179 +0,0 @@
-class MethodParameter < BaseVariable
-  attr_reader :usage_variable
-  attr_writer :variable_id
-  
-  def initialize(id=nil)
-    super(id)
-  end
-  
-  # Returns true if this variables meets the requirements of the
-  # supplied variable.  If the this meets the requirements of the
-  # supplied variable then this variable could replace the 
-  # supplied variable in a statement.
-  #
-  # TODO  Write tests for this
-  # 
-  # @param  of 
-  #
-  # TODO  Have an act_as call that doesn't return true/false but raises errors so I can identify
-  #       why something can't be something else.
-  #
-  def meets_requirements? of
-    
-    # Handle the possible datatypes of "of"
-    begin 
-      if of.kind_of?(Variable)
-        return meets_requirements_of_variable(of)
-      elsif of.kind_of?(InstanceCallContainer)
-        return meets_requirements_of_instance_call(of)
-      else
-        raise StandardError.new('Not expecting class of type '+of.class.to_s)
-      end
-    rescue FailedVariableMatch
-      return false
-    end
-  end    
-  
-  # Raises an error to avoid me accidently trying to give this class the
-  # method.
-  #
-  def to_literal_string
-    # TODO  I should turn this on further down the line - it realtes to tracking
-    #raise StandardError.new('Method Variables can\'t be converted to a literal string because they don\'t have a value')
-    return self.write
-  end
-  
-  #
-  def describe(tab=0,context=self)
-    
-    # Create a temporay copy of the variable
-    copied_var = self.copy
-
-    unless context == self
-      
-      # Return a duplicate variable with the requirements in the context indicated
-      copied_var = context.contextual_variable(copied_var.variable_id)
-      
-    end
-    
-    # Print the name of the variable
-    line = ''    
-    line += write
-    
-    # Print out each of the requirements
-    copied_var.each do |x|  
-      desc = x.describe(context)
-      desc.each_line do |l|
-        line += "  "+l
-      end      
-      line += "\n" unless x == copied_var.last      
-    end
-    line += "\n"
-    
-    return line
-    
-  end  
-
-  def copy
-    return Marshal.load(Marshal.dump(self))
-  end  
-  
-  # Returns a reference to the usage variable that is represented 
-  # by this variable.  Remember this MethodParameter represents 
-  # a particular rule so its id doesn't reflect all cases.
-  #
-  def usage_variable
-    return @usage_variable  
-  end
-  
-  # Set the usage variable that this method variable should be used
-  # as.  This is set when a method variable is added to a method.
-  # 
-  def usage_variable= usage
-    @usage_variable = usage
-  end
-  
-  # Attempts to return a literal that meets
-  # all the requirements.
-  #
-  def literalise
-
-    # Does the variable have any "equal to literal" requirements
-    self.each do |req|
-      if req.structure_match?([This,Equal,Literal])
-        return req[2].copy
-      end
-    end
-    
-    raise StandardError.new('The literalise call is very basic right now and needs improved')
-  end  
-  
-  # Returns a statement showing the variable being declaraced
-  # 
-  # MethodParameter.new(Requirement.new())
-  # 
-  def declaration_statement
-    # TODO  Check that .copy method call works across all the uses of "declaration_statement"
-    return Statement.new(ClassMethodCallContainer.new(MethodParameterClass.new,New.new,*self.collect {|x| x.copy.declaration_statement}))    
-  end 
-  
-  def to_declaration
-    return VariableDeclaration.new('MethodParameter',*self.collect {|x| x.to_declaration})
-  end  
-  
-private 
-  
-  # TODO  Write tests for this
-  def meets_requirements_of_variable(this)
-    
-    # Check if var has any requirements - if it doesn't have any then anything can be it
-    return 'is' if this.empty?
-
-    begin
-      
-      # Can this be literised? (it makes it easy to check requirements)
-      if self.literalisable?
-        
-        # then change it into a literal value
-        literal = self.literalise
-        
-        # Good stuff - next lets see if we can confirm the requirements of 'var'
-        begin
-          
-          # Goes through all of var requirements and substitutes self for the literal
-          this_could_be_that(literal,this)          
-          return true          
-        rescue IncompatiableRequirementsError => e
-          StandardLogger.instance.info e
-          return false
-        end          
-        
-      else  # If self can't be literalised
-
-        # Go through each of the supplied variables requirements
-        all_requirements_matched = true
-        this.each do |req|    
-          requirement_matched = false
-          self.each do |own_req|
-            if own_req.write == req.write
-              requirement_matched = true
-              break
-            end
-          end
-          all_requirements_matched = false unless requirement_matched
-        end
-        
-        return true if all_requirements_matched
-        return false
-      
-      end
-
-    rescue StandardError => e
-      StandardLogger.log e
-      return false
-    end        
-    return false
-      
-  end
-  
-end

data/lib/core/variable/MethodUsageVariable.rb

@@ -1,60 +0,0 @@
-class MethodUsageVariable < BaseVariable
-  
-  def initialize(*parameters)
-    super()
-    raise StandardError.new('Only submit the paramaters on the usage variable') if parameters.first.kind_of?(MethodUsage)
-    # Go through each paramater in the method usage instance
-    parameters.each do |x|
-      self.push x.copy
-    end
-    
-  end
-  
-  def to_declaration
-    return VariableDeclaration.new('MethodUsageVariable',*self.collect {|x| x.to_declaration})
-  end
-  
-  def copy
-    result = MethodUsageVariable.new(*self.collect {|x| x.copy}) {{:variable_id => self.variable_id,:uniq_id=>@uniq_id, :uniq_id_history=>@uniq_id_history.copy}}
-    return result
-  end
-  
-#  # Only let this method be called from fellow Fixnum classes or Unknowns
-#  def variable_id=(id)
-#    # TODO  This would be nicer if it wasn't so hard coded ./lib/core/variable/Unknown.rb
-#    unless caller.first.split(':')[0]==__FILE__ or caller.first.split(':')[0]=='./lib/core/variable/Unknown.rb'
-#      raise StandardError.new('Illegal attempt to set variable_id')
-#    end
-#    @variable_id = id
-#  end
-  
-  # TODO  Test this
-  def to_literal_string
-    l = 'MethodUsage.new('
-    self.each do |x|
-      l += x.to_literal_string
-      unless x.object_id == self.last.object_id
-        l += ','
-      end
-    end
-    l += ')'    
-    return l
-  end      
-  
-  # TODO  Write tests
-  # Compares the passed argument and returns true if they are 
-  # the same class and contains the same values.
-  #
-  def equivalent?(to)
-    return false if to.class != self.class
-    to.zip(self) do |x,y|
-      return false unless x.equivalent?(y)
-    end
-    return true
-  end   
-  
-  def destructive_instance_calls(with=[])
-    return []  
-  end
-  
-end

data/lib/core/variable/NilVariable.rb

@@ -1,29 +0,0 @@
-class NilVariable < TypeVariable
-  
-  def initialize(id=nil)
-    super(nil)
-  end  
-  
-  def copy
-    copied = NilVariable.new {{:variable_id => self.variable_id,:uniq_id=>@uniq_id, :uniq_id_history=>@uniq_id_history.copy}}
-    #copied.variable_id = self.variable_id
-    return copied
-  end    
-  
-  # Only let this method be called from fellow NilVariable classes  
-  def variable_id=(id)
-    unless caller.first.split(':')[0]==__FILE__
-      raise StandardError.new('Illegal attempt to set variable_id')
-    end
-    @variable_id = id
-  end      
-  
-  def realised?
-    return true
-  end  
-  
-  def to_declaration
-    return VariableDeclaration.new(self.class.to_s,nil.to_declaration)
-  end
-  
-end

data/lib/core/variable/RuntimeMethodParameter.rb

@@ -1,67 +0,0 @@
-class RuntimeMethodParameter < TypeVariable
-  
-  def initialize(val)
-    super(val)
-  end
-  
-#  def copy
-#    copied = self.class.new(@value)
-#    copied.variable_id = self.variable_id
-#    return copied
-#  end  
-#  
-  # Only let this method be called from fellow Fixnum classes or Unknowns
-  def variable_id=(id)
-    # TODO  I need a better way to restrict access to this
-    # TODO  This would be nicer if it wasn't so hard coded ./lib/core/variable/Unknown.rb
-    #unless caller.first.split(':')[0]==__FILE__ or caller.first.split(':')[0]=='./lib/core/variable/Unknown.rb'
-    #  raise StandardError.new('Illegal attempt to set variable_id')
-    #end
-    @variable_id = id
-  end
-  
-  # Returns an array of instance calls that are possible given the 
-  # provided variables.
-  # 
-  # @param  available   
-  #
-  def instance_calls(available=[],used_in_declaration_statement=false)
-    results = []
-
-    # Create runtime_method.push(runtime_value)                 
-    ##  Find all the statement variables
-    available.find_all {|x| x.kind_of?(StatementVariable)}.each do |y|
-      #results.push(InstanceCallContainer.new(self.copy,PushStatement.new,y.copy))    
-      # TODO  What is PushStatement for
-      results.push(InstanceCallContainer.new(self.copy,Push.new,y.copy))    
-    end
-    return results             
-  end
-  
-  # Returns an array of instances calls that return a value and are 
-  # therefore approriate for declaration statements. 
-  # 
-  # NOTE  Although .push does return a value I have excluded it because 
-  #       I want to limit the number of variables declared.
-  #
-  def returning_instance_calls(available)
-    return []  
-  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 instance_calls(available)
-  end
-  
-#  # Returns a declaration variable for this runtime method variable. 
-#  #
-#  def to_declaration
-#    return VariableDeclaration.new(RuntimeMethodParameter)
-#  end  
-  
-end