shoesgem 0.1424.0

data/shoes/ruby/lib/delegate.rb

@@ -0,0 +1,311 @@
+# = delegate -- Support for the Delegation Pattern
+#
+# Documentation by James Edward Gray II and Gavin Sinclair
+#
+# == Introduction
+#
+# This library provides three different ways to delegate method calls to an
+# object.  The easiest to use is SimpleDelegator.  Pass an object to the
+# constructor and all methods supported by the object will be delegated.  This
+# object can be changed later.
+#
+# Going a step further, the top level DelegateClass method allows you to easily
+# setup delegation through class inheritance.  This is considerably more
+# flexible and thus probably the most common use for this library.
+#
+# Finally, if you need full control over the delegation scheme, you can inherit
+# from the abstract class Delegator and customize as needed.  (If you find
+# yourself needing this control, have a look at _forwardable_, also in the
+# standard library.  It may suit your needs better.)
+#
+# == Notes
+#
+# Be advised, RDoc will not detect delegated methods.
+#
+# <b>delegate.rb provides full-class delegation via the
+# DelegateClass() method.  For single-method delegation via
+# def_delegator(), see forwardable.rb.</b>
+#
+# == Examples
+#
+# === SimpleDelegator
+#
+# Here's a simple example that takes advantage of the fact that
+# SimpleDelegator's delegation object can be changed at any time.
+#
+#   class Stats
+#     def initialize
+#       @source = SimpleDelegator.new([])
+#     end
+#     
+#     def stats( records )
+#       @source.__setobj__(records)
+#       	
+#       "Elements:  #{@source.size}\n" +
+#       " Non-Nil:  #{@source.compact.size}\n" +
+#       "  Unique:  #{@source.uniq.size}\n"
+#     end
+#   end
+#   
+#   s = Stats.new
+#   puts s.stats(%w{James Edward Gray II})
+#   puts
+#   puts s.stats([1, 2, 3, nil, 4, 5, 1, 2])
+#
+# <i>Prints:</i>
+#
+#   Elements:  4
+#    Non-Nil:  4
+#     Unique:  4
+# 
+#   Elements:  8
+#    Non-Nil:  7
+#     Unique:  6
+#
+# === DelegateClass()
+#
+# Here's a sample of use from <i>tempfile.rb</i>.
+#
+# A _Tempfile_ object is really just a _File_ object with a few special rules
+# about storage location and/or when the File should be deleted.  That makes for
+# an almost textbook perfect example of how to use delegation.
+#
+#   class Tempfile < DelegateClass(File)
+#     # constant and class member data initialization...
+#   
+#     def initialize(basename, tmpdir=Dir::tmpdir)
+#       # build up file path/name in var tmpname...
+#     
+#       @tmpfile = File.open(tmpname, File::RDWR|File::CREAT|File::EXCL, 0600)
+#     
+#       # ...
+#     
+#       super(@tmpfile)
+#     
+#       # below this point, all methods of File are supported...
+#     end
+#   
+#     # ...
+#   end
+#
+# === Delegator
+#
+# SimpleDelegator's implementation serves as a nice example here.
+#
+#    class SimpleDelegator < Delegator
+#      def initialize(obj)
+#        super             # pass obj to Delegator constructor, required
+#        @delegate_sd_obj = obj    # store obj for future use
+#      end
+# 
+#      def __getobj__
+#        @delegate_sd_obj          # return object we are delegating to, required
+#      end
+# 
+#      def __setobj__(obj)
+#        @delegate_sd_obj = obj    # change delegation object, a feature we're providing
+#      end
+# 
+#      # ...
+#    end
+
+#
+# Delegator is an abstract class used to build delegator pattern objects from
+# subclasses.  Subclasses should redefine \_\_getobj\_\_.  For a concrete
+# implementation, see SimpleDelegator.
+#
+class Delegator
+  [:to_s,:inspect,:=~,:!~,:===].each do |m|
+    undef_method m
+  end
+
+  #
+  # Pass in the _obj_ to delegate method calls to.  All methods supported by
+  # _obj_ will be delegated to.
+  #
+  def initialize(obj)
+    __setobj__(obj)
+  end
+
+  # Handles the magic of delegation through \_\_getobj\_\_.
+  def method_missing(m, *args, &block)
+    begin
+      target = self.__getobj__
+      unless target.respond_to?(m)
+        super(m, *args, &block)
+      else
+        target.__send__(m, *args, &block)
+      end
+    rescue Exception
+      $@.delete_if{|s| %r"\A#{Regexp.quote(__FILE__)}:\d+:in `method_missing'\z"o =~ s}
+      ::Kernel::raise
+    end
+  end
+
+  # 
+  # Checks for a method provided by this the delegate object by fowarding the 
+  # call through \_\_getobj\_\_.
+  # 
+  def respond_to?(m, include_private = false)
+    return true if super
+    return self.__getobj__.respond_to?(m, include_private)
+  end
+
+  # 
+  # Returns true if two objects are considered same.
+  # 
+  def ==(obj)
+    return true if obj.equal?(self)
+    self.__getobj__ == obj
+  end
+
+  #
+  # This method must be overridden by subclasses and should return the object
+  # method calls are being delegated to.
+  #
+  def __getobj__
+    raise NotImplementedError, "need to define `__getobj__'"
+  end
+
+  #
+  # This method must be overridden by subclasses and change the object delegate
+  # to _obj_.
+  #
+  def __setobj__(obj)
+    raise NotImplementedError, "need to define `__setobj__'"
+  end
+
+  # Serialization support for the object returned by \_\_getobj\_\_.
+  def marshal_dump
+    __getobj__
+  end
+  # Reinitializes delegation from a serialized object.
+  def marshal_load(obj)
+    __setobj__(obj)
+  end
+
+  # Clone support for the object returned by \_\_getobj\_\_.
+  def clone
+    new = super
+    new.__setobj__(__getobj__.clone)
+    new
+  end
+  # Duplication support for the object returned by \_\_getobj\_\_.
+  def dup
+    new = super
+    new.__setobj__(__getobj__.dup)
+    new
+  end
+end
+
+#
+# A concrete implementation of Delegator, this class provides the means to
+# delegate all supported method calls to the object passed into the constructor
+# and even to change the object being delegated to at a later time with
+# \_\_setobj\_\_ .
+#
+class SimpleDelegator<Delegator
+  # Returns the current object method calls are being delegated to.
+  def __getobj__
+    @delegate_sd_obj
+  end
+
+  #
+  # Changes the delegate object to _obj_.
+  #
+  # It's important to note that this does *not* cause SimpleDelegator's methods
+  # to change.  Because of this, you probably only want to change delegation
+  # to objects of the same type as the original delegate.
+  #
+  # Here's an example of changing the delegation object.
+  #
+  #   names = SimpleDelegator.new(%w{James Edward Gray II})
+  #   puts names[1]    # => Edward
+  #   names.__setobj__(%w{Gavin Sinclair})
+  #   puts names[1]    # => Sinclair
+  #
+  def __setobj__(obj)
+    raise ArgumentError, "cannot delegate to self" if self.equal?(obj)
+    @delegate_sd_obj = obj
+  end
+end
+
+# :stopdoc:
+def Delegator.delegating_block(mid)
+  lambda do |*args, &block|
+    begin
+      __getobj__.__send__(mid, *args, &block)
+    rescue
+      re = /\A#{Regexp.quote(__FILE__)}:#{__LINE__-2}:/o
+      $!.backtrace.delete_if {|t| re =~ t}
+      raise
+    end
+  end
+end
+# :startdoc:
+
+#
+# The primary interface to this library.  Use to setup delegation when defining
+# your class.
+#
+#   class MyClass < DelegateClass( ClassToDelegateTo )    # Step 1
+#     def initialize
+#       super(obj_of_ClassToDelegateTo)                   # Step 2
+#     end
+#   end
+#
+def DelegateClass(superclass)
+  klass = Class.new(Delegator)
+  methods = superclass.public_instance_methods(true)
+  methods -= ::Delegator.public_instance_methods
+  methods -= [:to_s,:inspect,:=~,:!~,:===]
+  klass.module_eval {
+    def __getobj__  # :nodoc:
+      @delegate_dc_obj
+    end
+    def __setobj__(obj)  # :nodoc:
+      raise ArgumentError, "cannot delegate to self" if self.equal?(obj)
+      @delegate_dc_obj = obj
+    end
+  }
+  klass.module_eval do
+    methods.each do |method|
+      define_method(method, Delegator.delegating_block(method))
+    end
+  end
+  return klass
+end
+
+# :enddoc:
+
+if __FILE__ == $0
+  class ExtArray<DelegateClass(Array)
+    def initialize()
+      super([])
+    end
+  end
+
+  ary = ExtArray.new
+  p ary.class
+  ary.push 25
+  p ary
+  ary.push 42
+  ary.each {|x| p x}
+
+  foo = Object.new
+  def foo.test
+    25
+  end
+  def foo.iter
+    yield self
+  end
+  def foo.error
+    raise 'this is OK'
+  end
+  foo2 = SimpleDelegator.new(foo)
+  p foo2
+  foo2.instance_eval{print "foo\n"}
+  p foo.test == foo2.test	# => true
+  p foo2.iter{[55,true]}        # => true
+  foo2.error			# raise error!
+end

data/shoes/ruby/lib/digest/hmac.rb

@@ -0,0 +1,274 @@
+# = digest/hmac.rb
+#
+# An implementation of HMAC keyed-hashing algorithm
+#
+# == Overview 
+# 
+# This library adds a method named hmac() to Digest classes, which
+# creates a Digest class for calculating HMAC digests.
+#
+# == Examples
+#
+#   require 'digest/hmac'
+#
+#   # one-liner example
+#   puts Digest::HMAC.hexdigest("data", "hash key", Digest::SHA1)
+#
+#   # rather longer one
+#   hmac = Digest::HMAC.new("foo", Digest::RMD160)
+#
+#   buf = ""
+#   while stream.read(16384, buf)
+#     hmac.update(buf)
+#   end
+#
+#   puts hmac.bubblebabble
+#
+# == License
+#
+# Copyright (c) 2006 Akinori MUSHA <knu@iDaemons.org>
+#
+# Documentation by Akinori MUSHA
+#
+# All rights reserved.  You can redistribute and/or modify it under
+# the same terms as Ruby.
+#
+#   $Id: hmac.rb 14881 2008-01-04 07:26:14Z akr $
+#
+
+require 'digest'
+
+module Digest
+  class HMAC < Digest::Class
+    def initialize(key, digester)
+      @md = digester.new
+
+      block_len = @md.block_length
+
+      if key.bytesize > block_len
+        key = @md.digest(key)
+      end
+
+      ipad = Array.new(block_len).fill(0x36)
+      opad = Array.new(block_len).fill(0x5c)
+
+      key.bytes.each_with_index { |c, i|
+        ipad[i] ^= c
+        opad[i] ^= c
+      }
+
+      @key = key.freeze
+      @ipad = ipad.inject('') { |s, c| s << c.chr }.freeze
+      @opad = opad.inject('') { |s, c| s << c.chr }.freeze
+      @md.update(@ipad)
+    end
+
+    def initialize_copy(other)
+      @md = other.instance_eval { @md.clone }
+    end
+
+    def update(text)
+      @md.update(text)
+      self
+    end
+    alias << update
+
+    def reset
+      @md.reset
+      @md.update(@ipad)
+      self
+    end
+
+    def finish
+      d = @md.digest!
+      @md.update(@opad)
+      @md.update(d)
+      @md.digest!
+    end
+    private :finish
+
+    def digest_length
+      @md.digest_length
+    end
+
+    def block_length
+      @md.block_length
+    end
+
+    def inspect
+      sprintf('#<%s: key=%s, digest=%s>', self.class.name, @key.inspect, @md.inspect.sub(/^\#<(.*)>$/) { $1 });
+    end
+  end
+end
+
+if $0 == __FILE__
+  eval DATA.read, nil, $0, __LINE__+4
+end
+
+__END__
+
+require 'test/unit'
+
+module TM_HMAC
+  def test_s_hexdigest
+    cases.each { |h|
+      digesters.each { |d|
+        assert_equal(h[:hexdigest], Digest::HMAC.hexdigest(h[:data], h[:key], d))
+      }
+    }
+  end
+
+  def test_hexdigest
+    cases.each { |h|
+      digesters.each { |d|
+        hmac = Digest::HMAC.new(h[:key], d)
+
+        hmac.update(h[:data])
+
+        assert_equal(h[:hexdigest], hmac.hexdigest)
+      }
+    }
+  end
+
+  def test_reset
+    cases.each { |h|
+      digesters.each { |d|
+        hmac = Digest::HMAC.new(h[:key], d)
+        hmac.update("test")
+        hmac.reset
+        hmac.update(h[:data])
+
+        assert_equal(h[:hexdigest], hmac.hexdigest)
+      }
+    }
+  end
+end  
+
+class TC_HMAC_MD5 < Test::Unit::TestCase
+  include TM_HMAC
+
+  def digesters
+    [Digest::MD5, Digest::MD5.new]
+  end
+
+  # Taken from RFC 2202: Test Cases for HMAC-MD5 and HMAC-SHA-1
+  def cases
+    [
+     {
+       :key		=> "\x0b" * 16,
+       :data		=> "Hi There",
+       :hexdigest	=> "9294727a3638bb1c13f48ef8158bfc9d",
+     }, {
+       :key		=> "Jefe",
+       :data		=> "what do ya want for nothing?",
+       :hexdigest	=> "750c783e6ab0b503eaa86e310a5db738",
+     }, {
+       :key		=> "\xaa" * 16,
+       :data		=> "\xdd" * 50,
+       :hexdigest	=> "56be34521d144c88dbb8c733f0e8b3f6",
+     }, {
+       :key		=> "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
+       :data		=> "\xcd" * 50,
+       :hexdigest	=> "697eaf0aca3a3aea3a75164746ffaa79",
+     }, {
+       :key		=> "\x0c" * 16,
+       :data		=> "Test With Truncation",
+       :hexdigest	=> "56461ef2342edc00f9bab995690efd4c",
+     }, {
+       :key		=> "\xaa" * 80,
+       :data		=> "Test Using Larger Than Block-Size Key - Hash Key First",
+       :hexdigest	=> "6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd",
+     }, {
+       :key		=> "\xaa" * 80,
+       :data		=> "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data",
+       :hexdigest	=> "6f630fad67cda0ee1fb1f562db3aa53e",
+     }
+    ]
+  end
+end
+
+class TC_HMAC_SHA1 < Test::Unit::TestCase
+  include TM_HMAC
+
+  def digesters
+    [Digest::SHA1, Digest::SHA1.new]
+  end
+
+  # Taken from RFC 2202: Test Cases for HMAC-MD5 and HMAC-SHA-1
+  def cases
+    [
+     {
+       :key		=> "\x0b" * 20,
+       :data		=> "Hi There",
+       :hexdigest	=> "b617318655057264e28bc0b6fb378c8ef146be00",
+     }, {
+       :key		=> "Jefe",
+       :data		=> "what do ya want for nothing?",
+       :hexdigest	=> "effcdf6ae5eb2fa2d27416d5f184df9c259a7c79",
+     }, {
+       :key		=> "\xaa" * 20,
+       :data		=> "\xdd" * 50,
+       :hexdigest	=> "125d7342b9ac11cd91a39af48aa17b4f63f175d3",
+     }, {
+       :key		=> "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
+       :data		=> "\xcd" * 50,
+       :hexdigest	=> "4c9007f4026250c6bc8414f9bf50c86c2d7235da",
+     }, {
+       :key		=> "\x0c" * 20,
+       :data		=> "Test With Truncation",
+       :hexdigest	=> "4c1a03424b55e07fe7f27be1d58bb9324a9a5a04",
+     }, {
+       :key		=> "\xaa" * 80,
+       :data		=> "Test Using Larger Than Block-Size Key - Hash Key First",
+       :hexdigest	=> "aa4ae5e15272d00e95705637ce8a3b55ed402112",
+     }, {
+       :key		=> "\xaa" * 80,
+       :data		=> "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data",
+       :hexdigest	=> "e8e99d0f45237d786d6bbaa7965c7808bbff1a91",
+     }
+    ]
+  end
+end
+
+class TC_HMAC_RMD160 < Test::Unit::TestCase
+  include TM_HMAC
+
+  def digesters
+    [Digest::RMD160, Digest::RMD160.new]
+  end
+
+  # Taken from RFC 2286: Test Cases for HMAC-RIPEMD160 and HMAC-RIPEMD128
+  def cases
+    [
+     {
+       :key		=> "\x0b" * 20,
+       :data		=> "Hi There",
+       :hexdigest	=> "24cb4bd67d20fc1a5d2ed7732dcc39377f0a5668",
+     }, {
+       :key		=> "Jefe",
+       :data		=> "what do ya want for nothing?",
+       :hexdigest	=> "dda6c0213a485a9e24f4742064a7f033b43c4069",
+     }, {
+       :key		=> "\xaa" * 20,
+       :data		=> "\xdd" * 50,
+       :hexdigest	=> "b0b105360de759960ab4f35298e116e295d8e7c1",
+     }, {
+       :key		=> "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
+       :data		=> "\xcd" * 50,
+       :hexdigest	=> "d5ca862f4d21d5e610e18b4cf1beb97a4365ecf4",
+     }, {
+       :key		=> "\x0c" * 20,
+       :data		=> "Test With Truncation",
+       :hexdigest	=> "7619693978f91d90539ae786500ff3d8e0518e39",
+     }, {
+       :key		=> "\xaa" * 80,
+       :data		=> "Test Using Larger Than Block-Size Key - Hash Key First",
+       :hexdigest	=> "6466ca07ac5eac29e1bd523e5ada7605b791fd8b",
+     }, {
+       :key		=> "\xaa" * 80,
+       :data		=> "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data",
+       :hexdigest	=> "69ea60798d71616cce5fd0871e23754cd75d5a0a",
+     }
+    ]
+  end
+end

data/shoes/ruby/lib/digest/sha2.rb

@@ -0,0 +1,74 @@
+#--
+# sha2.rb - defines Digest::SHA2 class which wraps up the SHA256,
+#           SHA384, and SHA512 classes.
+#++
+# Copyright (c) 2006 Akinori MUSHA <knu@iDaemons.org>
+#
+# All rights reserved.  You can redistribute and/or modify it under the same
+# terms as Ruby.
+#
+#   $Id: sha2.rb 24475 2009-08-08 15:35:43Z yugui $
+
+require 'digest'
+require 'digest/sha2.so'
+
+module Digest
+  #
+  # A meta digest provider class for SHA256, SHA384 and SHA512.
+  #
+  class SHA2 < Digest::Class
+    # call-seq:
+    #     Digest::SHA2.new(bitlen = 256) -> digest_obj
+    #
+    # Creates a new SHA2 hash object with a given bit length.
+    def initialize(bitlen = 256)
+      case bitlen
+      when 256
+        @sha2 = Digest::SHA256.new
+      when 384
+        @sha2 = Digest::SHA384.new
+      when 512
+        @sha2 = Digest::SHA512.new
+      else
+        raise ArgumentError, "unsupported bit length: %s" % bitlen.inspect
+      end
+      @bitlen = bitlen
+    end
+
+    # :nodoc:
+    def reset
+      @sha2.reset
+      self
+    end
+
+    # :nodoc:
+    def update(str)
+      @sha2.update(str)
+      self
+    end
+    alias << update
+
+    def finish
+      @sha2.digest!
+    end
+    private :finish
+
+    def block_length
+      @sha2.block_length
+    end
+
+    def digest_length
+      @sha2.digest_length
+    end
+
+    # :nodoc:
+    def initialize_copy(other)
+      @sha2 = other.instance_eval { @sha2.clone }
+    end
+
+    # :nodoc:
+    def inspect
+      "#<%s:%d %s>" % [self.class.name, @bitlen, hexdigest]
+    end
+  end
+end

data/shoes/ruby/lib/digest.rb

@@ -0,0 +1,50 @@
+require 'digest.so'
+
+module Digest
+  def self.const_missing(name)
+    case name
+    when :SHA256, :SHA384, :SHA512
+      lib = 'digest/sha2.so'
+    else
+      lib = File.join('digest', name.to_s.downcase)
+    end
+
+    begin
+      require lib
+    rescue LoadError => e
+      raise LoadError, "library not found for class Digest::#{name} -- #{lib}", caller(1)
+    end
+    unless Digest.const_defined?(name)
+      raise NameError, "uninitialized constant Digest::#{name}", caller(1)
+    end
+    Digest.const_get(name)
+  end
+
+  class ::Digest::Class
+    # creates a digest object and reads a given file, _name_.
+    # 
+    #  p Digest::SHA256.file("X11R6.8.2-src.tar.bz2").hexdigest
+    #  # => "f02e3c85572dc9ad7cb77c2a638e3be24cc1b5bea9fdbb0b0299c9668475c534"
+    def self.file(name)
+      new.file(name)
+    end
+  end
+
+  module Instance
+    # updates the digest with the contents of a given file _name_ and
+    # returns self.
+    def file(name)
+      File.open(name, "rb") {|f|
+        buf = ""
+        while f.read(16384, buf)
+          update buf
+        end
+      }
+      self
+    end
+  end
+end
+
+def Digest(name)
+  Digest.const_get(name)
+end