swivel 0.0.146 → 0.0.149

data/vendor/activeresource-2.0.2-/lib/active_resource/validations.rb

@@ -0,0 +1,288 @@
+module ActiveResource
+  class ResourceInvalid < ClientError  #:nodoc:
+  end
+
+  # Active Resource validation is reported to and from this object, which is used by Base#save
+  # to determine whether the object in a valid state to be saved. See usage example in Validations.  
+  class Errors
+    include Enumerable
+    attr_reader :errors
+
+    delegate :empty?, :to => :errors
+    
+    def initialize(base) # :nodoc:
+      @base, @errors = base, {}
+    end
+
+    # Add an error to the base Active Resource object rather than an attribute.
+    #
+    # ==== Examples
+    #   my_folder = Folder.find(1)
+    #   my_folder.errors.add_to_base("You can't edit an existing folder")
+    #   my_folder.errors.on_base
+    #   # => "You can't edit an existing folder"
+    #
+    #   my_folder.errors.add_to_base("This folder has been tagged as frozen")
+    #   my_folder.valid?
+    #   # => false
+    #   my_folder.errors.on_base
+    #   # => ["You can't edit an existing folder", "This folder has been tagged as frozen"]
+    #
+    def add_to_base(msg)
+      add(:base, msg)
+    end
+
+    # Adds an error to an Active Resource object's attribute (named for the +attribute+ parameter)
+    # with the error message in +msg+.
+    #
+    # ==== Examples
+    #   my_resource = Node.find(1)
+    #   my_resource.errors.add('name', 'can not be "base"') if my_resource.name == 'base'
+    #   my_resource.errors.on('name')
+    #   # => 'can not be "base"!'
+    #
+    #   my_resource.errors.add('desc', 'can not be blank') if my_resource.desc == ''
+    #   my_resource.valid?
+    #   # => false
+    #   my_resource.errors.on('desc')
+    #   # => 'can not be blank!'
+    #
+    def add(attribute, msg)
+      @errors[attribute.to_s] = [] if @errors[attribute.to_s].nil?
+      @errors[attribute.to_s] << msg
+    end
+
+    # Returns true if the specified +attribute+ has errors associated with it.
+    #
+    # ==== Examples
+    #   my_resource = Disk.find(1)
+    #   my_resource.errors.add('location', 'must be Main') unless my_resource.location == 'Main'
+    #   my_resource.errors.on('location')
+    #   # => 'must be Main!'
+    #
+    #   my_resource.errors.invalid?('location')
+    #   # => true
+    #   my_resource.errors.invalid?('name')
+    #   # => false
+    def invalid?(attribute)
+      !@errors[attribute.to_s].nil?
+    end
+
+    # A method to return the errors associated with +attribute+, which returns nil, if no errors are 
+    # associated with the specified +attribute+, the error message if one error is associated with the specified +attribute+,
+    # or an array of error messages if more than one error is associated with the specified +attribute+.
+    #
+    # ==== Examples
+    #   my_person = Person.new(params[:person])
+    #   my_person.errors.on('login')
+    #   # => nil
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.errors.on('login')
+    #   # => 'can not be empty'
+    #
+    #   my_person.errors.add('login', 'can not be longer than 10 characters') if my_person.login.length > 10
+    #   my_person.errors.on('login')
+    #   # => ['can not be empty', 'can not be longer than 10 characters']
+    def on(attribute)
+      errors = @errors[attribute.to_s]
+      return nil if errors.nil?
+      errors.size == 1 ? errors.first : errors
+    end
+    
+    alias :[] :on
+
+    # A method to return errors assigned to +base+ object through add_to_base, which returns nil, if no errors are 
+    # associated with the specified +attribute+, the error message if one error is associated with the specified +attribute+,
+    # or an array of error messages if more than one error is associated with the specified +attribute+.
+    #
+    # ==== Examples
+    #   my_account = Account.find(1)
+    #   my_account.errors.on_base
+    #   # => nil
+    #
+    #   my_account.errors.add_to_base("This account is frozen")
+    #   my_account.errors.on_base
+    #   # => "This account is frozen"
+    #
+    #   my_account.errors.add_to_base("This account has been closed")
+    #   my_account.errors.on_base
+    #   # => ["This account is frozen", "This account has been closed"]
+    #
+    def on_base
+      on(:base)
+    end
+
+    # Yields each attribute and associated message per error added.
+    #
+    # ==== Examples
+    #   my_person = Person.new(params[:person])
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.errors.add('password', 'can not be empty') if my_person.password == ''
+    #   messages = ''
+    #   my_person.errors.each {|attr, msg| messages += attr.humanize + " " + msg + "<br />"}
+    #   messages
+    #   # => "Login can not be empty<br />Password can not be empty<br />"
+    #
+    def each
+      @errors.each_key { |attr| @errors[attr].each { |msg| yield attr, msg } }
+    end
+
+    # Yields each full error message added. So Person.errors.add("first_name", "can't be empty") will be returned
+    # through iteration as "First name can't be empty".
+    #
+    # ==== Examples
+    #   my_person = Person.new(params[:person])
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.errors.add('password', 'can not be empty') if my_person.password == ''
+    #   messages = ''
+    #   my_person.errors.each_full {|msg| messages += msg + "<br/>"}
+    #   messages
+    #   # => "Login can not be empty<br />Password can not be empty<br />"
+    #
+    def each_full
+      full_messages.each { |msg| yield msg }
+    end
+
+    # Returns all the full error messages in an array.
+    #
+    # ==== Examples
+    #   my_person = Person.new(params[:person])
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.errors.add('password', 'can not be empty') if my_person.password == ''
+    #   messages = ''
+    #   my_person.errors.full_messages.each {|msg| messages += msg + "<br/>"}
+    #   messages
+    #   # => "Login can not be empty<br />Password can not be empty<br />"
+    #
+    def full_messages
+      full_messages = []
+
+      @errors.each_key do |attr|
+        @errors[attr].each do |msg|
+          next if msg.nil?
+
+          if attr == "base"
+            full_messages << msg
+          else
+            full_messages << [attr.humanize, msg].join(' ')
+          end
+        end
+      end
+      full_messages
+    end
+
+    def clear
+      @errors = {}
+    end
+
+    # Returns the total number of errors added. Two errors added to the same attribute will be counted as such
+    # with this as well.
+    #
+    # ==== Examples
+    #   my_person = Person.new(params[:person])
+    #   my_person.errors.size
+    #   # => 0
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.errors.add('password', 'can not be empty') if my_person.password == ''
+    #   my_person.error.size
+    #   # => 2
+    #
+    def size
+      @errors.values.inject(0) { |error_count, attribute| error_count + attribute.size }
+    end
+
+    alias_method :count, :size
+    alias_method :length, :size
+    
+    # Grabs errors from the XML response.
+    def from_xml(xml)
+      clear
+      humanized_attributes = @base.attributes.keys.inject({}) { |h, attr_name| h.update(attr_name.humanize => attr_name) }
+      messages = Hash.from_xml(xml)['errors']['error'] rescue []
+      messages.each do |message|
+        attr_message = humanized_attributes.keys.detect do |attr_name|
+          if message[0, attr_name.size + 1] == "#{attr_name} "
+            add humanized_attributes[attr_name], message[(attr_name.size + 1)..-1]
+          end
+        end
+        
+        add_to_base message if attr_message.nil?
+      end
+    end
+  end
+  
+  # Module to allow validation of ActiveResource objects, which creates an Errors instance for every resource.
+  # Methods are implemented by overriding +Base#validate+ or its variants   Each of these methods can inspect 
+  # the state of the object, which usually means  ensuring that a number of attributes have a certain value 
+  # (such as not empty, within a given range, matching a certain regular expression and so on).
+  #
+  # ==== Example
+  #
+  #   class Person < ActiveResource::Base
+  #      self.site = "http://www.localhost.com:3000/"
+  #      protected
+  #        def validate
+  #          errors.add_on_empty %w( first_name last_name )
+  #          errors.add("phone_number", "has invalid format") unless phone_number =~ /[0-9]*/
+  #        end
+  #
+  #        def validate_on_create # is only run the first time a new object is saved
+  #          unless valid_member?(self)
+  #            errors.add("membership_discount", "has expired")
+  #          end
+  #        end
+  #
+  #        def validate_on_update
+  #          errors.add_to_base("No changes have occurred") if unchanged_attributes?
+  #        end
+  #   end
+  #   
+  #   person = Person.new("first_name" => "Jim", "phone_number" => "I will not tell you.")
+  #   person.save                         # => false (and doesn't do the save)
+  #   person.errors.empty?                # => false
+  #   person.errors.count                 # => 2
+  #   person.errors.on "last_name"        # => "can't be empty"
+  #   person.attributes = { "last_name" => "Halpert", "phone_number" => "555-5555" }
+  #   person.save                         # => true (and person is now saved to the remote service)
+  #
+  module Validations
+    def self.included(base) # :nodoc:
+      base.class_eval do
+        alias_method_chain :save, :validation
+      end
+    end
+
+    # Validate a resource and save (POST) it to the remote web service.
+    def save_with_validation
+      save_without_validation
+      true
+    rescue ResourceInvalid => error
+      errors.from_xml(error.response.body)
+      false
+    end
+
+    # Checks for errors on an object (i.e., is resource.errors empty?).
+    # 
+    # ==== Examples
+    #   my_person = Person.create(params[:person])
+    #   my_person.valid?
+    #   # => true
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.valid?
+    #   # => false
+    def valid?
+      errors.empty?
+    end
+
+    # Returns the Errors object that holds all information about attribute error messages.
+    def errors
+      @errors ||= Errors.new(self)
+    end
+  end
+end

data/vendor/activeresource-2.0.2-/lib/active_resource/version.rb

@@ -0,0 +1,9 @@
+module ActiveResource
+  module VERSION #:nodoc:
+    MAJOR = 2
+    MINOR = 0
+    TINY  = 2
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/vendor/activeresource-2.0.2-/lib/activeresource.rb

@@ -0,0 +1 @@
+require 'active_resource'

data/vendor/activeresource-2.0.2-/test/abstract_unit.rb

@@ -0,0 +1,10 @@
+require 'test/unit'
+
+$:.unshift "#{File.dirname(__FILE__)}/../lib"
+require 'active_resource'
+require 'active_resource/http_mock'
+
+$:.unshift "#{File.dirname(__FILE__)}/../test"
+require 'setter_trap'
+
+ActiveResource::Base.logger = Logger.new("#{File.dirname(__FILE__)}/debug.log")

data/vendor/activeresource-2.0.2-/test/authorization_test.rb

@@ -0,0 +1,82 @@
+require "#{File.dirname(__FILE__)}/abstract_unit"
+require 'base64'
+
+class AuthorizationTest < Test::Unit::TestCase
+  Response = Struct.new(:code)
+
+  def setup
+    @conn = ActiveResource::Connection.new('http://localhost')
+    @matz  = { :id => 1, :name => 'Matz' }.to_xml(:root => 'person')
+    @david = { :id => 2, :name => 'David' }.to_xml(:root => 'person')
+    @authenticated_conn = ActiveResource::Connection.new("http://david:test123@localhost")
+    @authorization_request_header = { 'Authorization' => 'Basic ZGF2aWQ6dGVzdDEyMw==' }
+
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.get    "/people/2.xml",           @authorization_request_header, @david
+      mock.put    "/people/2.xml",           @authorization_request_header, nil, 204
+      mock.delete "/people/2.xml",           @authorization_request_header, nil, 200
+      mock.post   "/people/2/addresses.xml", @authorization_request_header, nil, 201, 'Location' => '/people/1/addresses/5'
+    end
+  end
+
+  def test_authorization_header
+    authorization_header = @authenticated_conn.send!(:authorization_header)
+    assert_equal @authorization_request_header['Authorization'], authorization_header['Authorization']
+    authorization = authorization_header["Authorization"].to_s.split
+    
+    assert_equal "Basic", authorization[0]
+    assert_equal ["david", "test123"], Base64.decode64(authorization[1]).split(":")[0..1]
+  end
+  
+  def test_authorization_header_with_username_but_no_password
+    @conn = ActiveResource::Connection.new("http://david:@localhost")
+    authorization_header = @conn.send!(:authorization_header)
+    authorization = authorization_header["Authorization"].to_s.split
+    
+    assert_equal "Basic", authorization[0]
+    assert_equal ["david"], Base64.decode64(authorization[1]).split(":")[0..1]
+  end
+  
+  def test_authorization_header_with_password_but_no_username
+    @conn = ActiveResource::Connection.new("http://:test123@localhost")
+    authorization_header = @conn.send!(:authorization_header)
+    authorization = authorization_header["Authorization"].to_s.split
+    
+    assert_equal "Basic", authorization[0]
+    assert_equal ["", "test123"], Base64.decode64(authorization[1]).split(":")[0..1]
+  end
+  
+  def test_get
+    david = @authenticated_conn.get("/people/2.xml")
+    assert_equal "David", david["name"]
+  end
+  
+  def test_post
+    response = @authenticated_conn.post("/people/2/addresses.xml")
+    assert_equal "/people/1/addresses/5", response["Location"]
+  end
+  
+  def test_put
+    response = @authenticated_conn.put("/people/2.xml")
+    assert_equal 204, response.code
+  end
+  
+  def test_delete
+    response = @authenticated_conn.delete("/people/2.xml")
+    assert_equal 200, response.code
+  end
+
+  def test_raises_invalid_request_on_unauthorized_requests
+    assert_raises(ActiveResource::InvalidRequestError) { @conn.post("/people/2.xml") }
+    assert_raises(ActiveResource::InvalidRequestError) { @conn.post("/people/2/addresses.xml") }
+    assert_raises(ActiveResource::InvalidRequestError) { @conn.put("/people/2.xml") }
+    assert_raises(ActiveResource::InvalidRequestError) { @conn.delete("/people/2.xml") }
+  end
+
+  protected
+    def assert_response_raises(klass, code)
+      assert_raise(klass, "Expected response code #{code} to raise #{klass}") do
+        @conn.send!(:handle_response, Response.new(code))
+      end
+    end
+end

data/vendor/activeresource-2.0.2-/test/base/custom_methods_test.rb

@@ -0,0 +1,96 @@
+require "#{File.dirname(__FILE__)}/../abstract_unit"
+require "#{File.dirname(__FILE__)}/../fixtures/person"
+require "#{File.dirname(__FILE__)}/../fixtures/street_address"
+
+class CustomMethodsTest < Test::Unit::TestCase
+  def setup
+    @matz  = { :id => 1, :name => 'Matz' }.to_xml(:root => 'person')
+    @matz_deep  = { :id => 1, :name => 'Matz', :other => 'other' }.to_xml(:root => 'person')
+    @matz_array = [{ :id => 1, :name => 'Matz' }].to_xml(:root => 'people')
+    @ryan  = { :name => 'Ryan' }.to_xml(:root => 'person')
+    @addy  = { :id => 1, :street => '12345 Street' }.to_xml(:root => 'address')
+    @addy_deep  = { :id => 1, :street => '12345 Street', :zip => "27519" }.to_xml(:root => 'address')
+    @default_request_headers = { 'Content-Type' => 'application/xml' }
+    
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.get    "/people/1.xml",             {}, @matz
+      mock.get    "/people/1/shallow.xml", {}, @matz
+      mock.get    "/people/1/deep.xml", {}, @matz_deep
+      mock.get    "/people/retrieve.xml?name=Matz", {}, @matz_array
+      mock.get    "/people/managers.xml", {}, @matz_array
+      mock.post   "/people/hire.xml?name=Matz", {}, nil, 201
+      mock.put    "/people/1/promote.xml?position=Manager", {}, nil, 204
+      mock.put    "/people/promote.xml?name=Matz", {}, nil, 204, {}
+      mock.put    "/people/sort.xml?by=name", {}, nil, 204
+      mock.delete "/people/deactivate.xml?name=Matz", {}, nil, 200
+      mock.delete "/people/1/deactivate.xml", {}, nil, 200
+      mock.post   "/people/new/register.xml",      {}, @ryan, 201, 'Location' => '/people/5.xml'
+      mock.post   "/people/1/register.xml", {}, @matz, 201
+      mock.get    "/people/1/addresses/1.xml", {}, @addy
+      mock.get    "/people/1/addresses/1/deep.xml", {}, @addy_deep
+      mock.put    "/people/1/addresses/1/normalize_phone.xml?locale=US", {}, nil, 204
+      mock.put    "/people/1/addresses/sort.xml?by=name", {}, nil, 204
+      mock.post   "/people/1/addresses/new/link.xml", {}, { :street => '12345 Street' }.to_xml(:root => 'address'), 201, 'Location' => '/people/1/addresses/2.xml'
+    end
+  end  
+
+  def teardown
+    ActiveResource::HttpMock.reset!
+  end
+
+  def test_custom_collection_method
+    # GET
+    assert_equal([{ "id" => 1, "name" => 'Matz' }], Person.get(:retrieve, :name => 'Matz'))
+
+    # POST
+    assert_equal(ActiveResource::Response.new("", 201, {}), Person.post(:hire, :name => 'Matz'))
+
+    # PUT
+    assert_equal ActiveResource::Response.new("", 204, {}),
+                   Person.put(:promote, {:name => 'Matz'}, 'atestbody')
+    assert_equal ActiveResource::Response.new("", 204, {}), Person.put(:sort, :by => 'name')
+
+    # DELETE
+    Person.delete :deactivate, :name => 'Matz'
+
+    # Nested resource
+    assert_equal ActiveResource::Response.new("", 204, {}), StreetAddress.put(:sort, :person_id => 1, :by => 'name')
+  end
+
+  def test_custom_element_method
+    # Test GET against an element URL
+    assert_equal Person.find(1).get(:shallow), {"id" => 1, "name" => 'Matz'}
+    assert_equal Person.find(1).get(:deep), {"id" => 1, "name" => 'Matz', "other" => 'other'}
+    
+    # Test PUT against an element URL
+    assert_equal ActiveResource::Response.new("", 204, {}), Person.find(1).put(:promote, {:position => 'Manager'}, 'body')
+    
+    # Test DELETE against an element URL
+    assert_equal ActiveResource::Response.new("", 200, {}), Person.find(1).delete(:deactivate)
+    
+    # With nested resources
+    assert_equal StreetAddress.find(1, :params => { :person_id => 1 }).get(:deep),
+                  { "id" => 1, "street" => '12345 Street', "zip" => "27519" }
+    assert_equal ActiveResource::Response.new("", 204, {}),
+                   StreetAddress.find(1, :params => { :person_id => 1 }).put(:normalize_phone, :locale => 'US')
+  end
+
+  def test_custom_new_element_method
+    # Test POST against a new element URL
+    ryan = Person.new(:name => 'Ryan')
+    assert_equal ActiveResource::Response.new(@ryan, 201, {'Location' => '/people/5.xml'}), ryan.post(:register)
+
+    # Test POST against a nested collection URL
+    addy = StreetAddress.new(:street => '123 Test Dr.', :person_id => 1)
+    assert_equal ActiveResource::Response.new({ :street => '12345 Street' }.to_xml(:root => 'address'), 
+                   201, {'Location' => '/people/1/addresses/2.xml'}),
+                 addy.post(:link)
+
+    matz = Person.new(:id => 1, :name => 'Matz')
+    assert_equal ActiveResource::Response.new(@matz, 201), matz.post(:register)
+  end
+
+  def test_find_custom_resources
+    assert_equal 'Matz', Person.find(:all, :from => :managers).first.name
+  end
+end