rubinius-core-api 0.0.1-java

data/README.txt

@@ -0,0 +1,20 @@
+This is an attempt to provide some of Rubinius's additional core classes on
+other implementations.
+
+Rubinius has all the normal Ruby classes, but to support implementing them
+mostly in Ruby, they have added a number of other support classes. This
+library hopes to implement those additional support classes for other Ruby
+implementations, so they their utility can be shared across implementations.
+
+Currently, only the following classes are implemented, and only on JRuby:
+
+Rubinius::ByteArray - a fixed-size array of bytes
+Rubinius::Channel - a low-level synchronization mechanism
+Rubinius::EnvironmentAccess - env variable support
+Rubinius::Tuple - a fixed-size array of object references
+Rubinius::Type - utilities for type conversions
+
+In addition, some utility methods added to Thread for recursive guards and
+Kernel::StringValue are also implemented.
+
+More APIs will be added over time.

data/Rakefile

@@ -0,0 +1,36 @@
+task :default => :spec
+
+if defined?(JRUBY_VERSION)
+  require 'ant'
+
+  directory "pkg/classes"
+
+  desc "Clean up build artifacts"
+  task :clean do
+    rm_rf "pkg/classes"
+    rm_rf "lib/rubinius-core-api.jar"
+  end
+
+  desc "Compile the extension"
+  task :compile => "pkg/classes" do |t|
+    ant.javac :srcdir => "src", :destdir => t.prerequisites.first,
+      :source => "1.5", :target => "1.5", :debug => true,
+      :classpath => "${java.class.path}:${sun.boot.class.path}"
+  end
+
+  desc "Build the jar"
+  task :jar => :compile do
+    ant.jar :basedir => "pkg/classes", :destfile => "lib/rubinius-core-api.jar", :includes => "**/*.class"
+  end
+ 
+  task :package => :jar
+elsif defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+  task :package do
+    # nop
+  end
+end
+
+desc "Run the specs"
+task :spec => :package do
+  ruby "-S", "rspec", "spec"
+end

data/lib/rubinius/core-api.rb

@@ -0,0 +1,16 @@
+if defined?(JRUBY_VERSION)
+  begin
+    require 'rubinius-core-api.jar'
+  rescue LoadError
+    # keep going; might be bundled into classpath already
+  end
+  
+  # for access to JRuby runtime
+  require 'jruby'
+  
+  org.jruby.ext.rubinius.RubiniusLibrary.new.load(JRuby.runtime, false)
+elsif defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+  # do nothing for Rubinius
+else
+  raise "Only supported on JRuby and Rubinius"
+end

data/lib/rubinius/kernel/bootstrap/channel.rb

@@ -0,0 +1,106 @@
+##
+# Channel is a FIFO, thread-aware value passing class that can hold any number
+# of objects similar to Queue.  Use #send to add objects to the channel and
+# #receive to remove objects from the channel.
+#
+# If Channel#receive is called on an empty channel, the VM puts the current
+# Thread (t1) to sleep.  At some future time, when Channel#send is called on
+# that same thread, the VM wakes up t1 and the value passed to #send is
+# returned.  This allows us to implement all manner of Thread semantics, such
+# as Mutex.
+#
+# Channel is used heavily by Scheduler, to allow ruby code to interact with
+# the outside world in a thread aware manner.
+
+module Rubinius
+  class Channel
+
+    ##
+    # Returns nil if nothing is waiting, or a List object which contains all
+    # Thread objects waiting on this Channel.
+
+    attr_reader :waiting
+
+    ##
+    # Returns nil if there are no values, otherwise a List object containing all
+    # values the Channel contains.
+
+    attr_reader :value
+
+    ##
+    # Creates a new Channel and registers it with the VM.
+
+    def self.new
+      Ruby.primitive :channel_new
+      raise PrimitiveFailure, "Channel.new primitive failed"
+    end
+
+    # We must be sure a Channel is always created properly, so handle
+    # this the same as new.
+    def self.allocate
+      Ruby.primitive :channel_new
+      raise PrimitiveFailure, "Channel.new primitive failed"
+    end
+
+    ##
+    # Puts +obj+ in the Channel.  If there are waiting threads the first thread
+    # will be woken up and handed +obj+.
+
+    def send(obj)
+      Ruby.primitive :channel_send
+      raise PrimitiveFailure, "Channel#send primitive failed"
+    end
+
+    alias_method :<<, :send
+
+    ##
+    # Removes and returns the first value from the Channel.  If the channel
+    # is empty, Thread.current is put to sleep until #send is called.
+
+    def receive
+      Ruby.primitive :channel_receive
+      raise PrimitiveFailure, "Channel#receive primitive failed"
+    end
+
+    def receive_timeout(duration)
+      Ruby.primitive :channel_receive_timeout
+      raise PrimitiveFailure, "Channel#receive_timeout primitive failed"
+    end
+
+    def try_receive
+      Ruby.primitive :channel_try_receive
+      raise PrimitiveFailure, "Channel#try_receive primitive failed"
+    end
+
+    ##
+    # Converts +obj+ into a Channel using #to_channel.
+
+    def self.convert_to_channel(obj)
+      return obj if Channel === obj
+      begin
+        o2 = obj.to_channel
+        unless Channel === o2
+          raise ArgumentError, "to_channel on #{obj.inspect} did not return a Channel"
+        end
+        return o2
+      rescue NoMethodError
+         raise ArgumentError, "Unable to convert #{obj.inspect} into a channel"
+      end
+    end
+
+    ##
+    # Legacy API. To be removed.
+
+    def self.receive(obj) # :nodoc:
+      return convert_to_channel(obj).receive
+    end
+
+    ##
+    # API compliance, returns self.
+
+    def to_channel
+      self
+    end
+
+  end
+end

data/lib/rubinius/kernel/common/bytearray.rb

@@ -0,0 +1,26 @@
+##
+# An array of bytes, used as a low-level data store for implementing various
+# other classes.
+
+class Rubinius::ByteArray
+  alias_method :[], :get_byte
+  alias_method :[]=, :set_byte
+
+  def each
+    i = 0
+    max = size()
+
+    while i < max
+      yield get_byte(i)
+      i += 1
+    end
+  end
+
+  def inspect
+    "#<#{self.class}:0x#{object_id.to_s(16)} #{size} bytes>"
+  end
+
+  def <=>(other)
+    compare_bytes other, size, other.size
+  end
+end

data/lib/rubinius/kernel/common/channel.rb

@@ -0,0 +1,21 @@
+##
+# A communication mechanism based on pi-calculus channels used primarily to
+# communicate between ruby and the VM about events.
+
+module Rubinius
+  class Channel
+    def inspect
+      "#<Rubinius::Channel>"
+    end
+
+    def as_lock(val=nil)
+      receive
+
+      begin
+        yield
+      ensure
+        self << val
+      end
+    end
+  end
+end

data/lib/rubinius/kernel/common/env.rb

@@ -0,0 +1,239 @@
+##
+# Interface to process environment variables.
+
+module Rubinius
+  class EnvironmentVariables
+    include Enumerable
+    include Rubinius::EnvironmentAccess
+
+    def [](key)
+      getenv(StringValue(key)).freeze
+    end
+
+    def []=(key, value)
+      key = StringValue(key)
+      if value.nil?
+        unsetenv(key)
+      else
+        setenv key, StringValue(value), 1
+      end
+      value
+    end
+
+    alias_method :store, :[]=
+
+    def each_key
+      return to_enum(:each_key) unless block_given?
+
+      each { |k, v| yield k }
+    end
+
+    def each_value
+      return to_enum(:each_value) unless block_given?
+
+      each { |k, v| yield v }
+    end
+
+    def each
+      return to_enum(:each) unless block_given?
+
+      env = environ()
+      ptr_size = FFI.type_size FFI.find_type(:pointer)
+
+      i = 0
+
+      offset = 0
+      cur = env + offset
+
+      until cur.read_pointer.null?
+        entry = cur.read_pointer.read_string
+        key, value = entry.split '=', 2
+        value.taint if value
+        key.taint if key
+
+        yield key, value
+
+        offset += ptr_size
+        cur = env + offset
+      end
+
+      self
+    end
+
+    alias_method :each_pair, :each
+
+    def delete(key)
+      existing_value = self[key]
+      self[key] = nil if existing_value
+      existing_value
+    end
+
+    def delete_if(&block)
+      return to_enum(:delete_it) unless block_given?
+      reject!(&block)
+      self
+    end
+
+    def fetch(key, absent=undefined)
+      if block_given? and !absent.equal?(undefined)
+        warn "block supersedes default value argument"
+      end
+
+      if value = self[key]
+        return value
+      end
+
+      if block_given?
+        return yield(key)
+      elsif absent.equal?(undefined)
+        raise IndexError, "key not found"
+      end
+
+      return absent
+    end
+
+    def include?(key)
+      !self[key].nil?
+    end
+
+    alias_method :has_key?, :include?
+    alias_method :key?, :include?
+    # More efficient than using the one from Enumerable
+    alias_method :member?, :include?
+
+    def to_s
+      "ENV"
+    end
+
+    def inspect
+      to_hash.inspect
+    end
+
+    def reject(&block)
+      to_hash.reject(&block)
+    end
+
+    def reject!
+      return to_enum(:reject!) unless block_given?
+
+      rejected = false
+      each do |k, v|
+        if yield(k, v)
+          delete k
+          rejected = true
+        end
+      end
+
+      rejected ? self : nil
+    end
+
+    def clear
+      # Avoid deleting from environ while iterating because the
+      # OS can handle that in a million different bad ways.
+
+      keys = []
+      each { |k,v| keys << k }
+      keys.each { |k| delete k }
+
+      self
+    end
+
+    def has_value?(value)
+      each { |k,v| return true if v == value }
+      return false
+    end
+
+    alias_method :value?, :has_value?
+
+    def values_at(*params)
+      params.map{ |k| self[k] }
+    end
+
+    def index(value)
+      each do |k, v|
+        return k if v == value
+      end
+      nil
+    end
+
+    def invert
+      to_hash.invert
+    end
+
+    def keys
+      keys = []
+      each { |k,v| keys << k }
+      keys
+    end
+
+    def values
+      vals = []
+      each { |k,v| vals << v }
+      vals
+    end
+
+    def empty?
+      each { return false }
+      return true
+    end
+
+    def length
+      sz = 0
+      each { |k,v| sz += 1 }
+      sz
+    end
+
+    alias_method :size, :length
+
+    def rehash
+      # No need to do anything, our keys are always strings
+    end
+
+    def replace(other)
+      clear
+      other.each { |k, v| self[k] = v }
+    end
+
+    def shift
+      env = environ()
+      ptr_size = FFI.type_size FFI.find_type(:pointer)
+
+      offset = 0
+      cur = env + offset
+
+      ptr = cur.read_pointer
+      return nil unless ptr
+
+      key, value = ptr.read_string.split "=", 2
+
+      return nil unless key
+
+      key.taint if key
+      value.taint if value
+
+      delete key
+
+      return [key, value]
+    end
+
+    def to_a
+      ary = []
+      each { |k,v| ary << [k,v] }
+      ary
+    end
+
+    def to_hash
+      return environ_as_hash()
+    end
+
+    def update(other, &block)
+      if block_given?
+        other.each { |k, v| self[k] = yield(k, self[k], v) }
+      else
+        other.each { |k, v| self[k] = v }
+      end
+    end
+
+    # Missing and deprecated: indexes, indices
+  end
+end