sidekick-client 0.1.0

data/lib/ext/eventmachine-0.12.10/web/whatis

@@ -0,0 +1,7 @@
+EventMachine is a library for Ruby, C++, and Java programs. It provides event-driven I/O using the Reactor pattern.
+
+EventMachine is designed to simultaneously meet two key needs:
+- Extremely high scalability, performance and stability for the most demanding production environments; and
+- An API that <i>eliminates</i> the complexities of high-performance threaded network programming, allowing engineers to concentrate on their application logic.
+
+This unique combination makes EventMachine a premier choice for designers of critical networked applications, including web servers and proxies, email and IM production systems, authentication/authorization processors, and many more.

data/lib/ext/misc/README

@@ -0,0 +1 @@
+Miscellaneous libraries, non-gems, etc, go here

data/lib/ext/misc/indifferent_access.rb

@@ -0,0 +1,131 @@
+# This class has dubious semantics and we only have it so that
+# people can write params[:key] instead of params['key']
+# and they get the same value for both keys.
+
+class HashWithIndifferentAccess < Hash
+  def initialize(constructor = {})
+    if constructor.is_a?(Hash)
+      super()
+      update(constructor)
+    else
+      super(constructor)
+    end
+  end
+
+  def default(key = nil)
+    if key.is_a?(Symbol) && include?(key = key.to_s)
+      self[key]
+    else
+      super
+    end
+  end
+
+  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+  alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+  # Assigns a new value to the hash:
+  #
+  #   hash = HashWithIndifferentAccess.new
+  #   hash[:key] = "value"
+  #
+  def []=(key, value)
+    regular_writer(convert_key(key), convert_value(value))
+  end
+
+  # Updates the instantized hash with values from the second:
+  # 
+  #   hash_1 = HashWithIndifferentAccess.new
+  #   hash_1[:key] = "value"
+  # 
+  #   hash_2 = HashWithIndifferentAccess.new
+  #   hash_2[:key] = "New Value!"
+  # 
+  #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+  # 
+  def update(other_hash)
+    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+    self
+  end
+
+  alias_method :merge!, :update
+
+  # Checks the hash for a key matching the argument passed in:
+  #
+  #   hash = HashWithIndifferentAccess.new
+  #   hash["key"] = "value"
+  #   hash.key? :key  # => true
+  #   hash.key? "key" # => true
+  #
+  def key?(key)
+    super(convert_key(key))
+  end
+
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+
+  # Fetches the value for the specified key, same as doing hash[key]
+  def fetch(key, *extras)
+    super(convert_key(key), *extras)
+  end
+
+  # Returns an array of the values at the specified indices:
+  #
+  #   hash = HashWithIndifferentAccess.new
+  #   hash[:a] = "x"
+  #   hash[:b] = "y"
+  #   hash.values_at("a", "b") # => ["x", "y"]
+  #
+  def values_at(*indices)
+    indices.collect {|key| self[convert_key(key)]}
+  end
+
+  # Returns an exact copy of the hash.
+  def dup
+    HashWithIndifferentAccess.new(self)
+  end
+
+  # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
+  # Does not overwrite the existing hash.
+  def merge(hash)
+    self.dup.update(hash)
+  end
+
+  # Removes a specified key from the hash.
+  def delete(key)
+    super(convert_key(key))
+  end
+
+  def stringify_keys!; self end
+  def symbolize_keys!; self end
+  def to_options!; self end
+
+  # Convert to a Hash with String keys.
+  def to_hash
+    Hash.new(default).merge(self)
+  end
+
+  protected
+    def convert_key(key)
+      key.kind_of?(Symbol) ? key.to_s : key
+    end
+
+    def convert_value(value)
+      case value
+      when Hash
+        value.with_indifferent_access
+      when Array
+        value.collect { |e| e.is_a?(Hash) ? e.with_indifferent_access : e }
+      else
+        value
+      end
+    end
+end
+
+class Hash #:nodoc:
+  def with_indifferent_access
+    hash = HashWithIndifferentAccess.new(self)
+    hash.default = self.default
+    hash
+  end
+end

data/lib/ext/uuidtools-2.1.1/CHANGELOG

@@ -0,0 +1,56 @@
+== UUIDTools 2.1.1
+ * fixed issue with Ruby 1.9 compatibility
+== UUIDTools 2.1.0
+ * completely reworked the MAC address detection code
+ * added additional parsing methods
+== UUIDTools 2.0.0
+ * moved to its own module to avoid collisions
+== UUIDTools 1.0.7
+ * fixed incompatible SecureRandom implementation
+== UUIDTools 1.0.6
+ * fixed Bignum hash issue
+ * added implicit to_str cast
+== UUIDTools 1.0.5
+ * improved specs
+ * fixed minor bugs
+ * better JRuby compatibility
+ * uses securerandom library
+ * updated rake tasks
+== UUIDTools 1.0.4
+ * calculates random node id with multicast bit if there is no MAC address
+ * uses RSpec instead of Test::Unit
+ * works in Ruby 1.9
+ * cleaned up some code
+ * removed deprecated methods
+ * changed version constant
+ * new gem file structure
+== UUIDTools 1.0.3
+ * improved code for obtaining a MAC address within JRuby
+== UUIDTools 1.0.2
+ * improved code for obtaining a MAC address for Solaris and OpenBSD
+ * added hash and eql? methods
+== UUIDTools 1.0.1
+ * improved code for obtaining a MAC address for Solaris and NetBSD
+ * MAC addresses can now be set manually
+ * replaced random number generator, less effective on Windows, but faster
+ * fixed inheritance issues
+ * changed UUID#to_uri method to return a string instead of a URI object
+ * removed UUID#to_uri_string
+== UUIDTools 1.0.0
+ * slight improvements to the random number generator
+ * fixed issue with failing to obtain mac address in certain environments
+== UUIDTools 0.1.4
+ * improved speed when generating timestamp-based uuids
+ * fixed bug with rapid generation of timestamp uuids leading to duplicates
+ * improved code for detection of mac address
+== UUIDTools 0.1.3
+ * fixed issue with UUID#raw attempting to call protected class methods
+== UUIDTools 0.1.2
+ * fixed variant method
+ * added valid? method
+ * changed timestamp_create method to allow creation of UUIDs from
+   arbitrary timestamps
+== UUIDTools 0.1.1
+ * changed helper methods to be protected like they should have been
+== UUIDTools 0.1.0
+ * parsing and generation of UUIDs implemented

data/lib/ext/uuidtools-2.1.1/LICENSE

@@ -0,0 +1,20 @@
+UUIDTools, Copyright (c) 2005-2008 Bob Aman
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/ext/uuidtools-2.1.1/README

@@ -0,0 +1,13 @@
+ UUIDTools was designed to be a simple library for generating any
+ of the various types of UUIDs.  It conforms to RFC 4122 whenever
+ possible.
+
+== Example
+  UUIDTools::UUID.md5_create(UUIDTools::UUID_DNS_NAMESPACE, "www.widgets.com")
+  => #<UUID:0x287576 UUID:3d813cbb-47fb-32ba-91df-831e1593ac29>
+  UUIDTools::UUID.sha1_create(UUIDTools::UUID_DNS_NAMESPACE, "www.widgets.com")
+  => #<UUID:0x2a0116 UUID:21f7f8de-8051-5b89-8680-0195ef798b6a>
+  UUIDTools::UUID.timestamp_create
+  => #<UUID:0x2adfdc UUID:64a5189c-25b3-11da-a97b-00c04fd430c8>
+  UUIDTools::UUID.random_create
+  => #<UUID:0x19013a UUID:984265dc-4200-4f02-ae70-fe4f48964159>

data/lib/ext/uuidtools-2.1.1/Rakefile

@@ -0,0 +1,48 @@
+lib_dir = File.expand_path(File.join(File.dirname(__FILE__), "lib"))
+$:.unshift(lib_dir)
+$:.uniq!
+
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'spec/rake/spectask'
+
+require File.join(File.dirname(__FILE__), 'lib/uuidtools', 'version')
+
+PKG_DISPLAY_NAME   = 'UUIDTools'
+PKG_NAME           = PKG_DISPLAY_NAME.downcase
+PKG_VERSION        = UUID::VERSION::STRING
+PKG_FILE_NAME      = "#{PKG_NAME}-#{PKG_VERSION}"
+
+RELEASE_NAME       = "REL #{PKG_VERSION}"
+
+RUBY_FORGE_PROJECT = PKG_NAME
+RUBY_FORGE_USER    = "sporkmonger"
+RUBY_FORGE_PATH    = "/var/www/gforge-projects/#{RUBY_FORGE_PROJECT}"
+RUBY_FORGE_URL     = "http://#{RUBY_FORGE_PROJECT}.rubyforge.org/"
+
+PKG_SUMMARY        = "UUID generator"
+PKG_DESCRIPTION    = <<-TEXT
+A simple universally unique ID generation library.
+TEXT
+
+PKG_FILES = FileList[
+    "lib/**/*", "spec/**/*", "vendor/**/*",
+    "tasks/**/*", "website/**/*",
+    "[A-Z]*", "Rakefile"
+].exclude(/database\.yml/).exclude(/[_\.]git$/)
+
+RCOV_ENABLED = (RUBY_PLATFORM != "java" && RUBY_VERSION =~ /^1\.8/)
+if RCOV_ENABLED
+  task :default => "spec:verify"
+else
+  task :default => "spec"
+end
+
+WINDOWS = (RUBY_PLATFORM =~ /mswin|win32|mingw|bccwin|cygwin/) rescue false
+SUDO = WINDOWS ? '' : ('sudo' unless ENV['SUDOLESS'])
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/lib/ext/uuidtools-2.1.1/lib/compat/securerandom.rb

@@ -0,0 +1,202 @@
+# = Secure random number generator interface.
+#
+# This library is an interface for secure random number generator which is
+# suitable for generating session key in HTTP cookies, etc.
+#
+# It supports following secure random number generators.
+#
+# * openssl
+# * /dev/urandom
+# * Win32
+#
+# == Example
+#
+# # random hexadecimal string.
+# p SecureRandom.hex(10) #=> "52750b30ffbc7de3b362"
+# p SecureRandom.hex(10) #=> "92b15d6c8dc4beb5f559"
+# p SecureRandom.hex(11) #=> "6aca1b5c58e4863e6b81b8"
+# p SecureRandom.hex(12) #=> "94b2fff3e7fd9b9c391a2306"
+# p SecureRandom.hex(13) #=> "39b290146bea6ce975c37cfc23"
+# ...
+#
+# # random base64 string.
+# p SecureRandom.base64(10) #=> "EcmTPZwWRAozdA=="
+# p SecureRandom.base64(10) #=> "9b0nsevdwNuM/w=="
+# p SecureRandom.base64(10) #=> "KO1nIU+p9DKxGg=="
+# p SecureRandom.base64(11) #=> "l7XEiFja+8EKEtY="
+# p SecureRandom.base64(12) #=> "7kJSM/MzBJI+75j8"
+# p SecureRandom.base64(13) #=> "vKLJ0tXBHqQOuIcSIg=="
+# ...
+#
+# # random binary string.
+# p SecureRandom.random_bytes(10) #=> "\016\t{\370g\310pbr\301"
+# p SecureRandom.random_bytes(10) #=> "\323U\030TO\234\357\020\a\337"
+# ...
+
+if !defined?(SecureRandom)
+  begin
+    require 'openssl'
+  rescue LoadError
+  end
+
+  module SecureRandom
+    # SecureRandom.random_bytes generates a random binary string.
+    #
+    # The argument n specifies the length of the result string.
+    #
+    # If n is not specified, 16 is assumed.
+    # It may be larger in future.
+    #
+    # If secure random number generator is not available,
+    # NotImplementedError is raised.
+    def self.random_bytes(n=nil)
+      n ||= 16
+
+      if defined? OpenSSL::Random
+        return OpenSSL::Random.random_bytes(n)
+      end
+
+      if !defined?(@has_urandom) || @has_urandom
+        flags = File::RDONLY
+        flags |= File::NONBLOCK if defined? File::NONBLOCK
+        flags |= File::NOCTTY if defined? File::NOCTTY
+        flags |= File::NOFOLLOW if defined? File::NOFOLLOW
+        begin
+          File.open("/dev/urandom", flags) {|f|
+            unless f.stat.chardev?
+              raise Errno::ENOENT
+            end
+            @has_urandom = true
+            ret = f.readpartial(n)
+            if ret.length != n
+              raise NotImplementedError,
+                "Unexpected partial read from random device"
+            end
+            return ret
+          }
+        rescue Errno::ENOENT
+          @has_urandom = false
+        end
+      end
+
+      if !defined?(@has_win32)
+        begin
+          require 'Win32API'
+
+          crypt_acquire_context = Win32API.new(
+            "advapi32", "CryptAcquireContext", 'PPPII', 'L'
+          )
+          @crypt_gen_random = Win32API.new(
+            "advapi32", "CryptGenRandom", 'LIP', 'L'
+          )
+
+          hProvStr = " " * 4
+          prov_rsa_full = 1
+          crypt_verifycontext = 0xF0000000
+
+          if crypt_acquire_context.call(
+              hProvStr, nil, nil, prov_rsa_full, crypt_verifycontext) == 0
+            raise SystemCallError,
+              "CryptAcquireContext failed: #{lastWin32ErrorMessage}"
+          end
+          @hProv, = hProvStr.unpack('L')
+
+          @has_win32 = true
+        rescue LoadError
+          @has_win32 = false
+        end
+      end
+      if @has_win32
+        bytes = " " * n
+        if @crypt_gen_random.call(@hProv, bytes.size, bytes) == 0
+          raise SystemCallError,
+            "CryptGenRandom failed: #{lastWin32ErrorMessage}"
+        end
+        return bytes
+      end
+
+      raise NotImplementedError, "No random device"
+    end
+
+    # SecureRandom.hex generates a random hex string.
+    #
+    # The argument n specifies the length of the random length.
+    # The length of the result string is twice of n.
+    #
+    # If n is not specified, 16 is assumed.
+    # It may be larger in future.
+    #
+    # If secure random number generator is not available,
+    # NotImplementedError is raised.
+    def self.hex(n=nil)
+      random_bytes(n).unpack("H*")[0]
+    end
+
+    # SecureRandom.base64 generates a random base64 string.
+    #
+    # The argument n specifies the length of the random length.
+    # The length of the result string is about 4/3 of n.
+    #
+    # If n is not specified, 16 is assumed.
+    # It may be larger in future.
+    #
+    # If secure random number generator is not available,
+    # NotImplementedError is raised.
+    def self.base64(n=nil)
+      [random_bytes(n)].pack("m*").delete("\n")
+    end
+
+    # SecureRandom.random_number generates a random number.
+    #
+    # If an positive integer is given as n,
+    # SecureRandom.random_number returns an integer:
+    # 0 <= SecureRandom.random_number(n) < n.
+    #
+    # If 0 is given or an argument is not given,
+    # SecureRandom.random_number returns an float:
+    # 0.0 <= SecureRandom.random_number() < 1.0.
+    def self.random_number(n=0)
+      if 0 < n
+        hex = n.to_s(16)
+        hex = '0' + hex if (hex.length & 1) == 1
+        bin = [hex].pack("H*")
+        first = bin[0..0]
+        mask = first.respond_to?(:ord) ? first.ord : first.sum(8)
+        mask |= mask >> 1
+        mask |= mask >> 2
+        mask |= mask >> 4
+        begin
+          rnd = SecureRandom.random_bytes(bin.length)
+          first = rnd[0..0]
+          ordinal = first.respond_to?(:ord) ? first.ord : first.sum(8)
+          rnd[0..0] = (ordinal & mask).chr
+        end until rnd < bin
+        rnd.unpack("H*")[0].hex
+      else
+        # assumption: Float::MANT_DIG <= 64
+        i64 = SecureRandom.random_bytes(8).unpack("Q")[0]
+        Math.ldexp(i64 >> (64-Float::MANT_DIG), -Float::MANT_DIG)
+      end
+    end
+
+    # Following code is based on David Garamond's GUID library for Ruby.
+    def self.lastWin32ErrorMessage # :nodoc:
+      get_last_error = Win32API.new(
+        "kernel32", "GetLastError", '', 'L'
+      )
+      format_message = Win32API.new(
+        "kernel32", "FormatMessageA", 'LPLLPLPPPPPPPP', 'L'
+      )
+      format_message_ignore_inserts = 0x00000200
+      format_message_from_system    = 0x00001000
+
+      code = get_last_error.call
+      msg = "\0" * 1024
+      len = format_message.call(
+        format_message_ignore_inserts + format_message_from_system,
+        0, code, 0, msg, 1024, nil, nil, nil, nil, nil, nil, nil, nil
+      )
+      msg[0, len].tr("\r", '').chomp
+    end
+  end
+end