cauldron 0.1.3 → 0.1.5

data/lib/core/literal/Raw.rb

@@ -1,23 +0,0 @@
-# This class is used to include code into a statement without having 
-# to create the correct classes etc.
-#
-# It is currently only used for method validation, where I want a quick
-# check that a generated method is correct e.g. 
-#
-# ' == "Test"'
-# 
-class Raw
-  
-  def initialize(value)
-    @value = value
-  end
-  
-  def write()
-    return @value
-  end
-  
-  def copy
-    return Raw.new(@value.copy)
-  end
-  
-end

data/lib/core/literal/RuntimeMethodLiteral.rb

@@ -1,21 +0,0 @@
-# TODO  Perhaps RuntimeMethodDeclaration might have worked better
-#
-class RuntimeMethodLiteral
-  
-  def initialize(usage,return_variable)
-    raise StandardError.new('Where is this used')
-    @usage = usage
-    @return_variable = return_variable
-  end
-  
-  def write
-    # TODO  This shouldn't just make up values
-    return 'RuntimeMethod.new('+@usage.to_declaration.write+','+@return_variable.to_declaration.write+')'
-  end
-  
-  # TODO  This copy isn't accurate
-  def copy
-    return RuntimeMethodLiteral.new(@usage.copy, @return_variable.copy)
-  end
-   
-end

data/lib/core/literal/StatementLiteral.rb

@@ -1,28 +0,0 @@
-class StatementLiteral
-  
-  # TODO  I might not need the RuntimeMethodLiteral or StatementLiteral classes - I could just
-  #       use the creation command.
-  
-  # 
-  #
-  def initialize(statement)
-    @statement = statement
-  end
-  
-  # 
-  # 
-  def write
-    l = 'Statement.new('
-    @statement.each do |x|
-      l += x.creation
-      l += ',' unless x.object_id == @statement.last.object_id
-    end
-    l += ')'
-    return l
-  end
-  
-  def copy
-    return StatementLiteral.new(@statement.copy)
-  end
-  
-end

data/lib/core/method_call/AvailableVariablesCall.rb

@@ -1,25 +0,0 @@
-class AvailableVariablesCall < InstanceCall
-  include WriteParameters
-  
-  def initialize(*parameters)
-    super(*parameters)
-    
-    # The requirements for the instance use this method call
-    @use_requirements = [Requirement.new(InstanceCallContainer.new(This.new,ClassCall.new), Equal.new , RuntimeMethodClass.new)]    
-    
-  end
-
-  def write
-    return '.available_variables'
-  end
-  
-  # TODO  Test this method works
-  def copy
-    return self.class.new(*self.collect {|x| x.copy})
-  end
-  
-  def requirements
-    @use_requirements.each {|req| yield req}    
-  end    
-    
-end

data/lib/core/method_call/ClassCall.rb

@@ -1,33 +0,0 @@
-# TODO  Change this to InstanceClassCall = remember it needs to be changed to InstanceClassCallClass
-#
-# TODO  Move this to instance_call
-#
-# This represents the .class element of statements like
-# e.g. var_a.class
-#
-class ClassCall <InstanceCall
-
-	def initialize
-   super 
-	end
-
-  def write
-    return '.class'
-  end
-  
-  def copy
-    return ClassCall.new
-  end
-
-  # The class call has no requirements since every object has
-  # this methods.
-  #
-  def requirements
-    return []
-  end
-
-  def declaration_statement
-    return ClassMethodCallContainer.new(ClassCallClass.new,New.new)
-  end
-
-end

data/lib/core/method_call/DefCall.rb

@@ -1,72 +0,0 @@
-# This class represent calls to availble functions.  This could be 
-# custom generated method calls e.g.
-#
-# m1
-#
-# if there was a method that looked like
-# 
-# def m1
-#   # do something
-# end
-#
-# it could also be core ruby calls
-# 
-# TODO  Write tests for this
-#
-class DefCall <InstanceCall
-  include WriteParameters
-  
-  # TODO  I'm still undecided on whether DefCall should have a scope id or not
-  attr_reader :runtime_method, :scope_id
-  attr_writer :scope_id
-  
-  #
-  #                     TODO  I suspect response isn't needed any more or at least should be the secound parameter
-  # @param  response    What is returned by the method - 
-  # 
-  def initialize(response,runtime_method,*parameters)
-    super(*parameters)
-    raise StandardError.new('Should be a runtime method instance') unless runtime_method.kind_of?(ActsAsRuntimeMethod)
-    @response = response.copy
-    @runtime_method = runtime_method.copy
-
-  end
-  
-  def write
-    l = @runtime_method.method_name
-    l += write_params(self)
-    return l
-  end
-  
-  def describe
-    x = 'Call: '+write
-    return x
-  end
-  
-  def copy
-    return DefCall.new(@response.copy,@runtime_method.copy,*self.collect {|x| x.copy})
-  end
-  
-  def response
-    return @response.copy
-  end  
-  
-  # Returns true if the method call can pass as specified variable_type.  This
-  # bascially depends on what the method call returns.
-  # 
-  # @param  variable_type   The variable type the method call will be treated as.  For
-  #                         example FixnumVariable.
-  # 
-  def pass_as?(variable_type)
-    return @response.pass_as?(variable_type)
-  end
-  
-  def equivalent?(to)
-    return false unless to.class == self.class
-    # TODO  I should also include a method_interation value here - this should increment each time the 
-    #       the runtime method recieves a new statement because it essentially becomes a different method.
-    return true if @runtime_method.method_id == to.runtime_method.method_id
-    return false    
-  end
-  
-end

data/lib/core/method_call/EvaluateClassCall.rb

@@ -1,29 +0,0 @@
-# NOTE: This class call shouldn't be made available during runtime method
-#       generation. - it would just get messy.
-#
-class EvaluateClassCall < InstanceCall
-  
-  def initialize
-   super 
-  end
-
-  def write
-    return '.evaluate_class'
-  end
-  
-  def copy
-    return EvaluateClassCall.new
-  end
-
-  # The class call has no requirements since every object has
-  # this methods.
-  #
-  def requirements
-    return []
-  end
-
-  def declaration_statement
-    return ClassMethodCallContainer.new(EvaluateClassCall.new,New.new)
-  end  
-  
-end

data/lib/core/method_call/MethodNameCall.rb

@@ -1,27 +0,0 @@
-
-class MethodNameCall < InstanceCall
-
-  def initialize
-   super 
-  end
-
-  def write
-    return '.method_name'
-  end
-  
-  def copy
-    return MethodNameCall.new
-  end
-
-  # The class call has no requirements since every object has
-  # this methods.
-  #
-  def requirements
-    return []
-  end
-
-  def declaration_statement
-    return ClassMethodCallContainer.new(MethodNameCall.new,New.new)
-  end
-
-end

data/lib/core/method_call/ToDeclarationCall.rb

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

data/lib/core/requirement/Requirement.rb

@@ -1,292 +0,0 @@
-# A requirement is simply a statment that evaluates to true.
-# 
-# For example this == 7
-class Requirement < Array
-  include PrintVariables
-  
-  attr_reader :parent  
-  attr_writer :parent
-  
-  alias :array_push :push
-  
-  def initialize(*parameters)
-    #raise StandardError.new('---------------------This is redundant')
-    super()
-    parameters.each do |param|
-      self.push param
-    end
-  end
-  
-  # Compares another requirement to its self and to determine
-  # whether they are mutually exclusive.
-  #
-  # For example:
-  #     self > 8 ~= requirement < 7
-  #
-  def mutually_exclusive?(requirement)
-    return false
-  end
-  
-  def describe(context=self)
-    
-    line = ''        
-        
-    # Handle describing requirement 
-    if context == self
-      self.each do |code|   
-        line += code.write
-      end
-      line += "\n"
-      return line
-    end
-    
-    # Handle the description for a higher context
-    after_equal_sign = false
-    self.each do |code|
-      next if code.kind_of? This 
-      
-      if code.kind_of? Equivalent
-        after_equal_sign = true
-        line += "\t" 
-      end
-      
-      # Handle instance calls (should be shown as .class = String
-      if code.kind_of? InstanceCallContainer
-        if after_equal_sign
-          line += code.write
-        else
-          line += '.'+code.method_call.write
-        end
-      else
-        line += code.write
-      end
-      
-      line += ' ' unless code == self.last
-    end
-    return line
-    
-  end
-  
-  # Returns true if the requirement contains any other variables
-  # e.g.  self.chop = 'test' returns false
-  #       self.length = var4 returns true
-  # 
-  def any_variables?
-    self.each do |code|
-      if code.kind_of? InstanceCallContainer 
-        return true if code.subject.kind_of? Variable
-      end
-      return true if code.kind_of? Variable
-    end
-    return false
-  end
-  
-  # Writes out the nature of the requirement.  
-  #
-  # @param  context   The context in when the requirement is being written.  This
-  #                   should be something that can print variables.
-  # @param  variable  The variable that represent 'self' in the requirement.  Otherwise
-  #                   it defaults to 'self'
-  # 
-  def write(context=self,variable=nil)
-
-    #variable = parent unless parent.nil?
-    
-    line = ''
-    self.each do |x|
-      #if x.kind_of? This or x.kind_of? InstanceCallContainer
-    if x.kind_of? This or x.kind_of? InstanceCallContainer      
-        line += x.write+' '
-      else
-        line += x.write+' '
-      end
-    end
-    return line
-  end
-  
-  # Intended to be a more reliable clone.  So will go deeper
-  # into the object.
-  #
-  def copy
-    copied_requirement = Requirement.new
-    self.each do |code|
-      copied_requirement.push code.copy
-    end
-    copied_requirement.parent = nil
-    return copied_requirement
-  end
-  
-  # Returns true if the requirement contains a 'self'.  I don't think
-  # it's possible or desirable not to so I'll probably end up dropping 
-  # this method.
-  #
-  def contains_self?
-    self.each do |x|   
-      if x.kind_of? This then return true end
-      
-      # Check any instance calls for 'self'
-      if x.kind_of? InstanceCallContainer
-        return true
-      end
-      
-    end
-    return false
-  end
-  
-  # Changes the "self" value for a literal value to determine
-  # whether the literal value could be used in place.  For
-  # example:
-  #
-  # self.chop = 8 -> subst self for 22                [WRONG]
-  # self.chop = 8 -> subst self for 'community'       [CORRECT]
-  # 
-  def subst_self_for literal
-    
-    # Make a copy of the current requirement
-    copied_requirement = self.copy
-    copied_requirement.each_with_index do |x,i|
-      if x.kind_of? InstanceCallContainer
-        x.subst_self_for literal
-      end
-      if x.kind_of? This
-        copied_requirement[i] = literal
-      end
-    end    
-    
-    return copied_requirement
-    
-  end
-    
-  # Pretty much the same as each except that it includes 
-  # instance calls as two elements e.g. the suject and 
-  # the method call.
-  #  
-  def each_bit
-    self.each do |g|
-      if g.kind_of? InstanceCallContainer
-        yield g.subject
-        yield g.method_call        
-        next
-      end
-      yield g
-    end
-  end
-  
-  # Checks whether the structure of the requirement 
-  # matches that supplied.
-  # 
-  # @param  structure   A structure is simply an array of 
-  #                     classes e.g. [This,Equal,Literal]
-  #
-  def structure_match?(structure)
-
-    # Checks that they are at least the same length
-    if self.length != structure.length then return false end
-    
-    structure.each_with_index do |x,i|
-      return false unless self[i].kind_of?(x)
-    end
-    return true
-  end
-  
-  # Evaluates the code in the requirement to determine 
-  # whether it generates a runtime error.
-  #
-  def evaluate
-    evaluation_code = ''  
-    self.each do |x|
-      
-      # Change the equal sign to equivalent for evaluation purposes
-      if x.kind_of? Equal
-        evaluation_code += ' == '
-        next
-      end
-      evaluation_code += x.write(self)
-    end
-    eval 'return '+evaluation_code
-  end
-  
-  def valid?
-    begin
-      return evaluate  
-    rescue NoMethodError => e
-      StandardLogger.log e
-      return false
-    rescue RuntimeError => e
-      StandardLogger.log e
-      return false
-    end  
-  end
-  
-  # Evaluates the literal by replacing 'self' with the 
-  # literal value provided.
-  # 
-  def use?(literal)
-    
-    new_requirement = subst_self_for literal
-
-    # Change any equal(=) to equivalent(==)
-    new_requirement_string = 'if '
-    new_requirement.each do |code|
-
-      if code.kind_of? Equal
-        new_requirement_string += ' == '  
-        next
-      end
-
-      new_requirement_string += code.write
-    end
-    
-    new_requirement_string += ' then return true end'+"\n"+'return false'
-    
-    # See if the evaluated requirement breaks anything
-    begin
-      eval new_requirement_string
-    rescue StandardError => e
-      StandardLogger.log e
-      return false
-    end
-    return true
-    
-  end
-  
-  # Returns a string of the requirement but also includes the variable
-  # id for any variables.
-  #
-  def write_with_variable_id(tab=0,context=self)
-    line = ''
-    tab.times {line += "\t" }    
-    self.each do |x|
-      if x.kind_of? Variable
-        line += x.write(self)+'('+x.variable_id.to_s+') '  
-        next
-      end
-      if x.kind_of? InstanceCallContainer
-        line += x.write(self)+'('+x.subject.variable_id.to_s+')'
-        next
-      end
-      line += x.write(self)
-    end
-    return line    
-  end
-  
-  # Returns a statement containing a MethodClass instance 
-  # which is basicall Requirement.new(This.new,Equal.new,Something else)
-  #
-  def declaration_statement
-    
-    # Create the class method call 
-    instance_declaraction = ClassMethodCallContainer.new(RequirementClass.new,New.new,*self.collect{|x|x.copy.declaration_statement})  
-    
-    s = Statement.new(instance_declaraction)
-    return s
-      
-  end
-  
-protected
-  
-  def push(val)
-    array_push(val)
-  end
-  
-end