AmberVM 0.0.19

data/lib/amber/classes/list.rb

@@ -0,0 +1,96 @@
+module AmberVM
+  module Classes
+    class List < AmberVM::Classes::Class
+      plugin_host Classes
+      register_for :list
+      @@type = :list
+      attr_reader :sepperator
+      
+      def [] i
+        if not @array[i]
+          @array[i] =  AmberVM::Interpreter::VariableStorage.new(nil)
+        end
+        @array[i]
+      end
+      
+      def []= i,v
+        v = v.val if v.is_a? AmberVM::Interpreter::VariableStorage
+        if not @array[i]
+          @array[i] = AmberVM::Interpreter::VariableStorage.new(v)
+        else
+          @array[i].val = v
+        end
+        @array[i]
+      end
+      
+      def data_type
+        :list
+      end
+      
+      def array
+        @array
+      end
+      
+      def variables
+        @variables ||= super.merge({
+          'size' => AmberVM::Interpreter::VariableStorageCallback.new(self,:size,false),
+          'length' => AmberVM::Interpreter::VariableStorageCallback.new(self,:size,false)
+        })
+      end
+      
+      def initialize source = [], sepperator = ' '
+        super()
+        @array = Array.new()
+        if source.is_a?(::String) # Okay we've to hack here to get sure we get the /real/ String
+          source = source.split sepperator
+        elsif !source.is_a?(Array)
+          source = [source]
+        end
+        source.map! {|i| AmberVM::Interpreter::makevs(i)}
+        @array.concat source
+        @sepperator = sepperator.to_s
+      end
+      
+      def resplit(sep)
+        sep = sep.to_s
+        if sep != @sepperator
+          t = @array.map{|i| i.val}.join(@sepperator)
+          @sepperator = sep
+          @array.clear
+          @array.concat(t.split(sep).map{|i| AmberVM::Interpreter::makevs(i)})
+        end
+      end
+      
+      def == v
+        if v.is_a? List
+          @array == v.array and @sepperator == v.sepperator
+        else
+          @array.map{|i| i.val} == v
+        end
+      end
+      
+      def + v
+        if v.is_a? List
+          @array + v.array
+        else
+          @array + v
+        end
+      end
+      
+      def size
+        @array.size
+      end
+      
+      def sepperator= sep
+        @sepperator = sep.to_s
+      end
+      
+      def to_s
+        if @sepperator
+          @array.map{|i| i.val.to_s}.join(@sepperator)
+        end
+      end
+      
+    end
+  end
+end

data/lib/amber/classes/null.rb

@@ -0,0 +1,35 @@
+module AmberVM
+  module Classes
+    class Null < AmberVM::Classes::Class
+      register_for :null
+      
+      def data_type
+        :null
+      end
+      
+      def hash
+        nil.hash
+      end
+      
+      def eql?(o)
+        if o.nil? and o.is_a?(AmberVM::Classes::Null)
+          true
+        else
+          false
+        end
+      end
+      
+      def initialize value
+        super()
+      end
+      
+      def to_s
+        'null'
+      end
+      
+      def is_true?
+        false
+      end
+    end
+  end
+end

data/lib/amber/classes/number.rb

@@ -0,0 +1,95 @@
+module AmberVM
+  module Classes
+    class Number < Class
+      register_for :number
+      @@type = :number
+      
+      # Fix for comparing numbers.
+      # We need to have the values hash here.
+      def hash
+        @value.hash
+      end
+      
+      def eql?(o)
+        if o.is_a?(AmberVM::Classes::Number)
+          @value == o.value
+        elsif o.is_a?(@value.class)
+          @value == o
+        else
+          false
+        end
+      end
+      
+      
+      
+      def initialize value
+        super()
+        if value.is_a? Numeric
+          @value = value
+        elsif value.respond_to?(:to_f) and ((v = value.to_f) != value.to_i)
+          @value = v
+        elsif value.respond_to?(:to_i)
+          @value = value.to_i
+        else
+          @value = "#{value}".to_f
+          if @value == @value.to_i 
+            @value = @value.to_i
+          end
+        end
+      end
+      
+      def == v
+        @value == v
+      end
+      
+      def to_s
+        @value.to_s
+      end
+      
+      def to_i
+        @value.to_i
+      end
+      
+      def to_f
+        @value.to_f
+      end
+      
+      def is_true?
+        @value != 0
+      end
+      
+      def value
+        @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)
+      #end
+      
+      alias :method_missing_number :method_missing
+      
+      def method_missing m, *args, &block
+        if @value.respond_to? m
+          args.map! do |a|
+            if a.is_a? Number
+              a.value
+            else
+              Number.new(a).value
+            end
+          end
+          r = @value.send(m,*args)
+          r = Number.new(r) if r.is_a? Numeric
+          r
+        else
+          #raise "beep!#{m}, #{args}, #{block}" 
+          super(m, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/amber/classes/object.rb

@@ -0,0 +1,56 @@
+module AmberVM
+  module Classes
+    class Object < AmberVM::Classes::Class
+      register_for :object
+      attr_reader :variables
+      attr_reader :object_class
+      
+      def env
+        @env
+      end
+      
+      class VariableProxy
+        def initialize env
+          @env = env
+        end
+        def [] n
+          @env[n]
+        end
+        
+        def []= n,v
+          @env[n] = v
+        end
+        
+        def each &block
+          @env.data[:locals].each(&block)
+        end
+        
+        def keys
+          @env.data[:locals].keys
+        end
+      end
+      
+      
+      def initialize objectClass, parent_env = nil
+        super()
+        @object_class = objectClass
+        @env = AmberVM::Interpreter::Environment.new({:locals => {:self => self}}, parent_env)
+        @variables = VariableProxy.new(@env)
+      end
+
+      
+      def obj_send(method, params, env)
+        m = @variables[method] || @object_class.variables[method]
+        raise "Unknown method #{method} for object #{self}" if not m or not m.respond_to?(:call)
+        AmberVM::debug "Calling object function method #{method}." if $DEBUG
+        env = AmberVM::Interpreter::Environment.new({:params => params||[], :locals => @variables}, env)
+        m.call(params, env)
+      end
+      
+      def data_type
+        :object
+      end
+      
+    end
+  end
+end

data/lib/amber/classes/string.rb

@@ -0,0 +1,79 @@
+module AmberVM
+  module Classes
+    class String < ::String 
+      extend Plugin
+      plugin_host Classes
+      register_for :string
+      @@type = :string
+      ANSI_MAP = {
+        'h' => 1,  'H' => 22, 
+        'u' => 4,  'U' => 24,
+        'f' => 5,  'f' => 25,
+        'i' => 7,  'I' => 27,
+        'n' => 0,
+        'x' => 30, 'X' => 40,
+        'r' => 31, 'R' => 41,
+        'g' => 32, 'G' => 42,
+        'y' => 33, 'Y' => 42,
+        'b' => 34, 'B' => 44,
+        'm' => 35, 'M' => 45,
+        'c' => 36, 'C' => 45,
+        'w' => 37, 'W' => 47,
+      } unless defined?(ANSI_MAP)
+      
+      def initialize val = ""
+        super val.to_s
+      end
+      
+      def is_true?
+        not empty?
+      end
+      
+      def data_type
+        :string
+      end
+      
+      def center width, char = " " 
+        c = char[0..0]
+        c = ' ' if c.empty?
+        width = width.to_i - self.length
+        width = 0 if width < 0
+        l = width / 2
+        r = width - l
+        self.class.new((c*l) + self +  (c*r))
+      end
+      
+      def ljust width, char = " " 
+        c = char[0..0]
+        c = ' ' if c.empty?
+        width = width.to_i - self.length
+        width = 0 if width < 0
+        self.class.new(self +  (c*width))
+      end
+      
+      def rjust width, char = " " 
+        c = char[0..0]
+        c = ' ' if c.empty?
+        width = width.to_i - self.length
+        width = 0 if width < 0
+        self.class.new((c*width) + self)
+      end
+      
+      def + v
+        v = v.to_s if not v.is_a?(String)
+        self.class.new(super(v))
+      end
+      
+      def ansi colorset
+        colorset.gsub!(/[^#{ANSI_MAP.keys.join('')}]/,'')
+        colorcode = colorset.split('').map { |c| ANSI_MAP[c].to_s}.join(';')
+        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/amber/classes.rb

@@ -0,0 +1,113 @@
+# = classes.rb - Class Plugin Library
+#
+# Copyright (C) 2008 Heinz N. Gies (heinz@licenser.net)
+#
+# This file is published under the MIT Licenser, see LICENSE for details.
+#
+
+require 'amber/plugin'
+require 'amber/functions'
+module AmberVM
+  # This module is the basic class container, classes are supposed to be
+  # used by this as in: AmberVM::Classes[<class id>] this guarnatees that,
+  # in the case of overwriting a standard class the code still works.
+  #
+  # == Example
+  #
+  # === Creating a string calss
+  #
+  #   require 'amber/classes'
+  #   string = AmberVM::Classes[:string].new
+  module Classes
+    extend AmberVM::PluginHost
+    default :string
+    
+    # The Parent for new classes, meant never to be used alone.
+    # It takes care of registering the calss to the PluginHost,
+    # as well of basic functionality.
+    #
+    # Also it offers access to the function plugins to be used
+    # as functions within the commands.
+    #
+    # == Examples
+    #
+    # === COMPLEX NUMBERS
+    # 
+    #   # file: amber/classes/math/complex.rb
+    #   require 'amber/classes'
+    #   module AmberVM
+    #     module Classes
+    #       class Complex < AmberVM::Classes::Class
+    #         def initialize i, n
+    #           @i = i
+    #           @j = j
+    #         end
+    #         #...
+    #       end
+    #     end
+    #   end
+    class Class
+      
+      # We make classes a Plugin and set the plugin host to Classes s it can
+      # handle the details for it.
+      extend AmberVM::Plugin
+      plugin_host Classes
+      
+      # Basic functions hash for classes so every class at least can respond
+      # to a +functions+ call.
+      def functions
+        @functions ||= {}
+      end
+      
+      # Basic variables hash for classes so every class at least can respond
+      # to a +variables+ call.
+      def variables
+        @variables ||= {:self => self}
+      end
+      
+      
+      # Every class is by default treated as beeing true when not defined
+      # otherwise.
+      # This makes sure that calling boolean functions on classes will always
+      # return a usefull result.
+      # So it can be redefinde to say, have 0 act as false if this is wanted.
+      def is_true?
+        true
+      end
+      
+      # This defines the type of the class, it defaults to :any
+      # it is important for tying and type conversion, as long as it
+      # behaves like a string, it can look like a sting ;)
+      def data_type
+        :any
+      end
+      
+      def obj_send(method, params, env)
+        @env ||= AmberVM::Interpreter::Environment.new({:params => params||[], :locals => variables, :functions => functions}, env)
+        m = @functions[method]
+        raise "Unknown method #{method} for object #{self}" if not m
+        AmberVM::debug "Calling object function method #{method}."
+        m.call(params, @env)
+      end
+      
+      # Redefinding the method to allow using self defined functions
+      # within classes - while this is discuraged it still is possible.      
+      def method_missing(m, *args, &block)
+        # Check if the functions PluginHost knwos about the called function
+        if (AmberVM::Functions::has? m)
+          # Calls the function with given args and environment that is,
+          # hopefully defiend in the calling class.
+          AmberVM::Functions[m].execute args, @env
+        else
+          # If the function is not known we call the usual method missing 
+          # method.
+          super(m, *args, &block)
+        end
+      end
+    end
+  end
+end
+
+Dir[File.dirname(__FILE__) + '/classes/*.rb'].each do |c|
+  require 'amber/classes/' + File.basename(c)
+end