abiquo-etk 0.4.13

data/vendor/options-2.3.0/lib/options.rb

@@ -0,0 +1,220 @@
+module Options
+  Options::VERSION = '2.3.0' unless defined?(Options::VERSION)
+
+  class << Options
+    def version
+      Options::VERSION
+    end
+
+    def normalize!(hash)
+      hash.keys.each{|key| hash[key.to_s.to_sym] = hash.delete(key) unless Symbol===key}
+      hash
+    end
+    alias_method 'to_options!', 'normalize!'
+
+    def normalize(hash)
+      normalize!(hash.dup)
+    end
+    alias_method 'to_options', 'normalize'
+
+    def stringify!(hash)
+      hash.keys.each{|key| hash[key.to_s] = hash.delete(key) unless String===key}
+      hash
+    end
+    alias_method 'stringified!', 'stringify!'
+
+    def stringify(hash)
+      stringify!(hash)
+    end
+    alias_method 'stringified', 'stringify'
+
+    def for(hash)
+      hash =
+        case hash
+          when Hash
+            hash
+          when Array
+            Hash[*hash.flatten]
+          when String, Symbol
+            {hash => true}
+          else
+            hash.to_hash
+        end
+      normalize!(hash)
+    ensure
+      hash.extend(Options) unless hash.is_a?(Options)
+    end
+
+    def parse(args)
+      case args
+      when Array
+        args.extend(Arguments) unless args.is_a?(Arguments)
+        [args, args.options.pop]
+      when Hash
+        Options.for(args)
+      else
+        raise ArgumentError, "`args` should be an Array or Hash"
+      end
+    end
+  end
+
+  def to_options!
+    replace to_options
+  end
+
+  def to_options
+    keys.inject(Hash.new){|h,k| h.update k.to_s.to_sym => fetch(k)}
+  end
+        
+  def getopt key, default = nil
+    [ key ].flatten.each do |key|
+      return fetch(key) if has_key?(key)
+      key = key.to_s
+      return fetch(key) if has_key?(key)
+      key = key.to_sym
+      return fetch(key) if has_key?(key)
+    end
+    default
+  end
+
+  def getopts *args
+    args.flatten.map{|arg| getopt arg}
+  end
+
+  def hasopt key, default = nil
+    [ key ].flatten.each do |key|
+      return true if has_key?(key)
+      key = key.to_s
+      return true if has_key?(key)
+      key = key.to_sym
+      return true if has_key?(key)
+    end
+    default
+  end
+  alias_method 'hasopt?', 'hasopt'
+
+  def hasopts *args
+    args.flatten.map{|arg| hasopt arg}
+  end
+  alias_method 'hasopts?', 'hasopts'
+
+  def delopt key, default = nil
+    [ key ].flatten.each do |key|
+      return delete(key) if has_key?(key)
+      key = key.to_s
+      return delete(key) if has_key?(key)
+      key = key.to_sym
+      return delete(key) if has_key?(key)
+    end
+    default
+  end
+
+  def delopts *args
+    args.flatten.map{|arg| delopt arg}
+  end
+
+  def setopt key, value = nil
+    [ key ].flatten.each do |key|
+      return self[key]=value if has_key?(key)
+      key = key.to_s
+      return self[key]=value if has_key?(key)
+      key = key.to_sym
+      return self[key]=value if has_key?(key)
+    end
+    return self[key]=value
+  end
+  alias_method 'setopt!', 'setopt'
+
+  def setopts opts 
+    opts.each{|key, value| setopt key, value}
+    opts
+  end
+  alias_method 'setopts!', 'setopts'
+
+  def select! *a, &b
+    replace select(*a, &b).to_hash
+  end
+
+  def normalize!
+    Options.normalize!(self)
+  end
+  alias_method 'normalized!', 'normalize!'
+  alias_method 'to_options!', 'normalize!'
+
+  def normalize
+    Options.normalize(self)
+  end
+  alias_method 'normalized', 'normalize'
+  alias_method 'to_options', 'normalize'
+
+  def stringify!
+    Options.stringify!(self)
+  end
+  alias_method 'stringified!', 'stringify!'
+
+  def stringify
+    Options.stringify(self)
+  end
+  alias_method 'stringified', 'stringify'
+
+  attr_accessor :arguments
+  def pop
+    pop! unless popped?
+    self
+  end
+
+  def popped?
+    defined?(@popped) and @popped
+  end
+
+  def pop!
+    if arguments.last.is_a?(Hash)
+      @popped = arguments.pop
+    else
+      @popped = true
+    end
+  end
+
+  # Validates that the options provided are acceptable.
+  #
+  # @param [Symbol] *acceptable_options List of options that are
+  #   allowed
+  def validate(*acceptable_options)
+    remaining = (provided_options - acceptable_options).map{|opt| opt.to_s}.sort
+    raise ArgumentError, "Unrecognized options: #{remaining.join(', ')}" unless remaining.empty?
+    
+    self
+  end
+
+  protected
+
+  def provided_options
+    normalize!.keys
+  end
+end
+
+module Arguments
+  def options
+    @options ||= Options.for(last.is_a?(Hash) ? last : {})
+  ensure
+    @options.arguments = self
+  end
+
+  class << Arguments
+    def for(args)
+      args.extend(Arguments) unless args.is_a?(Arguments)
+      args
+    end
+
+    def parse(args)
+      [args, Options.parse(args)]
+    end
+  end
+end
+
+class Array
+  def options
+    extend(Arguments) unless is_a?(Arguments)
+    options
+  end
+end

data/vendor/options-2.3.0/options.gemspec

@@ -0,0 +1,26 @@
+## options.gemspec
+#
+
+Gem::Specification::new do |spec|
+  spec.name = "options"
+  spec.version = "2.2.0"
+  spec.platform = Gem::Platform::RUBY
+  spec.summary = "options"
+
+  spec.files = ["lib", "lib/options.rb", "options.gemspec", "Rakefile", "README", "README.erb", "samples", "samples/a.rb", "samples/b.rb", "samples/c.rb", "samples/d.rb", "spec", "spec/options_spec.rb", "spec/spec_helper.rb"]
+  spec.executables = []
+  
+  spec.require_path = "lib"
+
+  spec.has_rdoc = true
+  spec.test_files = nil
+  #spec.add_dependency 'lib', '>= version'
+  #spec.add_dependency 'fattr'
+
+  spec.extensions.push(*[])
+
+  spec.rubyforge_project = "codeforpeople"
+  spec.author = "Ara T. Howard"
+  spec.email = "ara.t.howard@gmail.com"
+  spec.homepage = "http://github.com/ahoward/options/tree/master"
+end

data/vendor/options-2.3.0/samples/a.rb

@@ -0,0 +1,15 @@
+require 'options'
+
+# options.rb makes it super easy to deal with keyword options in a safe and
+# easy way.
+#
+
+  def method(*args)
+    args, options = Options.parse(args)
+
+    force = options.getopt(:force, default=false)
+    p force
+  end
+
+  method(:foo, :bar, :force => true)
+  method('force' => true)

data/vendor/options-2.3.0/samples/b.rb

@@ -0,0 +1,50 @@
+require 'options'
+
+# options.rb avoids common mistakes made handling keyword arguments
+#
+
+  def broken(*args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    if options[:force]
+      puts 'forcing'
+    else
+      puts 'broken'
+    end
+  end
+
+  def nonbroken(*args)
+    args, options = Options.parse(args)
+    if options.getopt(:force)
+      puts 'nonbroken'
+    end
+  end
+
+  broken('force' => true)
+  nonbroken('force' => true)
+
+
+
+  def fubar(*args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    verbose = options[:verbose] || true
+    if verbose 
+      if options[:verbose]
+        puts 'verbosely'
+      else
+        puts 'fubar'
+      end
+    end
+  end
+
+  def nonfubar(*args)
+    args, options = Options.parse(args)
+    verbose = options.getopt(:verbose)
+    if verbose 
+      puts 'verbosely'
+    else
+      puts 'nonfubar'
+    end
+  end
+
+  fubar(:verbose => false)
+  nonfubar(:verbose => false)

data/vendor/options-2.3.0/samples/c.rb

@@ -0,0 +1,20 @@
+require 'options'
+
+# options.rb hacks ruby core in exactly one way - the method Array#options
+#
+
+  def method(*args)
+    options = args.options
+    p :args => args
+    p :options => options
+  end
+
+  method(:a, :b, :k => :v)
+
+  def method2(*args)
+    options = args.options.pop
+    p :args => args
+    p :options => options
+  end
+
+  method2(:a, :b, :k => :v)

data/vendor/options-2.3.0/samples/d.rb

@@ -0,0 +1,17 @@
+require 'options'
+
+# options.rb makes it easy to provide good error messages when people
+# misuse a method.
+#
+
+  def method(*args)
+    args, options = Options.parse(args)
+    options.validate(:force)
+
+    force = options.getopt(:force, default=false)
+    p force
+  end
+
+  method(:foo, :bar, :misspelled_option => true)
+
+

data/vendor/options-2.3.0/spec/options_spec.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + "/spec_helper"
+require 'options'
+
+describe Options do 
+  describe "parsing" do 
+    it "should be able to handle an options hash" do 
+      opts = Options.parse({:this => 'that'})
+      opts.getopt(:this).should eql('that')
+    end
+
+    it "should be able to handle args list w/ options hash" do 
+      args, opts = Options.parse([:foo, {:this => 'that'}])
+      opts.getopt(:this).should eql('that')
+      args.should eql([:foo])
+    end
+  end
+
+  describe "validation" do 
+    it "should be able to detect extraneous options" do 
+      lambda{
+        Options.parse({:this => 'test'}).validate(:foo, :bar)
+      }.should raise_error(ArgumentError, "Unrecognized options: this")
+    end
+
+    it "should list all extraneous options in message" do 
+      lambda{
+        Options.parse({:this => 'test', :that => 'test'}).validate(:foo)
+      }.should raise_error(ArgumentError, "Unrecognized options: that, this")
+    end
+
+    it "should accept options from simple list" do 
+      lambda{
+        Options.parse({:foo => 'this', :bar => 'that'}).validate(:foo, :bar)
+      }.should_not raise_error
+    end
+
+  end
+end

data/vendor/options-2.3.0/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'spec'
+require 'pathname'
+require 'pp'
+
+$LOAD_PATH.unshift Pathname(__FILE__).dirname + "../lib"
+

data/vendor/resourceful-1.0.1/History.txt

@@ -0,0 +1,39 @@
+Version 1.0.0
+============
+ * Added .request() convenience method to Resourceful module.
+ * Added .get(), .post(), .put(), .delete() and .head() convenience method to Resourceful module
+
+Version 0.7.0
+=============
+ * Multiple values in a single header field are treated the same as repeated header fields. (Peter Williams)
+
+Compatibility issues
+--------------------
+
+ * The semantics of the Resourceful::Header API have changed slightly.
+   Previously multiple values in a single header field 
+   (e.g. `Accept: application/xml, application/json`) where treated 
+   differently from multiple values occurring in multiple fields (e.g 
+   `Accept: application/xml\n\rAccept: application/json`).  This lead 
+   to some unfortunate complexity when interacting with multi-valued 
+   fields.
+
+
+Version 0.6.0
+=============
+
+ * Improved support for multi-valued header fields. (Peter Williams)
+ * Added convenience mechanisms for making URL encoded and multipart form data requests. (Peter Williams)
+ * Ruby 1.9 support (Peter Williams)
+
+Compatibility issues
+--------------------
+
+ * The semantics of the Resourceful::Header API have changed slightly.
+   Previously, any header might return a string or an array.  Now
+   fields are either "single-value" and always return a string, or
+   "multi-value" and always return an array.  See API doc for more
+   details.
+
+
+

data/vendor/resourceful-1.0.1/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2008 Absolute-Performance, Inc
+Copyright (c) 2008 Peter Williams
+
+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/vendor/resourceful-1.0.1/Manifest

@@ -0,0 +1,43 @@
+History.txt
+MIT-LICENSE
+Manifest
+README.markdown
+Rakefile
+lib/resourceful.rb
+lib/resourceful/abstract_form_data.rb
+lib/resourceful/authentication_manager.rb
+lib/resourceful/cache_manager.rb
+lib/resourceful/exceptions.rb
+lib/resourceful/header.rb
+lib/resourceful/http_accessor.rb
+lib/resourceful/memcache_cache_manager.rb
+lib/resourceful/multipart_form_data.rb
+lib/resourceful/net_http_adapter.rb
+lib/resourceful/request.rb
+lib/resourceful/resource.rb
+lib/resourceful/response.rb
+lib/resourceful/simple.rb
+lib/resourceful/stubbed_resource_proxy.rb
+lib/resourceful/urlencoded_form_data.rb
+lib/resourceful/util.rb
+resourceful.gemspec
+spec/acceptance/authorization_spec.rb
+spec/acceptance/caching_spec.rb
+spec/acceptance/header_spec.rb
+spec/acceptance/redirecting_spec.rb
+spec/acceptance/resource_spec.rb
+spec/acceptance/resourceful_spec.rb
+spec/acceptance_shared_specs.rb
+spec/caching_spec.rb
+spec/old_acceptance_specs.rb
+spec/resourceful/header_spec.rb
+spec/resourceful/http_accessor_spec.rb
+spec/resourceful/multipart_form_data_spec.rb
+spec/resourceful/resource_spec.rb
+spec/resourceful/response_spec.rb
+spec/resourceful/urlencoded_form_data_spec.rb
+spec/resourceful_spec.rb
+spec/simple_sinatra_server.rb
+spec/simple_sinatra_server_spec.rb
+spec/spec.opts
+spec/spec_helper.rb

data/vendor/resourceful-1.0.1/README.markdown

@@ -0,0 +1,92 @@
+Resourceful
+===========
+
+Resourceful provides a convenient Ruby API for making HTTP requests.
+
+Features:
+
+ * GET, PUT, POST and DELETE HTTP requests
+ * HTTP Basic and Digest authentication
+ * HTTP Caching with pluggable backends
+ * Follow redirects based on the results of a callback
+
+More Info
+=========
+
+ * Source: [Github](http://github.com/paul/resourceful/tree/master)
+ * Bug Tracking: [Lighthouse](http://resourceful.lighthouseapp.com)
+ * Project Page: [Rubyforge](http://rubyforge.org/projects/resourceful/)
+ * Documentation: [API Docs](http://resourceful.rubyforge.org)
+
+Examples
+========
+
+Getting started
+---------------
+
+    gem install resourceful
+
+Simplest example
+---------------
+
+    require 'resourceful'
+    resp = Resourceful.get('http://rubyforge.org')
+    puts resp.body
+
+Get a page requiring HTTP Authentication
+----------------------------------------
+
+    my_realm_authenticator = Resourceful::BasicAuthenticator.new('My Realm', 'admin', 'secret')
+    http = Resourceful::HttpAccessor.new(:authenticator => my_realm_authenticator)
+    resp = http.resource('http://example.com/').get
+    puts resp.body
+
+Redirection based on callback results
+-------------------------------------
+
+Resourceful will by default follow redirects on read requests (GET and HEAD), but not for
+POST, etc. If you want to follow a redirect after a post, you will need to set the resource#on_redirect
+callback. If the callback evaluates to true, it will follow the redirect.
+
+    resource = http.resource('http://example.com/redirect_me')
+    resource.on_redirect { |req, resp| resp.header['Location'] =~ /example.com/ }
+    resource.get  # Will only follow the redirect if the new location is example.com
+
+Post a URL encoded form
+-----------------------
+
+     require 'resourceful'
+     http = Resourceful::HttpAccessor.new
+     resp = http.resource('http://mysite.example/service').
+              post(Resourceful::UrlencodedFormData.new(:hostname => 'test', :level => 'super'))
+
+Post a Mulitpart form with a file
+-----------------------
+
+     require 'resourceful'
+     http = Resourceful::HttpAccessor.new
+     form_data = Resourceful::MultipartFormData.new(:username => 'me')
+     form_data.add_file('avatar', '/tmp/my_avatar.png', 'image/png')
+     resp = http.resource('http://mysite.example/service').post(form_data)
+
+Put an XML document
+-------------------
+
+     require 'resourceful'
+     http = Resourceful::HttpAccessor.new
+     resp = http.resource('http://mysite.example/service').
+              put('<?xml version="1.0"?><test/>', :content_type => 'application/xml')
+
+Delete a resource
+-----------------
+
+     require 'resourceful'
+     http = Resourceful::HttpAccessor.new
+     resp = http.resource('http://mysite.example/service').delete
+
+
+Copyright
+---------
+
+Copyright (c) 2008 Absolute Performance, Inc, Peter Williams.  Released under the MIT License.
+

data/vendor/resourceful-1.0.1/Rakefile

@@ -0,0 +1,91 @@
+require 'rubygems'
+require 'rake'
+require 'lib/resourceful'
+
+begin
+  require 'echoe'
+
+  Echoe.new('resourceful', Resourceful::VERSION) do |p|
+    p.description     = "An HTTP library for Ruby that takes advantage of everything HTTP has to offer."
+    p.url             = "http://github.com/paul/resourceful"
+    p.author          = "Paul Sadauskas"
+    p.email           = "psadauskas@gmail.com"
+
+    p.ignore_pattern  = ["pkg/*", "tmp/*"]
+    p.dependencies    = [['addressable', '>= 2.1.0'], 'httpauth', ['options', '>= 2.1.1']]
+    p.development_dependencies = ['thin', 'yard', 'sinatra', 'rspec']
+    p.retain_gemspec  = true
+  end
+rescue LoadError => e
+  puts "install 'echoe' gem to be able to build the gem"
+end
+
+require 'spec/rake/spectask'
+
+desc 'Run all acceptance specs'
+
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts << '--options' << 'spec/spec.opts' if File.exists?('spec/spec.opts')
+  t.libs << 'lib'
+  t.spec_files = FileList['spec/**/*_spec.rb'] 
+end
+
+namespace :spec do 
+  desc 'Run all acceptance specs'
+  Spec::Rake::SpecTask.new(:acceptance) do |t|
+    t.spec_opts << '--options' << 'spec/spec.opts' if File.exists?('spec/spec.opts')
+    t.libs << 'lib'
+    t.spec_files = FileList['spec/acceptance/*_spec.rb'] 
+  end
+
+  desc 'Run all unit specs'
+  Spec::Rake::SpecTask.new(:unit) do |t|
+    t.spec_opts << '--options' << 'spec/spec.opts' if File.exists?('spec/spec.opts')
+    t.libs << 'lib'
+    t.spec_files = FileList['spec/**/*_spec.rb'] - (FileList['spec/acceptance/*_spec.rb'] + FileList['spec/simple_sinatra_server_spec.rb'] )
+  end
+  
+  desc 'Run the specs for the server'
+  Spec::Rake::SpecTask.new('server') do |t|
+    t.spec_opts << '--options' << 'spec/spec.opts' if File.exists?('spec/spec.opts')
+    t.libs << 'lib'
+    t.spec_files = FileList['spec/simple_sinatra_server_spec.rb'] 
+  end
+end
+
+task :server do 
+  begin 
+    require 'spec/simple_sinatra_server'
+    desc "Run the sinatra echo server, with loggin" 
+    task :server do
+      Sinatra::Default.set(
+                           :run => true,
+                           :logging => true
+                           )
+    end
+  rescue LoadError => e
+    puts "Install 'sinatra' gem to run the server"
+  end
+end
+
+desc 'Default: Run Specs'
+task :default => :spec
+
+desc 'Run all tests'
+task :test => :spec
+
+begin
+  require 'yard'
+
+  desc "Generate Yardoc"
+  YARD::Rake::YardocTask.new do |t|
+    t.files = ['lib/**/*.rb', 'README.markdown']
+  end
+rescue LoadError => e
+  puts "Install 'yard' gem to generate docs"
+end
+
+desc "Update rubyforge documentation"
+task :update_docs => :yardoc do
+  puts %x{rsync -aPz doc/* psadauskas@resourceful.rubyforge.org:/var/www/gforge-projects/resourceful/}
+end