cauldron 0.1.0

data/lib/core/variable/BaseVariable.rb

@@ -0,0 +1,154 @@
+#require "set"
+# This was introduced so I could maintain the use of the class variable
+# @@variable_id with the ArrayVarialble without having to include 
+# requirements with the array.  
+#
+class BaseVariable < Array
+  attr_reader :variable_id , :instance_variable, :value, :uniq_id_history
+  attr_writer :instance_variable, :uniq_id_history
+  
+  include Variable
+  include Token
+  # TODO  VariableIncluded is in Variable so i can probably get rid of the VariableIncluded
+  #include VariableIncluded
+  
+  # TODO  I think I'll get rid of the id parameter and just use blocks
+  # 
+  #  NOTE:  You can set the variable ids by passing it in a block
+  #         e.g. BaseVariable.new {[8,9]}
+  #         where 8 is the variable_id and unique_id is 9
+  #
+  def initialize(id=nil)  
+    super()
+    
+    # TODO  I should maybe include a check on all .copy methods to ensure a block is provided
+    # Set the variable id for the newly created variable    
+    if block_given?
+      # TEMP
+      if yield.kind_of?(Fixnum)
+        raise StandardError.new('Expecting array')
+      end
+      unless yield[:variable_id].nil?      
+        @variable_id = yield[:variable_id]      
+      else
+        @variable_id = @@variable_id
+        @@variable_id += 1
+        # TODO  Should have a separate call that returns @@variable_id and increaments @@variable_id
+      end
+      unless yield[:uniq_id].nil? 
+        raise StandardError.new('Expecting Fixnum') unless yield[:uniq_id].kind_of?(Fixnum)
+        @uniq_id = yield[:uniq_id]
+      else  
+        @uniq_id = @@uniq_id
+        @@uniq_id += 1
+      end
+      
+      @uniq_id_history = yield[:uniq_id_history] unless yield[:uniq_id_history].nil? 
+      
+    else
+      if id.nil?
+        @variable_id = @@variable_id
+        @@variable_id += 1      
+      else
+        @variable_id = id
+      end
+      
+    end
+    
+    # Give the variable an unique id
+    if @uniq_id.nil?
+      @uniq_id = @@uniq_id 
+      #raise StandardError.new('Uniq id change point') if (@uniq_id+1) == 86
+      @@uniq_id += 1      
+    end
+    
+    @uniq_id_history ||= []
+    
+    # Flag indicating if this is a scope variable or a instance variable
+    @instance_variable = false
+    
+  end
+  
+  def self.reset_global_id
+    #http://www.zenspider.com/Languages/Ruby/QuickRef.html
+    unless $".include?('test/unit.rb')
+      StandardLogger.log 'WARNING: Resetting variable id, this should only be done for tests'
+    end
+    @@variable_id = 0
+  end
+  
+  # Returns the variable if the ids matched
+  #
+  # @param  id    The uniq_id of the variable that is being looked for
+  #
+  def find_actual_variable(uniq_id)
+    return self if @uniq_id == uniq_id
+    throw :variable_not_found
+  end  
+  
+  # Returns an array of instance calls that can be created from
+  # this variable.
+  #
+  # NOTE: I checked that instance_calls wasn't a intrinsic method.
+  # 
+  # TODO  Test this (esp with ArrayVariable)
+  #
+  def instance_calls(with=[])
+    return [] unless self.realised? 
+
+    # Attempt to retrieve the literal value for the variable
+    #val = self.literalise.value
+    val = self.value
+    
+    # TODO  I suspect this method is redundant since it is always overwritten
+    
+    # Now retrieve all the possible instance call structures for that value
+    results = []
+    val.instance_call_structures.each do |struct|
+
+      if struct.instance_class != self.class then raise StandardError.new('Unexpected class type: - expecting '+val.class.to_s+' but was '+struct.instance_class.to_s) end
+      
+      # Now create a method call of the instance call
+      inst_call = InstanceCallContainer.new(self.copy,struct.method_call.copy) 
+      results.push inst_call
+
+    end
+    return results    
+  end
+  
+  # Returns an array of instances calls that return a value and are 
+  # therefore approriate for declaration statements. 
+  #
+  def returning_instance_calls(available=[])
+    return instance_calls(available)  
+  end    
+  
+  def destructive_instance_calls(with=[])
+    raise StandardError.new(" 'destructive_instance_calls' method should be overridden for "+self.class.to_s)
+  end
+  
+  #
+  # 
+  #
+  def write()
+    if (@instance_variable)
+      return '@var_'+variable_id.to_s    
+    end
+    return 'var_'+variable_id.to_s    
+  end  
+  
+  def write_with_uniq_id
+    if (@instance_variable)
+      return '@var_'+variable_id.to_s+'_u'+uniq_id.to_s    
+    end
+    return 'var_'+variable_id.to_s+'_u'+uniq_id.to_s            
+  end
+  
+  # Always returns true since realised variables should extend this class
+  # but overwrite this method.
+  #
+  def realised? 
+    return false  
+  end
+  
+end

data/lib/core/variable/BlockVariable.rb

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

@@ -0,0 +1,36 @@
+class FixnumVariable < TypeVariable
+  
+  def initialize(val,id=nil)
+    super(val,id)
+  end
+  
+  # TODO  Write test
+  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

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

data/lib/core/variable/MethodParameter.rb

@@ -0,0 +1,206 @@
+class MethodParameter < BaseVariable
+  attr_reader :usage_variable
+  
+  # TODO  I'm trying to move away from requirements
+  #
+  # @param  *requirements   Any number of requirements that describe the 
+  #                         the properties of the method variable.
+  #                         For example self == 6
+  def initialize(*requirements)
+    super(nil)
+  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|  
+      
+      #tmp = gets      
+      desc = x.describe(context)
+
+      #tmp = gets
+      desc.each_line do |l|
+        line += "\t"+l
+      end      
+      line += "\n" unless x == copied_var.last      
+    end
+    line += "\n"
+    
+    return line
+    
+  end  
+
+  def copy
+    result = self.class.new(*self) {{:variable_id => self.variable_id,:uniq_id=>@uniq_id, :uniq_id_history=>@uniq_id_history.copy}}
+    result.instance_variable = @instance_variable
+    return result
+  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
+  
+  # TODO Write tests for this
+  def meets_requirements_of_instance_call(instance_call)
+    #unless instance_call.literalisable?
+    #  raise StandardError.new('Unable to litralise instance call '+instance_call.write)
+    #end
+    
+    # Attempt to litralise the variable 
+    # TODO  The variable class returns a Literal the InstanceCallContainer returns a 
+    #       value.  They don't need to do different things.
+    if(self.literalisable?)
+      return self.literalise.value == instance_call.literalise
+    else
+      raise FailedVariableMatch.new('Unable to litralise variable to see if it meets requirements')
+    end
+    
+  end  
+  
+end