abiquo-etk 0.4.13

data/vendor/fattr-2.1.0/a.rb

@@ -0,0 +1,42 @@
+require 'rubygems'
+require 'fattr'
+
+class A
+  class << A
+    fattr(:x, :inheritable => true){ 42 }
+  end
+end
+
+class B < A; end
+
+class C < B; end
+
+
+p C.x
+p B.x
+p A.x
+puts
+
+B.x = 42.0
+
+p C.x
+p B.x
+p A.x
+puts
+
+C.x! # force re-initialization from parent(s)
+
+p C.x
+p B.x
+p A.x
+puts
+
+
+class K
+end
+module M
+  fattr(:x, :inheritable => true){ 42 }
+end
+K.extend(M)
+
+p K.x

data/vendor/fattr-2.1.0/fattr.gemspec

@@ -0,0 +1,29 @@
+## fattr.gemspec
+#
+
+Gem::Specification::new do |spec|
+  spec.name = "fattr"
+  spec.description = 'fattr.rb is a "fatter attr" for ruby'  
+  spec.version = "2.1.0"
+  spec.platform = Gem::Platform::RUBY
+  spec.summary = "fattr"
+
+  spec.files = ["a.rb", "fattr.gemspec", "lib", "lib/fattr.rb", "Rakefile", "README", "README.erb", "samples", "samples/a.rb", "samples/b.rb", "samples/c.rb", "samples/d.rb", "samples/e.rb", "samples/f.rb", "samples/g.rb", "samples/h.rb", "test", "test/fattr.rb"]
+  spec.executables = []
+  
+  
+  spec.require_path = "lib"
+  
+
+  spec.has_rdoc = true
+  spec.test_files = "test/fattr.rb"
+  #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/fattr/tree/master"
+end

data/vendor/fattr-2.1.0/lib/fattr.rb

@@ -0,0 +1,193 @@
+module Fattr
+  Fattr::Version = '2.1.0' unless Fattr.const_defined?(:Version)
+  def self.version() Fattr::Version end
+
+  class List < ::Array
+    def << element
+      super
+      self
+    ensure
+      uniq!
+      index!
+    end
+
+    def index!
+      @index ||= Hash.new
+      each{|element| @index[element.to_s] = true}
+    end
+
+    def include?(element)
+      @index ||= Hash.new
+      @index[element.to_s] ? true : false
+    end
+
+    def initializers
+      @initializers ||= Hash.new
+    end
+  end
+
+  def fattrs(*args, &block)
+    unless args.empty?
+      returned = Hash.new
+
+      args.flatten!
+      args.compact!
+
+      all_hashes = args.all?{|arg| Hash===arg}
+
+      names_and_configs = {}
+
+      if all_hashes
+        args.each do |hash|
+          hash.each do |key, val|
+            name = key.to_s
+            config = Hash===val ? val : {:default => val}
+            names_and_configs[name] = config
+          end
+        end
+      else
+        config = Hash===args.last ? args.pop : {}
+        names = args.select{|arg| Symbol===arg or String===arg}.map{|arg| arg.to_s}
+        names.each do |name|
+          names_and_configs[name] = config
+        end
+      end
+
+      initializers = __fattrs__.initializers
+
+      names_and_configs.each do |name, config|
+        raise(NameError, "bad instance variable name '@#{ name }'") if("@#{ name }" =~ %r/[!?=]$/o)
+
+        name = name.to_s
+
+        default = nil
+        default = config[:default] if config.has_key?(:default)
+        default = config['default'] if config.has_key?('default')
+
+        inheritable = false
+        if Module===self
+          inheritable = config[:inheritable] if config.has_key?(:inheritable)
+          inheritable = config['inheritable'] if config.has_key?('inheritable')
+        end
+
+        initialize = (
+          if inheritable
+            lambda do
+              parents = ancestors[1..-1]
+              catch(:value) do
+                parents.each do |parent|
+                  throw(:value, parent.send(name)) if parent.respond_to?(name)
+                end
+                block ? block.call : default
+              end
+            end
+          else
+            block || lambda{ default }
+          end
+        )
+
+        initializer = lambda do |this|
+          Object.instance_method('instance_eval').bind(this).call(&initialize)
+        end
+
+        initializer_id = initializer.object_id
+
+        __fattrs__.initializers[name] = initializer
+
+        compile = lambda do |code|
+          begin
+            module_eval(code)
+          rescue SyntaxError
+            raise(SyntaxError, "\n#{ code }\n")
+          end
+        end
+
+      # setter, block invocation caches block
+        code = <<-code
+          def #{ name }=(*value, &block)
+            value.unshift block if block
+            @#{ name } = value.first
+          end
+        code
+        compile[code]
+
+      # getter, providing a value or block causes it to acts as setter
+        code = <<-code
+          def #{ name }(*value, &block)
+            value.unshift block if block
+            return self.send('#{ name }=', value.first) unless value.empty?
+            #{ name }! unless defined? @#{ name }
+            @#{ name }
+          end
+        code
+        compile[code]
+
+      # bang method re-calls any initializer given at declaration time
+        code = <<-code
+          def #{ name }!
+            initializer = ObjectSpace._id2ref #{ initializer_id }
+            self.#{ name } = initializer.call(self)
+            @#{ name }
+          end
+        code
+        compile[code]
+
+      # query simply defers to getter - cast to bool
+        code = <<-code
+          def #{ name }?
+            self.#{ name }
+          end
+        code
+        compile[code]
+
+        fattrs << name
+        returned[name] = initializer 
+      end
+
+      returned
+    else
+      begin
+        __fattr_list__
+      rescue NameError
+        singleton_class =
+          class << self
+            self
+          end
+        klass = self
+        singleton_class.module_eval do
+          fattr_list = List.new 
+          define_method('fattr_list'){ klass == self ? fattr_list : raise(NameError) }
+          alias_method '__fattr_list__', 'fattr_list'
+        end
+        __fattr_list__
+      end
+    end
+  end
+
+  %w( __fattrs__ __fattr__ fattr ).each{|dst| alias_method(dst, 'fattrs')}
+end
+
+class Module
+  include Fattr
+
+  def Fattrs(*args, &block)
+    class << self
+      self
+    end.module_eval{ __fattrs__(*args, &block) }
+  end
+
+  def Fattr(*args, &block)
+    class << self
+      self
+    end.module_eval{ __fattr__(*args, &block) }
+  end
+end
+
+class Object
+  def fattrs(*args, &block)
+    class << self
+      self
+    end.__fattrs__(*args, &block)
+  end
+  %w( __fattrs__ __fattr__ fattr ).each{|dst| alias_method(dst, 'fattrs')}
+end

data/vendor/fattr-2.1.0/samples/a.rb

@@ -0,0 +1,21 @@
+#
+# basic usage is like attr, but note that fattr defines a suite of methods
+#
+  require 'fattr'
+
+  class C
+    fattr 'a'
+  end
+
+  c = C.new
+
+  c.a = 42
+  p c.a                 #=> 42
+  p 'forty-two' if c.a? #=> 'forty-two'
+
+#
+# fattrs works on object too 
+#
+  o = Object.new
+  o.fattr 'answer' => 42
+  p o.answer           #=> 42

data/vendor/fattr-2.1.0/samples/b.rb

@@ -0,0 +1,22 @@
+#
+# default values may be given either directly or as a block which will be
+# evaluated in the context of self.  in both cases (value or block) the
+# default is set only once and only if needed - it's a lazy evaluation.  the
+# 'banger' method can be used to re-initialize a variable at any point whether
+# or not it's already been initialized.
+#
+  require 'fattr'
+
+  class C
+    fattr :a => 42
+    fattr(:b){ Float a }
+  end
+
+  c = C.new
+  p c.a #=> 42
+  p c.b #=> 42.0
+
+  c.a = 43
+  p c.a #=> 43
+  c.a!
+  p c.a #=> 42

data/vendor/fattr-2.1.0/samples/c.rb

@@ -0,0 +1,12 @@
+#
+# multiple name=>default pairs can be given 
+#
+  require 'fattr'
+
+  class C
+    fattrs 'x' => 0b101000, 'y' => 0b10
+  end
+
+  c = C.new
+  z = c.x + c.y
+  p z #=> 42

data/vendor/fattr-2.1.0/samples/d.rb

@@ -0,0 +1,34 @@
+#
+# a nice feature is that all fattrs are enumerated in the class.  this,
+# combined with the fact that the getter method is defined so as to delegate
+# to the setter when an argument is given, means bulk initialization and/or
+# fattr traversal is very easy.
+#
+  require 'fattr'
+
+  class C
+    fattrs %w( x y z )
+
+    def fattrs
+      self.class.fattrs
+    end
+
+    def initialize
+      fattrs.each_with_index{|a,i| send a, i}
+    end
+
+    def to_hash
+      fattrs.inject({}){|h,a| h.update a => send(a)}
+    end
+
+    def inspect
+      to_hash.inspect
+    end
+  end
+
+  c = C.new
+  p c.fattrs 
+  p c 
+
+  c.x 'forty-two' 
+  p c.x

data/vendor/fattr-2.1.0/samples/e.rb

@@ -0,0 +1,17 @@
+#
+# my favourite element of fattrs is that getters can also be setters.
+# this allows incredibly clean looking code like
+#
+  require 'fattr'
+
+  class Config
+    fattrs %w( host port)
+    def initialize(&block) instance_eval &block end
+  end
+
+  conf = Config.new{
+    host 'codeforpeople.org'
+    port 80
+  }
+
+  p conf

data/vendor/fattr-2.1.0/samples/f.rb

@@ -0,0 +1,21 @@
+#
+# of course fattrs works as well at class/module level as at instance
+# level
+#
+  require 'fattr'
+
+  module Logging 
+    Level_names = {
+      0 => 'INFO',
+      # ...
+      42 => 'DEBUG',
+    }
+
+    class << Logging
+      fattr 'level' => 42
+      fattr('level_name'){ Level_names[level] }
+    end
+  end
+
+p Logging.level
+p Logging.level_name

data/vendor/fattr-2.1.0/samples/g.rb

@@ -0,0 +1,15 @@
+#
+# you can add class/module fattrs the 'normal' way or using the provided
+# shortcut method
+#
+  require 'fattr'
+
+  class C
+    class << C
+      fattr 'a' => 4
+    end
+
+    Fattr 'b' => 2
+  end
+
+  p [ C.a, C.b ].join

data/vendor/fattr-2.1.0/samples/h.rb

@@ -0,0 +1,29 @@
+#
+# class variable inheritance is supported simply
+#
+  require 'fattr'
+
+  class A
+    Fattr :x, :default => 42, :inheritable => true
+  end
+
+  class B < A
+  end
+
+  class C < B
+  end
+
+  p C.x #=> 42
+
+  A.x = 42.0
+  B.x = 'forty-two'
+
+  p A.x #=> 42.0
+  p B.x #=> 'forty-two'
+  p C.x #=> 42
+
+  C.x! # re-initialize from closest ancestor (B)
+
+  p A.x #=> 42.0
+  p B.x #=> 'forty-two'
+  p C.x #=> 'forty-two'

data/vendor/fattr-2.1.0/test/fattr.rb

@@ -0,0 +1,166 @@
+require 'fattr'
+
+Testing Fattr do
+  testing 'that a basic set of methods are defined' do
+    o = Class.new{ fattr :a }.new
+    %w( a a= a? ).each do |msg|
+      assert("respond_to?(#{ msg.inspect })"){ o.respond_to?(msg) }
+    end
+  end
+
+  testing 'that the basic usage works' do
+    o = Class.new{ fattr :a }.new
+    assert{ o.a==nil }
+    assert{ o.a=42 }
+    assert{ o.a(42.0) }
+    assert{ o.a? }
+  end
+
+  testing 'that simple defaults work' do
+    o = Class.new{ fattr :a => 42 }.new
+    assert{ o.a==42 }
+  end
+
+  testing 'that block defaults work' do
+    n = 41
+    o = Class.new{ fattr(:a){ n += 1 } }.new
+    assert{ o.a==42 }
+    assert{ n==42 }
+  end
+
+  testing 'that > 1 fattrs can be defined at once' do
+    o = Class.new{ fattr :a, :b }.new
+    %w( a a= a? b b= b? ).each do |msg|
+      assert("respond_to?(#{ msg.inspect })"){ o.respond_to?(msg) }
+    end
+  end
+
+  testing 'that > 1 fattrs with defaults can be defined at once' do
+    o = Class.new{ fattr :a => 40, :b => 2 }.new
+    assert{ o.a+o.b==42 }
+  end
+
+  testing 'that fattrs can be retrieved from the object' do
+    c = Class.new{ fattr :a, :b, :c; self }
+    assert{ c.fattrs.sort === %w[a b c] }
+  end
+
+  testing 'getters as setters' do
+    o = Class.new{ fattr :a }.new
+    assert{ o.a(42) }
+    assert{ o.a==42 }
+  end
+
+  testing 'module fattrs' do
+    m = Module.new{ class << self; fattr :a => 42; end; }
+    assert{ m.a==42 }
+  end
+
+  testing 'module fattr shortcut' do
+    m = Module.new{ Fattr :a => 42 }
+    assert{ m.a==42 }
+  end
+
+  testing 'that fattrs support simple class inheritable attributes' do
+    a = Class.new{ Fattr :x, :default => 42, :inheritable => true }
+    b = Class.new(a)
+    c = Class.new(b)
+
+    def a.name() 'a' end
+    def b.name() 'b' end
+    def c.name() 'c' end
+
+    assert{ c.x==42 }
+    assert{ b.x==42 }
+    assert{ a.x==42 }
+
+    assert{ b.x=42.0 }
+    assert{ b.x==42.0 }
+    assert{ a.x==42 }
+
+    assert{ a.x='forty-two' }
+    assert{ a.x=='forty-two' }
+    assert{ b.x==42.0 }
+
+    assert{ b.x! }
+    assert{ b.x=='forty-two' }
+    assert{ b.x='FORTY-TWO' }
+
+    assert{ c.x! }
+    assert{ c.x=='FORTY-TWO' }
+  end
+
+  testing 'a list of fattrs can be declared at once' do
+    list = %w( a b c )
+    c = Class.new{ fattrs list }
+    list.each do |attr|
+      assert{ c.fattrs.include?(attr.to_s) }
+      assert{ c.fattrs.include?(attr.to_sym) }
+    end
+  end
+end
+
+
+
+
+
+
+
+BEGIN {
+  require 'test/unit'
+  STDOUT.sync = true
+  $:.unshift 'lib'
+  $:.unshift '../lib'
+  $:.unshift '.'
+
+  def Testing(*args, &block)
+    Class.new(Test::Unit::TestCase) do
+      def self.slug_for(*args)
+        string = args.flatten.compact.join('-')
+        words = string.to_s.scan(%r/\w+/)
+        words.map!{|word| word.gsub %r/[^0-9a-zA-Z_-]/, ''}
+        words.delete_if{|word| word.nil? or word.strip.empty?}
+        words.join('-').downcase
+      end
+
+      @@testing_subclass_count = 0 unless defined?(@@testing_subclass_count) 
+      @@testing_subclass_count += 1
+      slug = slug_for(*args).gsub(%r/-/,'_')
+      name = ['TESTING', '%03d' % @@testing_subclass_count, slug].delete_if{|part| part.empty?}.join('_')
+      name = name.upcase!
+      const_set(:Name, name)
+      def self.name() const_get(:Name) end
+
+      def self.testno()
+        '%05d' % (@testno ||= 0)
+      ensure
+        @testno += 1
+      end
+
+      def self.testing(*args, &block)
+        method = ["test", testno, slug_for(*args)].delete_if{|part| part.empty?}.join('_')
+        define_method("test_#{ testno }_#{ slug_for(*args) }", &block)
+      end
+
+      alias_method '__assert__', 'assert'
+
+      def assert(*args, &block)
+        if block
+          label = "assert(#{ args.join ' ' })"
+          result = nil
+          assert_nothing_raised{ result = block.call }
+          __assert__(result, label)
+          result
+        else
+          result = args.shift
+          label = "assert(#{ args.join ' ' })"
+          __assert__(result, label)
+          result
+        end
+      end
+
+      module_eval &block
+      self
+    end
+  end
+}

data/vendor/httpauth-0.1/LICENSE

@@ -0,0 +1,16 @@
+HTTPauth is an HTTP Authentication library for Ruby
+Copyright (C) 2006 Fingertips, Manfred Stienstra <m.stienstra@fngtps.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

data/vendor/httpauth-0.1/README

@@ -0,0 +1,39 @@
+= README
+
+HTTPauth is a library supporting the full HTTP Authentication protocol as specified in RFC 2617; both Digest Authentication and Basic Authentication. We aim to make HTTPAuth as compliant as possible.
+
+HTTPAuth is built to be completely agnostic of the HTTP implementation. If you have access to your webserver's headers you can use this library to implement authentication.
+
+This project is currently under development, don't use it in mission critical applications.
+
+== Getting started
+
+If you want to implement authentication for your application you should probably start by looking at the various examples. In the examples directory is an implementation of an HTTP client and server, you can use these to test your implementation. The examples are basic implementations of the protocol.
+
+== Limitations
+
+Currently the library doesn't check for consistency of the directives in the various headers, this means that implementations using this library can be vulnerable to request replay attacks. This will obviously be addressed before the final release.
+
+== Plugins
+
+=== Ruby on Rails
+
+A plugin for Ruby on Rails can be found here:
+
+https://fngtps.com/svn/rails-plugins/trunk/digest_authentication
+
+== Known client implementation issues
+
+=== Safari
+
+Safari doesn't understand and parse the algorithm and qop directives correctly. For instance: it sends qop=auth as qop="auth" and when multiple qop values are suggested by the server, no authentication is triggered. See http://bugzilla.opendarwin.org/show_bug.cgi?id=10727.
+
+== Internet Explorer
+
+The qop and algorithm bug quoting bugs are also present in IE.
+
+IE doesn't use the full URI for digest calculation, it chops off the query parameters. So a request on /script?q=a will response with uri='/script'.
+
+== Known server implementation issues
+
+Apache 2.0 sends Authorization-Info headers without a nextnonce directive.