cauldron 0.1.0

data/lib/core/literal/Raw.rb

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

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

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

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

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

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

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

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

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

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