abiquo-etk 0.6.0 → 0.6.1

data/vendor/abiquo-0.1.2/lib/core_ext.rb

@@ -0,0 +1,381 @@
+require 'net/http'
+
+#
+# Stolen from activesupport 2.3.8
+#
+class Module
+  # Provides a delegate class method to easily expose contained objects' methods
+  # as your own. Pass one or more methods (specified as symbols or strings)
+  # and the name of the target object as the final <tt>:to</tt> option (also a symbol
+  # or string).  At least one method and the <tt>:to</tt> option are required.
+  #
+  # Delegation is particularly useful with Active Record associations:
+  #
+  #   class Greeter < ActiveRecord::Base
+  #     def hello()   "hello"   end
+  #     def goodbye() "goodbye" end
+  #   end
+  #
+  #   class Foo < ActiveRecord::Base
+  #     belongs_to :greeter
+  #     delegate :hello, :to => :greeter
+  #   end
+  #
+  #   Foo.new.hello   # => "hello"
+  #   Foo.new.goodbye # => NoMethodError: undefined method `goodbye' for #<Foo:0x1af30c>
+  #
+  # Multiple delegates to the same target are allowed:
+  #
+  #   class Foo < ActiveRecord::Base
+  #     belongs_to :greeter
+  #     delegate :hello, :goodbye, :to => :greeter
+  #   end
+  #
+  #   Foo.new.goodbye # => "goodbye"
+  #
+  # Methods can be delegated to instance variables, class variables, or constants
+  # by providing them as a symbols:
+  #
+  #   class Foo
+  #     CONSTANT_ARRAY = [0,1,2,3]
+  #     @@class_array  = [4,5,6,7]
+  #     
+  #     def initialize
+  #       @instance_array = [8,9,10,11]
+  #     end
+  #     delegate :sum, :to => :CONSTANT_ARRAY
+  #     delegate :min, :to => :@@class_array
+  #     delegate :max, :to => :@instance_array
+  #   end
+  #
+  #   Foo.new.sum # => 6
+  #   Foo.new.min # => 4
+  #   Foo.new.max # => 11
+  #
+  # Delegates can optionally be prefixed using the <tt>:prefix</tt> option. If the value
+  # is <tt>true</tt>, the delegate methods are prefixed with the name of the object being
+  # delegated to.
+  #
+  #   Person = Struct.new(:name, :address)
+  #
+  #   class Invoice < Struct.new(:client)
+  #     delegate :name, :address, :to => :client, :prefix => true
+  #   end
+  #
+  #   john_doe = Person.new("John Doe", "Vimmersvej 13")
+  #   invoice = Invoice.new(john_doe)
+  #   invoice.client_name    # => "John Doe"
+  #   invoice.client_address # => "Vimmersvej 13"
+  #
+  # It is also possible to supply a custom prefix.
+  #
+  #   class Invoice < Struct.new(:client)
+  #     delegate :name, :address, :to => :client, :prefix => :customer
+  #   end
+  #
+  #   invoice = Invoice.new(john_doe)
+  #   invoice.customer_name    # => "John Doe"
+  #   invoice.customer_address # => "Vimmersvej 13"
+  #
+  # If the object to which you delegate can be nil, you may want to use the
+  # :allow_nil option. In that case, it returns nil instead of raising a
+  # NoMethodError exception:
+  #
+  #  class Foo
+  #    attr_accessor :bar
+  #    def initialize(bar = nil)
+  #      @bar = bar
+  #    end
+  #    delegate :zoo, :to => :bar
+  #  end
+  #
+  #  Foo.new.zoo   # raises NoMethodError exception (you called nil.zoo)
+  #
+  #  class Foo
+  #    attr_accessor :bar
+  #    def initialize(bar = nil)
+  #      @bar = bar
+  #    end
+  #    delegate :zoo, :to => :bar, :allow_nil => true
+  #  end
+  #
+  #  Foo.new.zoo   # returns nil
+  #
+  def delegate(*methods)
+    options = methods.pop
+    unless options.is_a?(Hash) && to = options[:to]
+      raise ArgumentError, "Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, :to => :greeter)."
+    end
+
+    if options[:prefix] == true && options[:to].to_s =~ /^[^a-z_]/
+      raise ArgumentError, "Can only automatically set the delegation prefix when delegating to a method."
+    end
+
+    prefix = options[:prefix] && "#{options[:prefix] == true ? to : options[:prefix]}_"
+
+    file, line = caller.first.split(':', 2)
+    line = line.to_i
+
+    methods.each do |method|
+      on_nil =
+        if options[:allow_nil]
+          'return'
+        else
+          %(raise "#{prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
+        end
+
+      module_eval(<<-EOS, file, line)
+        def #{prefix}#{method}(*args, &block)               # def customer_name(*args, &block)
+          #{to}.__send__(#{method.inspect}, *args, &block)  #   client.__send__(:name, *args, &block)
+        rescue NoMethodError                                # rescue NoMethodError
+          if #{to}.nil?                                     #   if client.nil?
+            #{on_nil}
+          else                                              #   else
+            raise                                           #     raise
+          end                                               #   end
+        end                                                 # end
+      EOS
+    end
+  end
+  # Encapsulates the common pattern of:
+  #
+  #   alias_method :foo_without_feature, :foo
+  #   alias_method :foo, :foo_with_feature
+  #
+  # With this, you simply do:
+  #
+  #   alias_method_chain :foo, :feature
+  #
+  # And both aliases are set up for you.
+  #
+  # Query and bang methods (foo?, foo!) keep the same punctuation:
+  #
+  #   alias_method_chain :foo?, :feature
+  #
+  # is equivalent to
+  #
+  #   alias_method :foo_without_feature?, :foo?
+  #   alias_method :foo?, :foo_with_feature?
+  #
+  # so you can safely chain foo, foo?, and foo! with the same feature.
+  def alias_method_chain(target, feature)
+    # Strip out punctuation on predicates or bang methods since
+    # e.g. target?_without_feature is not a valid method name.
+    aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+    yield(aliased_target, punctuation) if block_given?
+
+    with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"
+
+    alias_method without_method, target
+    alias_method target, with_method
+
+    case
+      when public_method_defined?(without_method)
+        public target
+      when protected_method_defined?(without_method)
+        protected target
+      when private_method_defined?(without_method)
+        private target
+    end
+  end
+
+  # Allows you to make aliases for attributes, which includes
+  # getter, setter, and query methods.
+  #
+  # Example:
+  #
+  #   class Content < ActiveRecord::Base
+  #     # has a title attribute
+  #   end
+  #
+  #   class Email < Content
+  #     alias_attribute :subject, :title
+  #   end
+  #
+  #   e = Email.find(1)
+  #   e.title    # => "Superstars"
+  #   e.subject  # => "Superstars"
+  #   e.subject? # => true
+  #   e.subject = "Megastars"
+  #   e.title    # => "Megastars"
+  def alias_attribute(new_name, old_name)
+    module_eval <<-STR, __FILE__, __LINE__ + 1
+      def #{new_name}; self.#{old_name}; end          # def subject; self.title; end
+      def #{new_name}?; self.#{old_name}?; end        # def subject?; self.title?; end
+      def #{new_name}=(v); self.#{old_name} = v; end  # def subject=(v); self.title = v; end
+    STR
+  end
+end
+
+class Object
+  # Invokes the method identified by the symbol +method+, passing it any arguments 
+  # and/or the block specified, just like the regular Ruby <tt>Object#send</tt> does.
+  #
+  # *Unlike* that method however, a +NoMethodError+ exception will *not* be raised 
+  # and +nil+ will be returned instead, if the receiving object is a +nil+ object or NilClass.
+  #
+  # ==== Examples
+  #
+  # Without try
+  #   @person && @person.name
+  # or
+  #   @person ? @person.name : nil
+  #
+  # With try
+  #   @person.try(:name)
+  #
+  # +try+ also accepts arguments and/or a block, for the method it is trying
+  #   Person.try(:find, 1)
+  #   @people.try(:collect) {|p| p.name}
+  #--
+  # This method definition below is for rdoc purposes only. The alias_method call 
+  # below overrides it as an optimization since +try+ behaves like +Object#send+,
+  # unless called on +NilClass+.
+  def try(method, *args, &block)
+    send(method, *args, &block)
+  end
+  remove_method :try
+  alias_method :try, :__send__
+end
+
+class NilClass
+  def try(*args)
+    nil
+  end
+end
+
+module Resourceful
+  class Resource
+    def options(header = {})
+      request(:options, nil, header)
+    end
+
+    def host_with_port
+      add = Addressable::URI.parse(uri)
+      !add.port.nil? && add.port != 80 ? [add.host, add.port].join(':') : add.host
+    end
+
+    alias_method_chain :host, :port
+  end
+
+  class NetHttpAdapter
+    def net_http_request_class_with_options(method)
+      if method == :options
+        Net::HTTP::Options
+      else
+        net_http_request_class_without_options(method)
+      end
+    end
+
+    alias_method_chain :net_http_request_class, :options
+  end
+end
+
+class Array
+  # Returns a string that represents this array in XML by sending +to_xml+
+  # to each element. Active Record collections delegate their representation
+  # in XML to this method.
+  #
+  # All elements are expected to respond to +to_xml+, if any of them does
+  # not an exception is raised.
+  #
+  # The root node reflects the class name of the first element in plural
+  # if all elements belong to the same type and that's not Hash:
+  #
+  #   customer.projects.to_xml
+  #
+  #   <?xml version="1.0" encoding="UTF-8"?>
+  #   <projects type="array">
+  #     <project>
+  #       <amount type="decimal">20000.0</amount>
+  #       <customer-id type="integer">1567</customer-id>
+  #       <deal-date type="date">2008-04-09</deal-date>
+  #       ...
+  #     </project>
+  #     <project>
+  #       <amount type="decimal">57230.0</amount>
+  #       <customer-id type="integer">1567</customer-id>
+  #       <deal-date type="date">2008-04-15</deal-date>
+  #       ...
+  #     </project>
+  #   </projects>
+  #
+  # Otherwise the root element is "records":
+  #
+  #   [{:foo => 1, :bar => 2}, {:baz => 3}].to_xml
+  #
+  #   <?xml version="1.0" encoding="UTF-8"?>
+  #   <records type="array">
+  #     <record>
+  #       <bar type="integer">2</bar>
+  #       <foo type="integer">1</foo>
+  #     </record>
+  #     <record>
+  #       <baz type="integer">3</baz>
+  #     </record>
+  #   </records>
+  #
+  # If the collection is empty the root element is "nil-classes" by default:
+  #
+  #   [].to_xml
+  #
+  #   <?xml version="1.0" encoding="UTF-8"?>
+  #   <nil-classes type="array"/>
+  #
+  # To ensure a meaningful root element use the <tt>:root</tt> option:
+  #
+  #   customer_with_no_projects.projects.to_xml(:root => "projects")
+  #
+  #   <?xml version="1.0" encoding="UTF-8"?>
+  #   <projects type="array"/>
+  #
+  # By default root children have as node name the one of the root
+  # singularized. You can change it with the <tt>:children</tt> option.
+  #
+  # The +options+ hash is passed downwards:
+  #
+  #   Message.all.to_xml(:skip_types => true)
+  #
+  #   <?xml version="1.0" encoding="UTF-8"?>
+  #   <messages>
+  #     <message>
+  #       <created-at>2008-03-07T09:58:18+01:00</created-at>
+  #       <id>1</id>
+  #       <name>1</name>
+  #       <updated-at>2008-03-07T09:58:18+01:00</updated-at>
+  #       <user-id>1</user-id>
+  #     </message>
+  #   </messages>
+  #
+  def to_xml(options = {})
+    raise "Not all elements respond to to_xml" unless all? { |e| e.respond_to? :to_xml }
+    require 'builder' unless defined?(Builder)
+
+    options = options.dup
+    options[:root]     ||= all? { |e| e.is_a?(first.class) && first.class.to_s != "Hash" } ? first.class.to_s.underscore.pluralize.tr('/', '-') : "records"
+    options[:children] ||= options[:root].singularize
+    options[:indent]   ||= 2
+    options[:builder]  ||= Builder::XmlMarkup.new(:indent => options[:indent])
+
+    root     = options.delete(:root).to_s
+    children = options.delete(:children)
+
+    if !options.has_key?(:dasherize) || options[:dasherize]
+      root = root.dasherize
+    end
+
+    options[:builder].instruct! unless options.delete(:skip_instruct)
+
+    opts = options.merge({ :root => children })
+
+    xml = options[:builder]
+    if empty?
+      xml.tag!(root, options[:skip_types] ? {} : {:type => "array"})
+    else
+      xml.tag!(root, options[:skip_types] ? {} : {:type => "array"}) {
+        yield xml if block_given?
+        each { |e| e.to_xml(opts.merge({ :skip_instruct => true })) }
+      }
+    end
+  end
+end

data/vendor/abiquo-0.1.2/lib/to_xml.rb

@@ -0,0 +1,22 @@
+module Abiquo
+  
+  module ToXml
+    
+    def to_xml_with_links(options = {})
+      if options[:convert_links] && options[:builder]
+        options[:builder].tag!(:link, :rel => options[:root]) do
+          to_xml_without_links(options)
+        end
+      else
+        to_xml_without_links(options)
+      end
+    end
+    
+  end
+  
+end
+
+class Array
+  include Abiquo::ToXml
+  alias_method_chain :to_xml, :links
+end

data/vendor/abiquo-0.1.2/spec/acceptance/create_resource_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+feature "Creating new resources" do
+  
+  scenario "Creating a resource in a collection" do
+    
+    datacenters = Abiquo::Resource("http://abiquo.example.com/api/admin/datacenters", auth)
+
+    stub_auth_request(:options, "http://admin:admin@abiquo.example.com/api/admin/datacenters").
+      to_return(:headers => {'Allow' => 'GET, POST, OPTIONS'})
+
+    stub_auth_request(:post, "http://admin:admin@abiquo.example.com/api/admin/datacenters").with do |req|
+      # we parse because comparing strings is too fragile because of order changing, different indentations, etc.
+      # we're expecting something very close to this:
+      # <datacenter>
+      #   <name>Wadus</name>
+      # </datacenter>
+      Nokogiri.parse(req.body).at_xpath("/datacenter/name").text == "Wadus"
+    end.to_return(:body => %q{
+      <datacenter>
+        <name>Wadus</name>
+        <link rel="edit" href="http://abiquo.example.com/api/admin/datacenters/1"/>
+      </datacenter>
+    })
+    
+    datacenter = datacenters.create(:name => "Wadus")
+    
+    datacenter.should be_a(Abiquo::Resource)
+    datacenter.name.should == "Wadus"
+
+    stub_auth_request(:options, "http://admin:admin@abiquo.example.com/api/admin/datacenters/1").
+      to_return(:headers => {'Allow' => 'GET, PUT, OPTIONS'})
+    
+    stub_auth_request(:get, "http://admin:admin@abiquo.example.com/api/admin/datacenters/1").to_return(:body => %q{
+      <datacenter>
+        <name>Wadus</name>
+        <link rel="edit" href="http://abiquo.example.com/api/admin/datacenters/1"/>
+      </datacenter>
+    })
+
+    datacenter.name == Abiquo::Resource(datacenter.url, auth).name
+  end
+end

data/vendor/abiquo-0.1.2/spec/acceptance/delete_resource_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+feature "Deleting resources" do
+  
+  scenario "return status 200 when delete is allowed" do
+    datacenter = Abiquo::Resource("http://abiquo.example.com/api/admin/datacenters/1", auth)
+    
+    stub_auth_request(:options, "http://admin:admin@abiquo.example.com/api/admin/datacenters/1").
+      to_return(:status => 200, :headers => {'Allow' => 'GET, PUT, OPTIONS, HEAD, DELETE'})
+
+    stub_auth_request(:delete, "http://admin:admin@abiquo.example.com/api/admin/datacenters/1").to_return(:status => 200)
+    
+    datacenter.delete
+    
+    auth_request(:delete, "http://admin:admin@abiquo.example.com/api/admin/datacenters/1").should have_been_made.once
+  end
+
+  scenario "raise Abiquo::NotAllowed when delete is not allowed" do
+    datacenter = Abiquo::Resource("http://abiquo.example.com/api/admin/datacenters/1", auth)
+
+    stub_auth_request(:options, "http://admin:admin@abiquo.example.com/api/admin/datacenters/1").
+      to_return(:status => 200, :headers => {'Allow' => 'GET, PUT, OPTIONS, HEAD'})
+    
+    lambda { datacenter.delete }.should raise_error(Abiquo::NotAllowed)
+  end
+  
+end