rVM 0.0.9 → 0.0.10

data/lib/rvm.rb

@@ -1,7 +1,7 @@
-require 'rvm/interpreter'
-require 'rvm/classes'
-require 'rvm/functions'
-require 'rvm/languages'
+require File.dirname(__FILE__) +'/rvm/interpreter'
+require File.dirname(__FILE__) +'/rvm/classes'
+require File.dirname(__FILE__) +'/rvm/functions'
+require File.dirname(__FILE__) +'/rvm/languages'
 require 'timeout'
 
 # This is the rVM library. Including it loads the very basic functionalites rVM offers.

data/lib/rvm/acts_as_rvm_type.rb

@@ -0,0 +1,116 @@
+
+# RVM::ActsAsRVMType is a mixin that allows to quickly publish classes and types
+# to the rVM interpreter without going through the hassle of defining each 
+# function on it's own and publisheing every varialbe that is watned.
+#
+# == Example
+#   class Test
+#     # Add the readers and writers for
+#     attr_accessor :var
+#     include RVM::ActsAsRVMType
+#     acts_as_rvm_type
+#     register_variable :var
+#     register_function :to_s
+#   end
+
+
+module RVM::ActsAsRVMType
+  
+  # Called when included, loads the class methods and the instance methods needed.
+  def self.included(mod)
+    mod.extend(RVM::ActsAsRVMType::ActsAsRVMTypeMethods)
+  end
+  
+  
+  module ActsAsRVMTypeMethods
+    # This function sets up the class to be a registerd class for rVM.
+    # It also sets it up to allow the use of +register_variable+ and 
+    # +register_function+.
+    def acts_as_rvm_type
+      # registering as class
+      extend RVM::Plugin
+      plugin_host RVM::Classes
+      register_for self.class.to_s.gsub(/(\w)([A-Z])/,"\1_" + "\2".downcase).to_sym
+      
+      #initializing empty functions and variables hashes
+      @functions = {}
+      @variables = {}
+      
+      #including DSL functions     
+      extend RVM::ActsAsRVMType::ActsAsRVMTypeInstanceMethods
+      
+      #including methods in class
+      include RVM::ActsAsRVMType::ActsAsRVMTypeSingeltonMethods
+    end
+  end
+  
+  module ActsAsRVMTypeSingeltonMethods
+    # This function will set up the variables for a rVM and replaces
+    # the current function with a shorter and faster one.
+    def variables
+      puts self.class
+      @variables = {}
+      #gets the variables hash from the Test class and maps it to a getter/setter Class
+      self.class.object_variables.each do |name, data|
+        published_as, writable = data
+        @variables[published_as.to_s] = RVM::Interpreter::VariableStorageCallback.new(self, name, writable)
+      end
+      #redefinces the variables method to remove overhead from mapping
+      instance_eval do
+        def variables
+          @variables
+        end
+      end
+      @variables
+    end
+    
+    # This function will set up the variables for a rVM and replaces
+    # the current function with a shorter and faster one.
+    def functions
+      @functions = self.class.object_functions.dup
+      instance_eval do
+        def functions
+          @functions
+        end
+      end
+      @functions ||= @@functions.dup
+    end
+    
+  end
+  
+  module ActsAsRVMTypeInstanceMethods
+    
+    # This registers a variable for the rVM interface, it allows the scripts
+    # to read and write them. If +writable+ is set this will be a read only
+    # variable. It alls an be published to rVM under a different name,
+    # by passing +published_as+.
+    def register_variable name, writable = true, published_as = name
+      @variables[published_as.to_s] = [name.to_sym, writable]
+    end
+   
+    # This registers a variable for the rVM interface, it allows the scripts
+    # to read and write them. If +writable+ is set this will be a read only
+    # variable. It alls an be published to rVM under a different name,
+    # by passing +published_as+.    
+    def register_function name, published_as = "#{name}"
+      @functions[published_as.to_s] = Class.new(RVM::Functions::Function) do @name = name; end
+      class << @functions[published_as.to_s]
+        def execute params, env
+          env.read_var_val(:self).send(@name, *params)
+        end
+        
+        def signature
+          [:any] 
+        end
+      end
+    end
+    
+    def object_variables
+      @variables
+    end
+    def object_functions
+      @functions
+    end 
+  end
+  
+end

data/lib/rvm/classes.rb

@@ -19,7 +19,6 @@ module RVM
   #   require 'lib/base/classes'
   #   string = RVM::Classes[:string].new
   module Classes
-    
     extend RVM::PluginHost
     default :string
     # The Parent for new classes, meant never to be used alone.

data/lib/rvm/classes/association.rb

@@ -0,0 +1,36 @@
+module RVM
+  module Classes
+    class Association < Hash
+      extend Plugin
+      plugin_host Classes
+      register_for :association
+      @@type = :association
+      
+      def data_type
+        :list
+      end      
+      
+      def variables
+        @variables ||= {}
+      end
+      
+      
+      def functions
+        @functions ||= {
+          'size' => RVM::Functions[:size],
+          'length' => RVM::Functions[:size],
+          'get' => RVM::Functions[:assoc_get],
+          'set' => RVM::Functions[:assoc_set],          
+        }
+      end
+      
+      def initialize source= {}, sepperator = ' '
+        super()
+        if source.is_a?(::Hash) # Okay we've to hack here to get sure we get the /real/ String
+          self.merge! source
+        end
+      end
+      
+    end
+  end
+end

data/lib/rvm/functions.rb

@@ -19,8 +19,7 @@ module RVM
           if (RVM::Functions::has? m)
             RVM::Functions[m].execute args, @env 
           else
-            raise "ook!"
-            #method_missing_old_functions m, *args, &block
+            method_missing_old_functions m, *args, &block
           end
         end
         

data/lib/rvm/functions/association/assoc_get.rb

@@ -0,0 +1,25 @@
+module RVM
+  module Functions
+    class AssocGet < RVM::Functions::Function
+      class << self
+        def execute params, env
+          if params.length == 2
+            assoc = params.shift
+            key = params.shift
+            assoc[key]
+          elsif params.length == 1 and (this = env.read_var_val(:self)).is_a?(RVM::Classes[:association]) 
+            this[params.shift]
+          else
+            RVM::Classes[:error].new(1,"FUNCTION (#{self.class}) EXPECTS 2 or 1 ARGUMENTS BUT GOT #{params.length}")
+          end
+        end
+        
+        def signature
+          [:any]
+        end
+      end
+      
+      register_for :assoc_get
+    end
+  end
+end

data/lib/rvm/functions/association/assoc_set.rb

@@ -0,0 +1,28 @@
+module RVM
+  module Functions
+    class AssocSet < RVM::Functions::Function
+      class << self
+        def execute params, env
+          if params.length == 3
+            assoc = params.shift
+            key = params.shift
+            value = params.shift
+            assoc[key] = value
+          elsif params.length == 2 and (this = env.read_var_val(:self)).is_a?(RVM::Classes[:association]) 
+            key = params.shift
+            value = params.shift
+            this[key] = value
+          else
+            RVM::Classes[:error].new(1,"FUNCTION (#{self.class}) EXPECTS 3 or 2 ARGUMENTS BUT GOT #{params.length}")
+          end
+        end
+        
+        def signature
+          [:any]
+        end
+      end
+      
+      register_for :assoc_set
+    end
+  end
+end

data/lib/rvm/functions/collection/get.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) +'/../array/at'
+require File.dirname(__FILE__) +'/../association/assoc_get'
+module RVM
+  module Functions
+    class Get < RVM::Functions::Function
+      class << self
+        FUNCTION_MAP = {
+          RVM::Classes::List => RVM::Functions::At,
+          Classes::Association => RVM::Functions::AssocGet
+        }
+        def execute params, env
+          if params.length == 2
+            if fun = FUNCTION_MAP[params.first.class]
+              fun.execute(params, env)
+            else
+              RVM::Classes[:error].new(1, "FUNCTION (#{self.class}) does not accept #{params.first.class}")
+            end
+          elsif params.length == 1 and (this = env.read_var_val(:self)).is_a?(RVM::Classes[:association]) 
+            if fun = FUNCTION_MAP[this]
+              fun.execute(params, env)
+            else
+              RVM::Classes[:error].new(1, "FUNCTION (#{self.class}) does not accept #{thiss.class}")
+            end         
+          else
+            RVM::Classes[:error].new(1, "FUNCTION (#{self.class}) EXPECTS 2 or 1 ARGUMENTS BUT GOT #{params.length}")
+          end
+        end
+        
+        def signature
+          [:any]
+        end
+      end
+      
+      register_for :get
+    end
+  end
+end

data/lib/rvm/functions/collection/set.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) +'/../array/set_at'
+require File.dirname(__FILE__) +'/../association/assoc_set'
+module RVM
+  module Functions
+    class Set < RVM::Functions::Function
+      class << self
+        FUNCTION_MAP = {
+          RVM::Classes::List => RVM::Functions::SetAt,
+          Classes::Association => RVM::Functions::AssocSet
+        }
+        def execute params, env
+          if params.length == 2
+            if fun = FUNCTION_MAP[params.first.class]
+              fun.execute(params, env)
+            else
+              RVM::Classes[:error].new(1, "FUNCTION (#{self.class}) does not accept #{params.first.class}")
+            end
+          elsif params.length == 1 and (this = env.read_var_val(:self)).is_a?(RVM::Classes[:association]) 
+            if fun = FUNCTION_MAP[this]
+              fun.execute(params, env)
+            else
+              RVM::Classes[:error].new(1, "FUNCTION (#{self.class}) does not accept #{thiss.class}")
+            end         
+          else
+            RVM::Classes[:error].new(1, "FUNCTION (#{self.class}) EXPECTS 2 or 1 ARGUMENTS BUT GOT #{params.length}")
+          end
+        end
+        
+        def signature
+          [:any]
+        end
+      end
+      
+      register_for :set
+    end
+  end
+end

data/lib/rvm/functions/{array → collection}/size.rb

@@ -1,9 +1,13 @@
 module RVM
   module Functions
     class Size < Function
-      class << self 
+      class << self
+        COLLECTION_CLASSES = [
+          RVM::Classes::List,
+          RVM::Classes::Association
+        ]
         def execute params, env
-          if (this = env.read_var_val(:self)).is_a?(RVM::Classes[:list]) and params.empty?
+          if COLLECTION_CLASSES.include?(this = env.read_var_val(:self)) and params.empty?
             RVM::Classes[:number].new(this.size)
           elsif params.length == 1
             RVM::Classes[:number].new(params[0].size)
@@ -11,7 +15,6 @@ module RVM
             RVM::Classes[:error].new(1,"FUNCTION (#{self.class}) EXPECTS 2 ARGUMENTS BUT GOT #{params.length}")
           end
         end
-        
         def signature
           [:any]
         end

data/lib/rvm/interpreter.rb

@@ -22,11 +22,28 @@ module RVM
       RVM::Interpreter::Constant.new(RVM::Classes[type].new(value), pos)
     end
     
+    
+    class VariableStorageCallback
+      def initialize obj, var, writable = true
+        @obj = obj
+        @get = var.to_sym
+        @set = "#{var}=".to_sym
+        @writable = writable
+      end
+      def val= v
+        @obj.send(@set,v) if @writable
+      end
+      def val
+        @obj.send(@get)
+      end
+    end
+    
     class VariableStorage
       attr_accessor :val
-      def initialize val, writable = true
+      def initialize val = nil, writable = true, &block
         @writable = writable
         @val = val
+        instance_eval(&block) if block
       end
       
       def val=v

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rVM
 version: !ruby/object:Gem::Version 
-  version: 0.0.9
+  version: 0.0.10
 platform: ruby
 authors: 
 - Heinz N. Gies
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-07-16 00:00:00 +02:00
+date: 2008-07-21 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -23,7 +23,9 @@ extra_rdoc_files:
 - README
 files: 
 - lib/rvm
+- lib/rvm/acts_as_rvm_type.rb
 - lib/rvm/classes
+- lib/rvm/classes/association.rb
 - lib/rvm/classes/block.rb
 - lib/rvm/classes/boolean.rb
 - lib/rvm/classes/class.rb
@@ -39,8 +41,14 @@ files:
 - lib/rvm/functions/array/append.rb
 - lib/rvm/functions/array/at.rb
 - lib/rvm/functions/array/set_at.rb
-- lib/rvm/functions/array/size.rb
 - lib/rvm/functions/array.rb
+- lib/rvm/functions/association
+- lib/rvm/functions/association/assoc_get.rb
+- lib/rvm/functions/association/assoc_set.rb
+- lib/rvm/functions/collection
+- lib/rvm/functions/collection/get.rb
+- lib/rvm/functions/collection/set.rb
+- lib/rvm/functions/collection/size.rb
 - lib/rvm/functions/general
 - lib/rvm/functions/general/cmp.rb
 - lib/rvm/functions/general/eq.rb
@@ -120,7 +128,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: rmush
-rubygems_version: 1.1.1
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: A ruby based VM that lets one add secure scripting to ruby applications.