rVM 0.0.14 → 0.0.17

data/lib/rvm/classes/number.rb

@@ -62,6 +62,10 @@ module RVM
         @value
       end
       
+      def pretty_print(q)
+        q.text @value.to_s
+      end
+      
       #alias :respond_to_number :respond_to?
       #def respond_to?(symbol,include_private = false)
       #  respond_to_number(symbol,include_private)

data/lib/rvm/classes/object.rb

@@ -18,7 +18,7 @@ module RVM
         m = @functions[method] || @object_class.object_functions(method)
         raise "Unknown method #{method} for object #{self}" if not m
         params.unshift self
-        env = RVM::Interpreter::Enviroment.new({:params => params||[], :locals => @variables}, env)
+        env = RVM::Interpreter::Environment.new({:params => params||[], :locals => @variables}, env)
         m.call(params, env)
       end
       

data/lib/rvm/classes/string.rb

@@ -19,7 +19,8 @@ module RVM
 				'm' => 35, 'M' => 45,
 				'c' => 36, 'C' => 45,
 				'w' => 37, 'W' => 47,
-      }
+      } unless defined?(ANSI_MAP)
+      
       def initialize val = ""
         super val.to_s
       end
@@ -69,6 +70,10 @@ module RVM
         c = "\e[#{colorcode}m"
         self.class.new("#{c}#{self.gsub("\e[0m",c)}\e[0m")
       end
+      
+      def value
+        to_s
+      end
     end
   end
 end

data/lib/rvm/environment.rb

@@ -0,0 +1,256 @@
+module RVM
+  module Interpreter
+        # This class represents the environment, the memory so to say for the VM.
+    # The environment holds environmental variables like who executes the
+    # code, on what object it runs, what parameters where passed to the call
+    # and as well, and perhaps most importantly the local variables.
+    #
+    # Some of the functions called will initialize new environments, as
+    # for example function calls.
+    class Environment
+      # This creates a new environment environment, it generates a new env
+      # default variables are set if not defined in +data+.
+      #
+      # If +oldenv+ is provided it will also fall back to see if not
+      # existing variables 
+      #
+      # +init_data+ is a hash that can be passed the following values:
+      # :locals:: A hash with local variables mapped name => value
+      # :functions:: A hash with functions for the scope.
+      # :evaldeepth:: A fixnum that indicates how deep the evaluation  is.
+      # :params:: A array that holds local parameters for example for functions
+      #           or blocks.
+      def initialize init_data = {}, oldenv=nil
+        
+        @data = {
+          :locals => {}, #oldenv ? oldenv.data[:locals] : {},
+          :locals_swapped => true, # init_data.keys.include?(:locals),
+          :functions => oldenv ? oldenv.data[:functions] : {},
+          :functions_swapped => init_data.keys.include?(:functions),
+          :evaldeepth => 0,
+          :params => oldenv ? oldenv.data[:params] : [],
+          :params_swapped => init_data.keys.include?(:params)
+        }.merge(init_data)
+        @path = [] if oldenv.nil?
+        
+        # Make sure that all locals that are passed, are actually in a variable
+        # storage.
+        if init_data[:locals]
+          # For easy access we get us a link to the locals
+          locals = @data[:locals]
+          # Now we itterate through them
+          init_data[:locals].each do |k,v|
+            #For every variable that isn't already in a storage
+            if not v.is_a?(VariableStorage)
+              # We put it in a storage to assure the environment is propper.
+              locals[k] = VariableStorage.new(v)
+            end
+          end
+        end
+        
+        # We store the priviouse environment to look upwards through the scopes
+        # for priviouse defined variables, if no old environment was given we
+        # set the priviose scope to an empty hash.
+        @prev = oldenv || {}
+        RVM::debug "data: #{data}\noldenv:#{oldenv}" if $DEBUG
+        RVM::debug "Creating new environment with: #{@data.inspect} as child" +
+                   " of #{@prev}" if $DEBUG
+      end
+      
+      
+      # Allows raw access to the data, it should not be used unless
+      # somoene knows pretty exactly what they are doing.
+      def data
+        @data
+      end
+      
+      def path
+        @path || @pre.path
+      end
+      
+      # returns a parameter that was passed to the call. For function calls
+      # this is especially important, it beginns with 0.
+      #
+      # If the current environment does not have the given paramenter it tries
+      # it's 'oldenv' attrib to see if that had a object.
+      def param i
+        RVM::debug "Getting param #{i} (#{@data[:params][i]})" if $DEBUG
+        if @data[:params_swapped]
+          @data[:params][i] || @prev.param(i)
+        else
+          @data[:params][i]
+        end
+      end
+      
+      # Returns a local variable with the given name.
+      #
+      # If the current environment does not have any local variables with
+      # the given name it tries the privious environments.
+      #
+      # This returns the +VariableData+ object NOT the value of the variable.
+      # Use +read_var_val+ if you want to read the value of a variable.
+      def [] k
+        
+        r = @data[:locals][k] 
+        r = @prev[k] if not r and @data[:locals_swapped]
+        RVM::debug "Getting variable #{k} (#{r})" if $DEBUG
+        r
+      end
+      
+      # Sets a local variable witin the environment.
+      #
+      # If the variable exists in a 'higher' environment the value is changed.
+      # 
+      # If not it is newly created in the current environment and thus not
+      # visible in upper environments.
+      def []= name, value
+        RVM::debug "Setting variable #{name} to #{value}" if $DEBUG
+        
+        # First we try to get the variable storage of the variable requested.
+        # This will work if it was defined in this or a priviouse scope.
+        if storage = self[name]
+          # If we found the storage we'll change it's value and not define it
+          # again.
+          storage.val = value
+        else
+          # If we didn't found a Variable storage, the variable wasn't defined
+          # before so we make a new VariableStorage and save the variable in
+          # it.
+          declare name, value
+        end
+        value
+      end
+      
+      # Defines a varialbe in the current scope, priviose variables are not
+      # changed.
+      # This is needed for local varialbe declarations that overwrite priviouse
+      # globals.
+      def declare name, value
+        #Now we need to make our own set of storage!
+        if not @data[:locals_swapped]
+          @data[:locals_swapped] = true
+          @data[:locals] = {}
+        end
+        @data[:locals][name] = VariableStorage.new(value)
+      end
+      
+      # Returns a function for the environment. If the current environment does
+      # not hold a function with the requested name it checks through the 
+      # entire tree if a function can be found in the outer scopes.
+      # 
+      # The result is to be execpted to be of the +RVM::Classes::Block+ class.
+      def function name
+        # Try to get the function in the local defintions.
+        fun = @data[:functions][name]
+        # if that fails and we have a previous environment check that
+        fun = @prev.function(name) if fun.nil? and @data[:functions_swapped] and @prev.is_a? Environment
+        RVM::debug "Getting functon #{name} (#{fun})" if $DEBUG
+        # return what was found
+        fun
+      end
+      
+      # This defines a function within the environment and lets you call it later
+      # on.
+      # 
+      # It expects the body to be a RVM::Classes::Block so it can be executed.
+      # The return value is the given block
+      def def_function name, body
+        if not body.is_a?(RVM::Classes::Block)
+          raise(ArgumentError, "Function definitions must be of block class.") 
+        end
+        
+        #Now we need to make our own set of storage!
+        if not @data[:functions_swapped]
+          @data[:functions_swapped] = true
+          @data[:functions] = {}
+        end
+        
+        @data[:functions][name] = body
+        RVM::debug "Setting functon #{name} (#{body})" if $DEBUG
+        body
+      end
+      
+      # This functin is closely related to +[]+ with the difference that it
+      # returns the value and not the VariableStorage object.
+      # It is equivalent to [].val just that it also deals with nil ojects and
+      # and returns a RVM::Classes::Error if the requested variable wasn't
+      # found.
+      def read_var_val name
+        
+        r = nil
+        if (v = self[name])
+          r = v.val
+        else
+          raise "Variable #{name} is not defined."
+        end
+        RVM::debug "Getting variable value #{name} (#{r})" if $DEBUG
+        r
+      end
+    end
+    # This class is used to store the variable content to allow chross 
+    # refferencing and passing variables upwards through different scopes.
+    class VariableStorage
+      
+      # Lets the script read the value of the variable.
+      attr_reader :val
+      
+      # The storage is initialized with two optional parameters:
+      #
+      # +val+:: which is the value to be stores.
+      # +writable+:: which when set to false prevents the variable to be
+      #              written, which might be helpfull when trying to publish
+      #              some data to a script that is not supposed to be changed.
+      def initialize val = nil, writable = true
+        @writable = writable
+        @val = val
+      end
+      
+      # Used to write to the variable, if +writable+ was set to false this
+      # will have no effect.
+      # 
+      # It returns the new value set or, if +writable+ was false the old value.
+      def val=v
+        @val = v if @writable
+        @val
+      end
+    end  
+    
+    # The callback storang is used to help publishing variables from a ruby
+    # class to the rVM, it will get and set the variables during runtime.
+    #
+    # It will link getter and setter methods and not the instance variable
+    # itself, which means also computed attributes can be handled by this.
+    #
+    # This class is made if it is nessessary that a script always has access
+    # to constantly chaning data within a object and not only deal with static
+    # values set once.
+    class VariableStorageCallback < VariableStorage
+      # The construtor takes 3 parameters to specifie the object it shold
+      # be linked with, the attribute to handle and +writable+ that will define
+      # if the VariableStorage can be written too by the script.
+      #
+      # var is expected to by a Symbol equal the the function, the getter will
+      # call obj.var and the setter will call obj.var=.
+      #
+      def initialize obj, var, writable = true
+        super(nil, writable)
+        @obj = obj
+        @get = var.to_sym
+        @set = "#{var}=".to_sym
+      end
+      
+      # This methods sets the variable passed to the object by sending it to
+      # the setter method.
+      def val= v
+        @obj.send(@set,v) if @writable
+        @obj.send(@get)
+      end
+      
+      # The getter will call the getter of the object to handle to get the
+      # current value.
+      def val
+        @obj.send(@get)
+      end
+    end
+  end
+end

data/lib/rvm/functions.rb

@@ -1,5 +1,5 @@
-require File.dirname(__FILE__) + '/plugin'
-require File.dirname(__FILE__) + '/interpreter'
+require 'rvm/plugin'
+require 'rvm/interpreter'
 module RVM
   # This module holds all the functions laded for the rVM to to keep them
   # organized and handle which are accassabel and which not.
@@ -49,8 +49,9 @@ module RVM
         # is set.
         # This is what you want if you call a function to ensure all parameters
         # are passed correctly.
-        def call params, env, pos = nil
+        def call params, env, pos = []
           i = 0
+          pos ||= []
           # We want to make sure that if we don't have signatures from the
           # function we have a default signature of any to prevent automatic
           # type castng in that case
@@ -75,7 +76,11 @@ module RVM
             p 
           end if not signature.empty?
           # Now we execute the function code and cache the esult
-          r = execute(params, env)
+          begin
+            r = execute(params, env)
+          rescue Exception => e
+            raise "#{e} at #{pos.join(':')}"
+          end
           # print a debug message if needed
           RVM::debug "#{self.inspect}: #{signature.inspect} = '#{r}'" if $DEBUG
           r

data/lib/rvm/functions/array.rb

@@ -1,6 +1,30 @@
+=begin
+The MIT License
+
+Copyright (c) 2007 Heinz N. 'Licenser' Gies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Ruby Mush"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+=end
+
 Dir[File.dirname(__FILE__) + '/array/*.rb'].each do |c|
-  require c
+  require 'rvm/functions/array/' + File.basename(c)
 end
 Dir[File.dirname(__FILE__) + '/collection/*.rb'].each do |c|
-  require c
+  require 'rvm/functions/collection/' + File.basename(c)
 end

data/lib/rvm/functions/array/append.rb

@@ -1,5 +1,35 @@
-module RVM
+=begin
+The MIT License
+
+Copyright (c) 2007 Heinz N. 'Licenser' Gies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Ruby Mush"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+=end
+
+module RVM 
   module Functions
+    
+    # The Append function takes two arguments. The first an List or and anything
+    # else as a second parameter.
+    #
+    # It will take the List and append the second parameter passed to it to this
+    # list in the very end.
     class Append < Function
       def Append.execute params, env
         if params.length == 2

data/lib/rvm/functions/array/at.rb

@@ -1,5 +1,33 @@
-module RVM
+=begin
+The MIT License
+
+Copyright (c) 2007 Heinz N. 'Licenser' Gies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Ruby Mush"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+=end
+
+module RVM 
   module Functions
+    
+    # The At function is used to access elements for a List, it takes the List
+    # the get the element from as a first argument and the position to get it
+    # from, a Number, as the second.
     class At < Function
       class << self 
         def execute params, env

data/lib/rvm/functions/array/set_at.rb

@@ -1,5 +1,34 @@
+=begin
+The MIT License
+
+Copyright (c) 2007 Heinz N. 'Licenser' Gies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Ruby Mush"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+=end
+
+
 module RVM
   module Functions
+    
+    # This Function is used to set a element of a List on a specific position.
+    # The List is passed as first and the position, a Number, passed as second
+    # parameter.
     class SetAt < Function
       def SetAt.execute params, env
         if params.length == 3