sidekick-client 0.1.0

data/lib/ext/uuidtools-2.1.1/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/lib/ext/uuidtools-2.1.1/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+spec_dir = File.expand_path(File.dirname(__FILE__))
+lib_dir = File.expand_path(File.join(spec_dir, "../lib"))
+
+$:.unshift(lib_dir)
+$:.uniq!
+
+require "uuidtools"

data/lib/ext/uuidtools-2.1.1/spec/uuidtools/mac_address_spec.rb

@@ -0,0 +1,15 @@
+require File.join(File.dirname(__FILE__), "../spec_helper.rb")
+
+describe UUIDTools::UUID, "when obtaining a MAC address" do
+  before do
+    @mac_address = UUIDTools::UUID.mac_address
+  end
+
+  it "should obtain a MAC address" do
+    @mac_address.should_not be_nil
+  end
+
+  it "should cache the MAC address" do
+    @mac_address.object_id.should == UUIDTools::UUID.mac_address.object_id
+  end
+end

data/lib/ext/uuidtools-2.1.1/spec/uuidtools/utility_spec.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__), "../spec_helper.rb")
+
+describe SecureRandom do
+  it "should correctly obtain random bits" do
+    bits = []
+    1000.times do
+      bits << SecureRandom.random_bytes(16)
+    end
+    # Check to make sure that none of the 10,000 strings were duplicates
+    (bits.map {|x| x.to_s}).uniq.size.should == bits.size
+  end
+
+  it "should return the correct number of random bits" do
+    SecureRandom.random_bytes(16).size.should == 16
+    SecureRandom.random_bytes(6).size.should == 6
+  end
+
+  it "should return a sane random number" do
+    SecureRandom.random_number(5000).should < 5000
+  end
+end

data/lib/ext/uuidtools-2.1.1/spec/uuidtools/uuid_creation_spec.rb

@@ -0,0 +1,121 @@
+require File.join(File.dirname(__FILE__), "../spec_helper.rb")
+
+describe UUIDTools::UUID, "when generating" do
+  it "should correctly generate SHA1 variant UUIDs" do
+    UUIDTools::UUID.sha1_create(
+      UUIDTools::UUID_URL_NAMESPACE, 'http://sporkmonger.com'
+    ).to_s.should == "f2d04685-b787-55da-8644-9bd28a6f5a53"
+  end
+
+  it "should correctly generate MD5 variant UUIDs" do
+    UUIDTools::UUID.md5_create(
+      UUIDTools::UUID_URL_NAMESPACE, 'http://sporkmonger.com'
+    ).to_s.should == "15074785-9071-3fe3-89bd-876e4b9e919b"
+  end
+
+  it "should correctly generate timestamp variant UUIDs" do
+    UUIDTools::UUID.timestamp_create.should_not be_random_node_id
+    UUIDTools::UUID.timestamp_create.to_s.should_not ==
+      UUIDTools::UUID.timestamp_create.to_s
+    current_time = Time.now
+    UUIDTools::UUID.timestamp_create(current_time).to_s.should_not ==
+      UUIDTools::UUID.timestamp_create(current_time).to_s
+    uuids = []
+    1000.times do
+      uuids << UUIDTools::UUID.timestamp_create
+    end
+    # Check to make sure that none of the 1,000 UUIDs were duplicates
+    (uuids.map {|x| x.to_s}).uniq.size.should == uuids.size
+  end
+
+  it "should correctly generate UUIDs without a MAC address" do
+    mac_address = UUIDTools::UUID.mac_address
+    UUIDTools::UUID.mac_address = nil
+    UUIDTools::UUID.timestamp_create.should be_random_node_id
+    UUIDTools::UUID.mac_address = mac_address
+  end
+
+  it "should correctly generate random number variant UUIDs" do
+    uuids = []
+    1000.times do
+      uuids << UUIDTools::UUID.random_create
+    end
+    # Check to make sure that none of the 1,000 UUIDs were duplicates
+    (uuids.map {|x| x.to_s}).uniq.size.should == uuids.size
+  end
+
+  it "should throw an exception if a segment has an invalid value" do
+    (lambda do
+      UUIDTools::UUID.new(-1, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
+    end).should raise_error(ArgumentError)
+    (lambda do
+      UUIDTools::UUID.new(4294967296, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
+    end).should raise_error(ArgumentError)
+  end
+
+  it "should throw an exception if a segment has an invalid value" do
+    (lambda do
+      UUIDTools::UUID.new(0, -1, 0, 0, 0, [0, 0, 0, 0, 0, 0])
+    end).should raise_error(ArgumentError)
+    (lambda do
+      UUIDTools::UUID.new(0, 65536, 0, 0, 0, [0, 0, 0, 0, 0, 0])
+    end).should raise_error(ArgumentError)
+  end
+
+  it "should throw an exception if a segment has an invalid value" do
+    (lambda do
+      UUIDTools::UUID.new(0, 0, -1, 0, 0, [0, 0, 0, 0, 0, 0])
+    end).should raise_error(ArgumentError)
+    (lambda do
+      UUIDTools::UUID.new(0, 0, 65536, 0, 0, [0, 0, 0, 0, 0, 0])
+    end).should raise_error(ArgumentError)
+  end
+
+  it "should throw an exception if a segment has an invalid value" do
+    (lambda do
+      UUIDTools::UUID.new(0, 0, 0, -1, 0, [0, 0, 0, 0, 0, 0])
+    end).should raise_error(ArgumentError)
+    (lambda do
+      UUIDTools::UUID.new(0, 0, 0, 256, 0, [0, 0, 0, 0, 0, 0])
+    end).should raise_error(ArgumentError)
+  end
+
+  it "should throw an exception if a segment has an invalid value" do
+    (lambda do
+      UUIDTools::UUID.new(0, 0, 0, 0, -1, [0, 0, 0, 0, 0, 0])
+    end).should raise_error(ArgumentError)
+    (lambda do
+      UUIDTools::UUID.new(0, 0, 0, 0, 256, [0, 0, 0, 0, 0, 0])
+    end).should raise_error(ArgumentError)
+  end
+
+  it "should throw an exception if nodes are not a collection" do
+    (lambda do
+      UUIDTools::UUID.new(0, 0, 0, 0, 0, :bogus)
+    end).should raise_error(TypeError)
+  end
+
+  it "should throw an exception if nodes are the wrong size" do
+    (lambda do
+      UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0])
+    end).should raise_error(ArgumentError)
+  end
+
+  it "should throw an exception if any nodes have invalid values" do
+    (lambda do
+      UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 256])
+    end).should raise_error(ArgumentError)
+  end
+
+  it "should throw an exception if parsing anything but a String" do
+    (lambda do
+      UUIDTools::UUID.parse(:bogus)
+    end).should raise_error(TypeError)
+  end
+
+  it "should throw an exception if raw parsing anything but a String" do
+    (lambda do
+      UUIDTools::UUID.parse_raw(:bogus)
+    end).should raise_error(TypeError)
+  end
+end

data/lib/ext/uuidtools-2.1.1/spec/uuidtools/uuid_parsing_spec.rb

@@ -0,0 +1,127 @@
+require File.join(File.dirname(__FILE__), "../spec_helper.rb")
+
+describe UUIDTools::UUID, "when parsing" do
+  it "should correctly parse the MAC address from a timestamp version UUID" do
+    UUIDTools::UUID.timestamp_create.mac_address.should ==
+      UUIDTools::UUID.mac_address
+  end
+
+  it "should correctly parse the variant from a timestamp version UUID" do
+    UUIDTools::UUID.timestamp_create.variant.should == 0b100
+  end
+
+  it "should correctly parse the version from a timestamp version UUID" do
+    UUIDTools::UUID.timestamp_create.version.should == 1
+  end
+
+  it "should correctly parse the timestamp from a timestamp version UUID" do
+    UUIDTools::UUID.timestamp_create.timestamp.should < Time.now + 1
+    UUIDTools::UUID.timestamp_create.timestamp.should > Time.now - 1
+  end
+
+  it "should not treat a timestamp version UUID as a nil UUID" do
+    UUIDTools::UUID.timestamp_create.should_not be_nil_uuid
+  end
+
+  it "should not treat a timestamp version UUID as a random node UUID" do
+    UUIDTools::UUID.timestamp_create.should_not be_random_node_id
+  end
+
+  it "should treat a timestamp version UUID as a random node UUID " +
+      "if there is no MAC address" do
+    old_mac_address = UUIDTools::UUID.mac_address
+    UUIDTools::UUID.mac_address = nil
+    UUIDTools::UUID.timestamp_create.should be_random_node_id
+    UUIDTools::UUID.mac_address = old_mac_address
+  end
+
+  it "should correctly identify the nil UUID" do
+    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should be_nil_uuid
+  end
+
+  it "should correctly identify timestamp version UUIDs as valid" do
+    UUIDTools::UUID.timestamp_create.should be_valid
+  end
+
+  it "should correctly identify random number version UUIDs as valid" do
+    UUIDTools::UUID.random_create.should be_valid
+  end
+
+  it "should correctly identify SHA1 hash version UUIDs as valid" do
+    UUIDTools::UUID.sha1_create(
+      UUIDTools::UUID_URL_NAMESPACE, 'http://sporkmonger.com'
+    ).should be_valid
+  end
+
+  it "should correctly identify MD5 hash version UUIDs as valid" do
+    UUIDTools::UUID.md5_create(
+      UUIDTools::UUID_URL_NAMESPACE, 'http://sporkmonger.com'
+    ).should be_valid
+  end
+
+  it "should not identify the nil UUID as valid" do
+    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should_not be_valid
+  end
+
+  it "should allow for sorting of UUID arrays" do
+    uuids = []
+    1000.times do
+      uuids << UUIDTools::UUID.timestamp_create
+    end
+    uuids.sort!
+    uuids.first.should < uuids.last
+    uuids.last.should > uuids.first
+  end
+
+  it "should allow for comparison of UUIDs" do
+    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should <
+      UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 1])
+    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 1]).should >
+      UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
+    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should ==
+      UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
+  end
+
+  it "should produce the correct hexdigest for a UUID" do
+    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).hexdigest.should ==
+      "00000000000000000000000000000000"
+    UUIDTools::UUID.new(1, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).hexdigest.should ==
+      "00000001000000000000000000000000"
+    UUIDTools::UUID.timestamp_create.hexdigest.size.should == 32
+  end
+
+  it "should produce a sane hash value for a UUID" do
+    uuid = UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
+    uuid.to_i.should == 0
+    uuid.hash.should be_kind_of(Fixnum)
+  end
+
+  it "should produce the correct URI for a UUID" do
+    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).to_uri.should ==
+      "urn:uuid:00000000-0000-0000-0000-000000000000"
+  end
+
+  it "should correctly test UUID equality" do
+    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should be_eql(
+      UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
+    )
+  end
+
+  it "should correctly parse integers" do
+    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should ==
+      UUIDTools::UUID.parse_int(0)
+    UUIDTools::UUID.parse_int(0).should be_nil_uuid
+    uuid = UUIDTools::UUID.timestamp_create
+    UUIDTools::UUID.parse_int(uuid.to_i).should == uuid
+  end
+
+  it "should correctly parse hexdigests" do
+    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should ==
+      UUIDTools::UUID.parse_hexdigest("00000000000000000000000000000000")
+    UUIDTools::UUID.parse_hexdigest(
+      "00000000000000000000000000000000"
+    ).should be_nil_uuid
+    uuid = UUIDTools::UUID.timestamp_create
+    UUIDTools::UUID.parse_hexdigest(uuid.hexdigest).should == uuid
+  end
+end

data/lib/ext/uuidtools-2.1.1/tasks/benchmark.rake

@@ -0,0 +1,38 @@
+task :benchmark do
+  require 'lib/uuidtools'
+  require 'benchmark'
+
+  # Version 1
+  result = Benchmark.measure do
+    10000.times do
+      UUID.timestamp_create.to_s
+    end
+  end
+  puts "#{(10000.0 / result.real)} version 1 per second."
+
+  # Version 3
+  result = Benchmark.measure do
+    10000.times do
+      UUID.md5_create(UUID_URL_NAMESPACE,
+        "http://www.ietf.org/rfc/rfc4122.txt").to_s
+    end
+  end
+  puts "#{(10000.0 / result.real)} version 3 per second."
+
+  # Version 4
+  result = Benchmark.measure do
+    10000.times do
+      UUID.random_create.to_s
+    end
+  end
+  puts "#{(10000.0 / result.real)} version 4 per second."
+
+  # Version 5
+  result = Benchmark.measure do
+    10000.times do
+      UUID.sha1_create(UUID_URL_NAMESPACE,
+        "http://www.ietf.org/rfc/rfc4122.txt").to_s
+    end
+  end
+  puts "#{(10000.0 / result.real)} version 5 per second."
+end

data/lib/ext/uuidtools-2.1.1/tasks/clobber.rake

@@ -0,0 +1,2 @@
+desc "Remove all build products"
+task "clobber"

data/lib/ext/uuidtools-2.1.1/tasks/gem.rake

@@ -0,0 +1,68 @@
+require "rake/gempackagetask"
+
+namespace :gem do
+  GEM_SPEC = Gem::Specification.new do |s|
+    unless s.respond_to?(:add_development_dependency)
+      puts "The gem spec requires a newer version of RubyGems."
+      exit(1)
+    end
+
+    s.name = PKG_NAME
+    s.version = PKG_VERSION
+    s.summary = PKG_SUMMARY
+    s.description = PKG_DESCRIPTION
+
+    s.files = PKG_FILES.to_a
+
+    s.has_rdoc = true
+    s.extra_rdoc_files = %w( README )
+    s.rdoc_options.concat ["--main",  "README"]
+
+    s.add_development_dependency("rake", ">= 0.8.3")
+    s.add_development_dependency("rspec", ">= 1.1.11")
+    s.add_development_dependency("launchy", ">= 0.3.2")
+
+    s.require_path = "lib"
+
+    s.author = "Bob Aman"
+    s.email = "bob@sporkmonger.com"
+    s.homepage = "http://#{PKG_NAME}.rubyforge.org/"
+    s.rubyforge_project = RUBY_FORGE_PROJECT
+  end
+
+  Rake::GemPackageTask.new(GEM_SPEC) do |p|
+    p.gem_spec = GEM_SPEC
+    p.need_tar = true
+    p.need_zip = true
+  end
+
+  desc "Show information about the gem"
+  task :debug do
+    puts GEM_SPEC.to_ruby
+  end
+
+  desc "Install the gem"
+  task :install => ["clobber", "gem:package"] do
+    sh "#{SUDO} gem install --local pkg/#{GEM_SPEC.full_name}"
+  end
+
+  desc "Uninstall the gem"
+  task :uninstall do
+    installed_list = Gem.source_index.find_name(PKG_NAME)
+    if installed_list &&
+        (installed_list.collect { |s| s.version.to_s}.include?(PKG_VERSION))
+      sh(
+        "#{SUDO} gem uninstall --version '#{PKG_VERSION}' " +
+        "--ignore-dependencies --executables #{PKG_NAME}"
+      )
+    end
+  end
+
+  desc "Reinstall the gem"
+  task :reinstall => [:uninstall, :install]
+end
+
+desc "Alias to gem:package"
+task "gem" => "gem:package"
+
+task "clobber" => ["gem:clobber_package"]

data/lib/ext/uuidtools-2.1.1/tasks/git.rake

@@ -0,0 +1,40 @@
+namespace :git do
+  namespace :tag do
+    desc "List tags from the Git repository"
+    task :list do
+      tags = `git tag -l`
+      tags.gsub!("\r", "")
+      tags = tags.split("\n").sort {|a, b| b <=> a }
+      puts tags.join("\n")
+    end
+
+    desc "Create a new tag in the Git repository"
+    task :create do
+      changelog = File.open("CHANGELOG", "r") { |file| file.read }
+      puts "-" * 80
+      puts changelog
+      puts "-" * 80
+      puts
+
+      v = ENV["VERSION"] or abort "Must supply VERSION=x.y.z"
+      abort "Versions don't match #{v} vs #{PKG_VERSION}" if v != PKG_VERSION
+
+      tag = "#{PKG_NAME}-#{PKG_VERSION}"
+      msg = "Release #{PKG_NAME}-#{PKG_VERSION}"
+
+      existing_tags = `git tag -l #{PKG_NAME}-*`.split("\n")
+      if existing_tags.include?(tag)
+        warn("Tag already exists, deleting...")
+        unless system "git tag -d #{tag}"
+          abort "Tag deletion failed."
+        end
+      end
+      puts "Creating git tag '#{tag}'..."
+      unless system "git tag -a -m \"#{msg}\" #{tag}"
+        abort "Tag creation failed."
+      end
+    end
+  end
+end
+
+task "gem:release" => "git:tag:create"