backports 1.15.0 → 1.16.1

data/CHANGELOG.rdoc

@@ -1,5 +1,14 @@
 = Packable --- History
 
+== Version 1.16.1 - April 11th, 2010
+
+* Added a features of 1.9.2:
+
+  * Array#uniq, #uniq! (with block)
+  * Dir.home
+  * Hash#keep_if, select!
+  * Random (new class)
+
 == Version 1.15.0 - March 23rd, 2010
 
 * Added a features of 1.9.2:

data/README.rdoc

@@ -104,12 +104,16 @@ but since it is only an imitation, it must be required explicitly:
 
 == Ruby 1.9.2
 
-  Finally, some Ruby 1.9.2 features have been backported. As this version has not been feature frozen yet, changes are still possible.
+  Finally, most of Ruby 1.9.2 features have been backported. As this version has not been feature frozen yet, changes are still possible.
 
 * Array
   * <tt>rotate, rotate!</tt>
   * <tt>keep_if, select!</tt>
   * <tt>sort_by!</tt>
+  * <tt>uniq, #uniq!</tt> (with block)
+
+* Dir
+  * +home+
 
 * Enumerable
   * +chunk+
@@ -119,10 +123,15 @@ but since it is only an imitation, it must be required explicitly:
 
 * Float::INFINITY, NAN
 
+* Hash
+  * +keep_if+, <tt>select!</tt>
+
 * Object
   * <tt>respond_to_missing?</tt>
   * <tt>singleton_class</tt>
 
+* Random (new class)
+
 To include all Ruby backports but not those of Rails, <tt>require "backports/1.9.2"</tt> (or "backports/1.9")
 
 == Rails

data/Rakefile

@@ -17,13 +17,11 @@ begin
     gem.rdoc_options << '--title' << 'Backports library' <<
                            '--main' << 'README.rdoc' <<
                            '--line-numbers' << '--inline-source'
-
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
     gem.rubyforge_project = "backports"
-    Jeweler::GemcutterTasks.new
   end
+  Jeweler::GemcutterTasks.new
 rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
 end
 
 require 'rake/testtask'

data/VERSION.yml

@@ -1,5 +1,5 @@
 --- 
 :major: 1
 :build: 
-:minor: 15
-:patch: 0
+:minor: 16
+:patch: 1

data/backports.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{backports}
-  s.version = "1.15.0"
+  s.version = "1.16.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Marc-Andr\303\251 Lafortune"]
-  s.date = %q{2010-03-23}
+  s.date = %q{2010-04-11}
   s.description = %q{      Essential backports that enable some of the really nice features of ruby 1.8.7, ruby 1.9 and rails from ruby 1.8.6 and earlier.
 }
   s.email = %q{github@marc-andre.ca}
@@ -75,11 +75,18 @@ Gem::Specification.new do |s|
      "lib/backports/1.9.1/symbol.rb",
      "lib/backports/1.9.2.rb",
      "lib/backports/1.9.2/array.rb",
+     "lib/backports/1.9.2/dir.rb",
      "lib/backports/1.9.2/enumerable.rb",
      "lib/backports/1.9.2/float.rb",
+     "lib/backports/1.9.2/hash.rb",
      "lib/backports/1.9.2/kernel.rb",
      "lib/backports/1.9.2/match_data.rb",
      "lib/backports/1.9.2/method.rb",
+     "lib/backports/1.9.2/random.rb",
+     "lib/backports/1.9.2/random/MT19937.rb",
+     "lib/backports/1.9.2/random/bits_and_bytes.rb",
+     "lib/backports/1.9.2/random/implementation.rb",
+     "lib/backports/1.9.2/random/load.rb",
      "lib/backports/1.9.rb",
      "lib/backports/basic_object.rb",
      "lib/backports/rails.rb",

data/lib/backports/1.8.7/array.rb

@@ -1,7 +1,7 @@
 class Array
   # Standard in Ruby 1.8.7+. See official documentation[http://ruby-doc.org/core-1.9/classes/Array.html]
   def combination(num)
-    num = Backports.coerce_to num, Fixnum, :to_int
+    num = Backports.coerce_to_int(num)
     return to_enum(:combination, num) unless block_given?
     return self unless (0..size).include? num
     # Implementation note: slightly tricky.
@@ -24,7 +24,7 @@ class Array
     if n.nil?
       loop(&block)
     else
-      n = Backports.coerce_to n, Fixnum, :to_int
+      n = Backports.coerce_to_int(n)
       n.times{each(&block)}
     end
     nil
@@ -46,7 +46,7 @@ class Array
     # made, returns nil, otherwise self.
     # Adapted from rubinius'
     def flatten_with_optional_argument!(level=-1)
-      level = Backports.coerce_to(level, Integer, :to_int)
+      level = Backports.coerce_to_int(level)
       return flatten_without_optional_argument! unless level >= 0
 
       ret, out = nil, []
@@ -95,7 +95,7 @@ class Array
     return to_enum(:permutation, num) unless block_given?
     num = num.equal?(Backports::Undefined) ?
           size :
-          Backports.coerce_to(num, Fixnum, :to_int)
+          Backports.coerce_to_int(num)
     return self unless (0..size).include? num
 
     final_lambda = lambda do |partial, remain|
@@ -119,7 +119,7 @@ class Array
   unless ([1].pop(1) rescue false)
     def pop_with_optional_argument(n = Backports::Undefined)
       return pop_without_optional_argument if n == Backports::Undefined
-      n = Backports.coerce_to(n, Fixnum, :to_int)
+      n = Backports.coerce_to_int(n)
       raise ArgumentError, "negative array size" if n < 0
       first = size - n
       first = 0 if first < 0
@@ -136,7 +136,7 @@ class Array
     #
     result = []
 
-    arg.map!{|x| Backports.coerce_to(x, Array, :to_ary)}
+    arg.map!(&Backports.method(:coerce_to_ary))
     arg.reverse! # to get the results in the same order as in MRI, vary the last argument first
     arg.push self
 
@@ -167,7 +167,7 @@ class Array
   # Note: was named #choice in 1.8.7 and renamed in later versions
   def sample(n = Backports::Undefined)
     return self[Kernel.rand(size)] if n == Backports::Undefined
-    n = Backports.coerce_to(n, Fixnum, :to_int)
+    n = Backports.coerce_to_int(n)
     raise ArgumentError, "negative array size" if n < 0
     n = size if n > size
     result = Array.new(self)
@@ -183,7 +183,7 @@ class Array
   unless ([1].shift(1) rescue false)
     def shift_with_optional_argument(n = Backports::Undefined)
       return shift_without_optional_argument if n == Backports::Undefined
-      n = Backports.coerce_to(n, Fixnum, :to_int)
+      n = Backports.coerce_to_int(n)
       raise ArgumentError, "negative array size" if n < 0
       slice!(0, n)
     end

data/lib/backports/1.8.7/enumerable.rb

@@ -17,7 +17,7 @@ module Enumerable
   def cycle(n = nil, &block)
     return to_enum(:cycle, n) unless block_given?
     return loop(&block) if nil == n
-    n = Backports.coerce_to(n, Fixnum, :to_int)
+    n = Backports.coerce_to_int(n)
     if n >= 1
       cache = []
       each do |elem|
@@ -35,7 +35,7 @@ module Enumerable
   
   # Standard in Ruby 1.8.7+. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
   def drop(n)
-    n = Backports.coerce_to(n, Fixnum, :to_int)
+    n = Backports.coerce_to_int(n)
     raise ArgumentError, "attempt to drop negative size" if n < 0
     ary = to_a
     return [] if n > ary.size
@@ -198,7 +198,7 @@ module Enumerable
   
   # Standard in Ruby 1.8.7+. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
   def take(n)
-    n = Backports.coerce_to(n, Fixnum, :to_int)
+    n = Backports.coerce_to_int(n)
     raise ArgumentError, "attempt to take negative size: #{n}" if n < 0
     [].tap do |array|
       each do |elem|

data/lib/backports/1.8.8/array.rb

@@ -3,7 +3,7 @@ class Array
   class << self
     def self.try_convert(obj)
       return nil unless obj.respond_to?(:to_ary)
-      Backports.coerce_to(obj, Array, :to_ary)
+      Backports.coerce_to_ary(obj)
     end unless method_defined? :try_convert
   end
 end

data/lib/backports/1.8.8/regexp.rb

@@ -3,7 +3,7 @@ class Regexp
   class << self
     def self.try_convert(obj)
       return nil unless obj.respond_to?(:to_regexp)
-      Backports.coerce_to(obj, Array, :to_regexp)
+      Backports.coerce_to(obj, Regexp, :to_regexp)
     end unless method_defined? :try_convert
   end
 end

data/lib/backports/1.9.2/array.rb

@@ -24,5 +24,27 @@ class Array
     return to_enum(:sort_by!) unless block_given?
     replace sort_by(&block)
   end unless method_defined? :sort_by!
+
+  unless [1,2].uniq!{}
+    def uniq_with_block!(&block)
+      return uniq_without_block! unless block_given?
+      u = uniq(&block)
+      replace u unless u.size == size
+    end
+    Backports.alias_method_chain self, :uniq!, :block
+  end
+
+  unless [1,2].uniq{}.size == 1
+    def uniq_with_block
+      return uniq_without_block unless block_given?
+      h = {}
+      each do |elem|
+        h[yield(elem)] ||= elem
+      end
+      h.values
+    end
+    Backports.alias_method_chain self, :uniq, :block
+  end
+
 end
     

data/lib/backports/1.9.2/dir.rb

@@ -0,0 +1,5 @@
+class << Dir
+  def home(user = "")
+    File.expand_path "~#{user}"
+  end unless method_defined? :home
+end

data/lib/backports/1.9.2/hash.rb

@@ -0,0 +1,11 @@
+class Hash
+  def keep_if
+    return to_enum(:keep_if) unless block_given?
+    delete_if{|key, value| ! yield key, value}
+  end unless method_defined? :keep_if
+
+  def select!(&block)
+    return to_enum(:select!) unless block_given?
+    reject!{|key, value| ! yield key, value}
+  end unless method_defined? :select!
+end

data/lib/backports/1.9.2/random.rb

@@ -0,0 +1 @@
+autoload :Random, File.expand_path(File.dirname(__FILE__) + "/random/load")

data/lib/backports/1.9.2/random/MT19937.rb

@@ -0,0 +1,78 @@
+class Random
+  # An implementation of Mersenne Twister MT19937 in Ruby
+  class MT19937
+    STATE_SIZE = 624
+    LAST_STATE = STATE_SIZE - 1
+    PAD_32_BITS = 0xffffffff
+
+    attr_reader :state, :last_read
+
+    # See seed=
+    def initialize(seed)
+      self.seed = seed
+    end
+
+    LAST_31_BITS = 0x7fffffff
+    OFFSET = 397
+    
+    # Generates a completely new state out of the previous one.
+    def next_state
+      STATE_SIZE.times do |i|
+        mix = @state[i] & 0x80000000 | @state[i+1 - STATE_SIZE] & 0x7fffffff
+        @state[i] = @state[i+OFFSET - STATE_SIZE] ^ (mix >> 1)
+        @state[i] ^= 0x9908b0df if mix.odd?
+      end
+      @last_read = -1
+    end
+
+    # Seed must be either an Integer (only the first 32 bits will be used)
+    # or an Array of Integers (of which only the first 32 bits will be used)
+    #
+    # No conversion or type checking is done at this level
+    def seed=(seed)
+      case seed
+      when Integer
+        @state = Array.new(STATE_SIZE)
+        @state[0] = seed & PAD_32_BITS
+        (1..LAST_STATE).each do |i|
+          @state[i] = (1812433253 * (@state[i-1]  ^ @state[i-1]>>30) + i)& PAD_32_BITS
+        end
+        @last_read = LAST_STATE
+      when Array
+        self.seed = 19650218
+        i=1
+        j=0
+        [STATE_SIZE, seed.size].max.times do
+          @state[i] = (@state[i] ^ (@state[i-1] ^ @state[i-1]>>30) * 1664525) + j + seed[j] & PAD_32_BITS
+          if (i+=1) >= STATE_SIZE
+            @state[0] = @state[-1]
+            i = 1
+          end
+          j = 0 if (j+=1) >= seed.size
+        end
+        (STATE_SIZE-1).times do
+          @state[i] = (@state[i] ^ (@state[i-1] ^ @state[i-1]>>30) * 1566083941) - i & PAD_32_BITS
+          if (i+=1) >= STATE_SIZE
+            @state[0] = @state[-1]
+            i = 1
+          end
+        end
+        @state[0] = 0x80000000
+      else
+        raise ArgumentError, "Seed must be an Integer or an Array"
+      end
+    end
+
+    # Returns a random Integer from the range 0 ... (1 << 32)
+    def random_32_bits
+      next_state if @last_read >= LAST_STATE
+      @last_read += 1
+      y = @state[@last_read]
+      # Tempering
+      y ^= (y >> 11)
+      y ^= (y << 7) & 0x9d2c5680
+      y ^= (y << 15) & 0xefc60000
+      y ^= (y >> 18)
+    end
+  end
+end  

data/lib/backports/1.9.2/random/bits_and_bytes.rb

@@ -0,0 +1,73 @@
+class Random
+  # Supplement the MT19937 class with methods to do
+  # conversions the same way as MRI.
+  # No argument checking is done here either.
+
+  class MT19937
+    FLOAT_FACTOR = 1.0/9007199254740992.0
+    # generates a random number on [0,1) with 53-bit resolution
+    def random_float
+      ((random_32_bits >> 5) * 67108864.0 + (random_32_bits >> 6)) * FLOAT_FACTOR;
+    end
+
+    # Returns an integer within 0...upto
+    def random_integer(upto)
+      n = upto - 1
+      nb_full_32 = 0
+      while n > PAD_32_BITS
+        n >>= 32
+        nb_full_32 += 1
+      end
+      mask = mask_32_bits(n)
+      begin
+        rand = random_32_bits & mask
+        nb_full_32.times do
+          rand <<= 32
+          rand |= random_32_bits
+        end
+      end until rand < upto
+      rand
+    end
+
+    def random_bytes(nb)
+      nb_32_bits = (nb + 3) / 4
+      random = nb_32_bits.times.map { random_32_bits }
+      random.pack("L" * nb_32_bits)[0, nb]
+    end
+
+    def to_bignum
+      b = 0
+      state.each_with_index do |val, i|
+        b |= val << (32 * i)
+      end
+      b
+    end
+
+    # Convert an Integer seed of arbitrary size to either a single 32 bit integer, or an Array of 32 bit integers
+    def self.convert_seed(seed)
+      seed = seed.abs
+      long_values = []
+      begin
+        long_values << (seed & PAD_32_BITS)
+        seed >>= 32
+      end until seed == 0
+
+      long_values.pop if long_values[-1] == 1 && long_values.size > 1 # Done to allow any kind of sequence of integers
+
+      long_values.size > 1 ? long_values : long_values.first
+    end
+
+    def self.[](seed)
+      new(convert_seed(seed))
+    end
+
+  private
+    MASK_BY = [1,2,4,8,16]
+    def mask_32_bits(n)
+      MASK_BY.each do |shift|
+        n |= n >> shift
+      end
+      n
+    end
+  end
+end

data/lib/backports/1.9.2/random/implementation.rb

@@ -0,0 +1,87 @@
+class Random
+  # Implementation corresponding to the actual Random class of Ruby
+  # The actual random generator (mersenne twister) is in MT19937.
+  # Ruby specific conversions are handled in bits_and_bytes.
+  # The high level stuff (argument checking) is done here.
+  #
+  module Implementation
+    attr_reader :seed
+
+    def initialize(seed = 0)
+      super()
+      srand(seed)
+    end
+
+    def srand(new_seed = 0)
+      new_seed = Backports.coerce_to_int(new_seed)
+      old, @seed = @seed, new_seed.nonzero? || Random.new_seed
+      @mt = MT19937[ @seed ]
+      old
+    end
+
+    def rand(limit = Backports::Undefined)
+      case limit
+        when Backports::Undefined
+          @mt.random_float
+        when Float
+          limit * @mt.random_float unless limit <= 0
+        when Range
+          _rand_range(limit)
+        else
+          limit = Backports.coerce_to_int(limit)
+          @mt.random_integer(limit) unless limit <= 0
+      end || raise(ArgumentError, "invalid argument #{limit}")
+    end
+
+    def bytes(nb)
+      nb = Backports.coerce_to_int(nb)
+      raise ArgumentError, "negative size" if nb < 0
+      @mt.random_bytes(nb)
+    end
+
+    def ==(other)
+      other.is_a?(Random) &&
+        seed == other.seed &&
+        left == other.send(:left) &&
+        state == other.send(:state)
+    end
+
+  private
+    def state
+      @mt.to_bignum
+    end
+
+    def left
+      MT19937::STATE_SIZE - @mt.last_read
+    end
+
+    def _rand_range(limit)
+      if limit.end.is_a?(Float)
+        from = Backports.coerce_to(limit.begin, Float, :to_f)
+        to = limit.end
+        range = to - from
+        if range < 0
+          nil
+        elsif limit.exclude_end?
+          from + @mt.random_float * range unless range <= 0
+        else
+          # cheat a bit... this will reduce the nb of random bits
+          loop do
+            r = @mt.random_float * range * 1.0001
+            break from + r unless r > range
+          end
+        end
+      else
+        from, to = [limit.begin, limit.end].map(&Backports.method(:coerce_to_int))
+        to += 1 unless limit.exclude_end?
+        range = to - from
+        from + @mt.random_integer(range) unless range <= 0
+      end
+    end
+  end
+
+  def self.new_seed
+    Kernel::srand # use the built-in seed generator
+    Kernel::srand # return the generated seed
+  end
+end

data/lib/backports/1.9.2/random/load.rb

@@ -0,0 +1,11 @@
+require_relative "MT19937"
+require_relative "bits_and_bytes"
+require_relative "implementation"
+
+class Random
+  include Implementation
+  class << self
+    include Implementation
+  end
+  srand
+end

data/lib/backports/tools.rb

@@ -145,6 +145,14 @@ module Backports
     ret
   end
 
+  def self.coerce_to_int(obj)
+    coerce_to(obj, Integer, :to_int)
+  end
+
+  def self.coerce_to_ary(obj)
+    coerce_to(obj, Array, :to_ary)
+  end
+
   # Checks for a failed comparison (in which case it throws an ArgumentError)
   # Additionally, it maps any negative value to -1 and any positive value to +1
   # (from Rubinius)

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 1
-  - 15
-  - 0
-  version: 1.15.0
+  - 16
+  - 1
+  version: 1.16.1
 platform: ruby
 authors: 
 - "Marc-Andr\xC3\xA9 Lafortune"
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-23 00:00:00 -04:00
+date: 2010-04-11 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -85,11 +85,18 @@ files:
 - lib/backports/1.9.1/symbol.rb
 - lib/backports/1.9.2.rb
 - lib/backports/1.9.2/array.rb
+- lib/backports/1.9.2/dir.rb
 - lib/backports/1.9.2/enumerable.rb
 - lib/backports/1.9.2/float.rb
+- lib/backports/1.9.2/hash.rb
 - lib/backports/1.9.2/kernel.rb
 - lib/backports/1.9.2/match_data.rb
 - lib/backports/1.9.2/method.rb
+- lib/backports/1.9.2/random.rb
+- lib/backports/1.9.2/random/MT19937.rb
+- lib/backports/1.9.2/random/bits_and_bytes.rb
+- lib/backports/1.9.2/random/implementation.rb
+- lib/backports/1.9.2/random/load.rb
 - lib/backports/1.9.rb
 - lib/backports/basic_object.rb
 - lib/backports/rails.rb