directed-edge 0.2.0 → 0.2.1

data/.gitignore

@@ -1,3 +1,4 @@
 coverage
 rdoc
 pkg
+.yardoc

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (C) 2009, Directed Edge, Inc. <info@directededge.com>
+Copyright (C) 2009-2010, Directed Edge, Inc. <info@directededge.com>
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions

data/README.rdoc

@@ -2,16 +2,44 @@
 
 Bindings for the Directed Edge Web-services API
 
-== Note on Patches/Pull Requests
+== Usage
+
+You should have gotten a user name and password from Directed Edge when you
+signed up for an account.  If you don't have one now, you can get one at:
+
+- {Signup for Directed Edge Account}[http://www.directededge.com/signup.html]
+
+You'll use those when instantiating a Directed Edge database object, which will
+be the hub for other operations:
+
+  DE_USER = 'testaccount'
+  DE_PASS = '1234567890abcd'
+
+  database = DirectedEdge::Database.new(DE_USER, DE_PASS)
+
+From there you can create items:
+
+  item1 = DirectedEdge::Item.new(database, 'item_1')
+  item2 = DirectedEdge::Item.new(database, 'item_2')
+
+Push them over to the Directed Edge web service:
+
+  item1.save
+  item2.save
+
+And do stuff with them, like set properties, tags, link them to other items:
+
+  item1['picture'] = 'http://foo.bar.com/1.jpg'
+  item1.add_tag('product')
+  item1.link_to(item2)
+  item1.save
+
+There's more info on the Directed Edge developer site:
+
+- {Getting started for Ruby developers}[http://developer.directededge.com/article/Getting_started_for_Ruby_developers]
+- {Ruby E-Commerce Tutorial}[http://developer.directededge.com/article/Ruby_Bindings_for_E-Commerce_Tutorial]
 
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
 
 == Copyright
 
-Copyright (c) 2009 Directed Edge, Inc. See LICENSE for details.
+Copyright (c) 2009-2010 Directed Edge, Inc. See LICENSE for details.

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.2.1

data/lib/directed_edge.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009 Directed Edge, Inc.
+# Copyright (C) 2009-2010 Directed Edge, Inc.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
@@ -34,13 +34,10 @@ require 'cgi'
 
 module DirectedEdge
 
-  # A hash subclass that tracks the insert order, which is useful when returning
-  # a set of results that include full properties.
+  # @private
 
   class InsertOrderHash < Hash
 
-    # Overridden assignment to track insert order
-
     def []=(key, value)
       store(key, value)
       @insert_order = [] if @insert_order.nil?
@@ -48,13 +45,13 @@ module DirectedEdge
       @insert_order.push(key)
     end
 
-    # Provides an iterator that uses the hash's insert order
-
     def insert_order_each
       @insert_order.each { |key| yield key, fetch(key) } unless @insert_order.nil?
     end
   end
 
+  # @private
+
   class CollectionHash < Hash
     def initialize(type)
       @type = type
@@ -71,13 +68,16 @@ module DirectedEdge
     end
   end
 
-  # Base class used for Database and Item that has some basic resource
-  # grabbing functionality.
+  # @private
 
   class Resource
 
     private
 
+    def initialize(rest_resource)
+      @resource = rest_resource
+    end
+
     # Reads an item from the database and puts it into an XML document.
 
     def read_document(method='', params={})
@@ -85,7 +85,7 @@ module DirectedEdge
       REXML::Document.new(@resource[method].get(:accept => 'text/xml').to_s)
     end
 
-    # Returns an array of the elements from the document matching the given
+    # @return [Array] The elements from the document matching the given
     # element name.
 
     def list_from_document(document, element)
@@ -112,7 +112,7 @@ module DirectedEdge
     # so that they can be passed off to the web services API -- e.g.
     # :foo_bar to 'fooBar'
 
-    def normalize_params(hash)
+    def normalize_params!(hash)
       hash.each do |key, value|
         if !key.is_a?(String)
           hash.delete(key)
@@ -156,28 +156,48 @@ module DirectedEdge
     attr_reader :resource
 
     # Creates a connection to a Directed Edge database.  The name and password
-    # should have been provided when the account was created.  The protocol
-    # parameter is optional and may be <tt>http</tt> or <tt>https</tt>.
-    # <tt>http</tt> is used by default as it is somewhat lower latency.
+    # should have been provided when the account was created.
+    #
+    # @param [String] name User name given when the Directed Edge account was
+    #  created.
+    # @param [String] password Password given when the Directed Edge account was
+    #  created.
+    # @param [String] protocol The protocol to connect to the Directed Edge
+    #  webservices with.
+    #
+    # @return [DirectedEdge::Item]
 
-    def initialize(name, password='', protocol='http')
+    def initialize(name, password='', protocol='http', options = {})
       @name = name
-      host = ENV['DIRECTEDEDGE_HOST'] || 'webservices.directededge.com'
-      @resource =
-        RestClient::Resource.new("#{protocol}://#{name}:#{password}@#{host}/api/v1/#{name}")
+      host = options[:host] || ENV['DIRECTEDEDGE_HOST'] || 'webservices.directededge.com'
+      url = "#{protocol}://#{name}:#{password}@#{host}/api/v1/#{name}"
+
+      options[:timeout] ||= 10
+
+      super(RestClient::Resource.new(url, options))
     end
 
     # Imports a Directed Edge XML file to the database.
     #
-    # See http://developer.directededge.com for more information on the XML format or the
-    # Exporter for help on creating a file for importing.
+    # @see Exporter
+    # 
+    # @see {Developer site}[http://developer.directededge.com/] for more information
+    # on the XML format.
 
     def import(file_name)
       @resource.put(File.read(file_name), :content_type => 'text/xml')
     end
 
-    # Returns a set of recommendations for the set of items that is passed in in
+    # @return [Array] A set of recommendations for the set of items that is passed in in
     # aggregate, commonly used to do recommendations for a basket of items.
+    #
+    # @param [Array] items List of items to base the recommendations on, e.g. all of the
+    #  items in the basket.
+    #
+    # The tags and params parameters are equivalent to those with the normal Item#related
+    # call.
+    #
+    # @see Item#related
 
     def group_related(items=Set.new, tags=Set.new, params={})
       if !items.is_a?(Array) || items.size < 1
@@ -186,7 +206,7 @@ module DirectedEdge
       params['items'] = items.to_a.join(',')
       params['tags'] = tags.to_a.join(',')
       params['union'] = true
-      params = normalize_params(params)
+      normalize_params!(params)
       if params['includeProperties'] == 'true'
         property_hash_from_document(read_document('related', params), 'related')
       else
@@ -236,6 +256,8 @@ module DirectedEdge
     # destination is an existing database object, updates will be queued until
     # finish is called, at which point they will be uploaded to the webservices
     # in batch.
+    #
+    # @return [Exporter]
 
     def initialize(destination)
       if destination.is_a?(String)
@@ -321,8 +343,9 @@ module DirectedEdge
     # manipulated locally and then saved back to the database by calling save.
 
     def initialize(database, id)
-      @database = database
+      super(database.resource[URI.escape(id, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))])
 
+      @database = database
       @id = id
       @links = CollectionHash.new(Hash)
       @tags = Set.new
@@ -335,13 +358,11 @@ module DirectedEdge
       @preselected_to_remove = Set.new
       @blacklisted_to_remove = Set.new
       @properties_to_remove = Set.new
-
-      @resource = @database.resource[URI.escape(@id)]
       @cached = false
     end
 
-    # Returns true if the other item is the same.  The item given can either be
-    # a string or an item object.
+    # @return [Boolean] True if the other item has the same ID.  The item given
+    # can either be a string or an item object.
 
     def ==(other)
       if other.is_a?(Item)
@@ -351,17 +372,13 @@ module DirectedEdge
       end
     end
 
-    # Returns the item's ID.
+    # @return [String] The item's ID
 
     def name
       @id
     end
 
-    # Creates an item if it does not already exist in the database or overwrites
-    # an existing item if one does.
-    #
-    # This has been deprecated as it's not set up to properly support link types.
-    # use new / save instead.
+    # @deprecated Use new / save instead.
 
     def create(links={}, tags=Set.new, properties={})
       warn 'DirectedEdge::Item::create has been deprecated. Use new / save instead.'
@@ -378,9 +395,11 @@ module DirectedEdge
 
     # Writes all changes to links, tags and properties back to the database and
     # returns this item.
+    #
+    # @return [Item]
 
-    def save
-      if @cached
+    def save(options={})
+      if options[:overwrite] || @cached
         put(complete_document)
       else
 
@@ -410,6 +429,8 @@ module DirectedEdge
 
     # Reloads (or loads) the item from the database.  Any unsaved changes will
     # will be discarded.
+    #
+    # @return [Item]
 
     def reload
       @links.clear
@@ -426,44 +447,56 @@ module DirectedEdge
 
       @cached = false
       read
+      self
     end
 
-    # Returns a set of items that are linked to from this item.
+    # @return [Set] Items that are linked to from this item.
+    #
+    # @param [String] type Only links for the specified link-type will be
+    #  returned.
 
     def links(type='')
       read
       @links[type.to_s]
     end
 
-    # Returns a set containing all of this item's tags.
+    # @return [Set] The tags for this item.
 
     def tags
       read
       @tags
     end
 
-    # Returns an ordered list of items that are preselected for this item.
+    # An ordered list of preselected recommendations for this item.
+    #
+    # @return [Array] The preselected recommendations for this item.
 
     def preselected
       read
       @preselected
     end
 
-    # Returns a set of items that should not ever be recommended for this item.
+    # An ordered list of blacklisted recommendations for this item.
+    #
+    # @return [Array] The items blacklisted from being recommended for this item.
 
     def blacklisted
       read
       @blacklisted
     end
 
-    # Returns a hash of all of this item's properties.
+    # All properties for this item.
+    #
+    # @return [Hash] All of the properties for this item.
 
     def properties
       read
       @properties
     end
 
-    # Returns the property for the name specified.
+    # Fetches properties of the item.
+    #
+    # @return [String] The property for this item.
 
     def [](property_name)
       read
@@ -473,17 +506,23 @@ module DirectedEdge
     # Assigns value to the given property_name.
     #
     # This will not be written back to the database until save is called.
+    #
+    # @return [Item]
 
     def []=(property_name, value)
       @properties_to_remove.delete(property_name)
       @properties[property_name] = value
+      self
     end
 
     # Remove the given property_name.
+    #
+    # @return [Item]
 
     def clear_property(property_name)
       @properties_to_remove.add(property_name) unless @cached
       @properties.delete(property_name)
+      self
     end
 
     # Removes an item from the database, including deleting all links to and
@@ -491,6 +530,7 @@ module DirectedEdge
 
     def destroy
       @resource.delete
+      nil
     end
 
     # Creates a link from this item to other.
@@ -503,33 +543,50 @@ module DirectedEdge
     #   user.link_to(product, 5)
     #   user.save
     #
-    # If no link is specified then a tradtional, unweighted link will be
-    # created.  This is typical to, for instance, incidate a purchase or click
-    # from a user to a page or item.
-    #
-    # Weights may be in the range of 1 to 10.
+    # @param [String] other An identifier (or Item instance) for an item to be linked
+    #  to.
+    # @param [Integer] weight A weight in the range of 1 to 10 for this link.  If not
+    #  specified (which is fine for most situations) an unweighted link will be
+    #  created.
+    # @param [String] type The link type to be used for this connection, or, the
+    #  default untyped link.  This could be, for example, *purchase* or *rating*.
     #
     # Note that 'other' must exist in the database or must be saved before this
     # item is saved.  Otherwise the link will be ignored as the engine tries
     # to detect 'broken' links that do not terminate at a valid item.
+    # 
+    # @return [String] The item ID just linked to
 
     def link_to(other, weight=0, type='')
       raise RangeError if (weight < 0 || weight > 10)
       @links_to_remove[type.to_s].delete(other)
       @links[type.to_s][other.to_s] = weight
+      other
     end
 
-    # Deletes a link from this item to other.
+    # Removes a relationship from this item to another item.
     #
     # The changes will not be reflected in the database until save is called.
+    #
+    # @param [String] other The ID (or Item instance) for an object to be
+    #  unlinked.
+    # @return [String] The item ID just unlinked from.
+    # @see Item#link_to
 
     def unlink_from(other, type='')
       @links_to_remove[type.to_s].add(other.to_s) unless @cached
       @links[type.to_s].delete(other.to_s)
+      other
     end
 
     # If there is a link for "other" then it returns the weight for the given
     # item.  Zero indicates that no weight is assigned.
+    #
+    # @param [String] other The item being queried for.
+    # @param [String] type The link type of the relationship.
+    #
+    # @return [Integer] The weight for a link from this item to the specified
+    #  item, or nil if not found.
 
     def weight_for(other, type='')
       read
@@ -538,55 +595,118 @@ module DirectedEdge
 
     # Adds a tag to this item.
     #
+    # @param [String] tag The tag to be added to this item's tag set.
+    # @return [String] The tag just added.
+    #
     # The changes will not be reflected in the database until save is called.
 
     def add_tag(tag)
       @tags_to_remove.delete(tag)
       @tags.add(tag)
+      tag
     end
 
     # Removes a tag from this item.
     #
+    # @param [String] tag The tag to be removed from this item's set of tags.
+    # @return [String] The tag just removed.
+    #
     # The changes will not be reflected in the database until save is called.
 
     def remove_tag(tag)
       @tags_to_remove.add(tag) unless @cached
       @tags.delete(tag)
+      tag
     end
 
+    # Adds a hand-picked recommendation for this item.
+    #
+    # Note that preselected recommendations are weighted by the order that they
+    # are added, i.e. the first preselected item added will be the first one
+    # shown.
+    #
+    # @param [String] item The ID (or an Item instance) of the item that should
+    #  be always returned as a recommendation for this item.
+    # @return [String] The ID just added.
+
     def add_preselected(item)
-      @preselected_to_remove.delete(item)
-      @preselected.push(item)
+      @preselected_to_remove.delete(item.to_s)
+      @preselected.push(item.to_s)
+      item
     end
 
+    # Removes a hand-picked recommendation for this item.
+    #
+    # @param [String] item The ID (or an Item instance) of the item that should
+    #  be removed from the preselected list.
+    # @return [String] The ID just removed.
+    #
+    # @see Item#add_preselected
+
     def remove_preselected(item)
-      @preselected_to_remove.add(item) unless @cached
-      @preselected.delete(item)
+      @preselected_to_remove.add(item.to_s) unless @cached
+      @preselected.delete(item.to_s)
+      item
     end
 
+    # Adds a blacklisted item that should never be shown as recommended for this
+    # item.
+    #
+    # @param [String] item The ID (or an Item instance) of the item that should
+    #  be blacklisted.
+    # @return [String] The ID just blacklisted.
+
     def add_blacklisted(item)
-      @blacklisted_to_remove.delete(item)
-      @blacklisted.add(item)
+      @blacklisted_to_remove.delete(item.to_s)
+      @blacklisted.add(item.to_s)
+      item
     end
 
+    # Removes a blacklisted item.
+    #
+    # @param [String] item The ID (or an Item instance) of the item that should
+    #  be removed from the blacklist.
+    # @return [String] The ID just delisted.
+    #
+    # @see Item::add_blacklisted
+
     def remove_blacklisted(item)
-      @blacklisted_to_remove.add(item) unless @cached
-      @blacklisted.delete(item)
+      @blacklisted_to_remove.add(item.to_s) unless @cached
+      @blacklisted.delete(item.to_s)
+      item
     end
 
-    # Returns the list of items related to this one.  Unlike "recommended" this
-    # may include items which are directly linked from this item.  If any tags
-    # are specified, only items which have one or more of the specified tags
+    # related and recommended are the two main methods for querying for
+    # recommendations with the Directed Edge API.  Related is for *similar*
+    # items, e.g. "products like this product", whereas recommended is for
+    # personalized recommendations, i.e. "We think you'd like..."
+    #
+    # @return [Array] List of item IDs related to this one with the most closely
+    # related items first.
+    # 
+    # @param [Set] tags Only items which have at least one of the provided tags
     # will be returned.
     #
-    # Parameters that may be passed in include:
-    # - :exclude_linked (true / false)
-    # - :max_results (integer)
+    # @param [Hash] options A set of options which are passed directly on to
+    # the web services API in the query string.
+    #
+    # @option params [Boolean] :exclude_linked (false)
+    #  Exclude items which are linked directly from this item.
+    # @option params [Integer] :max_results (20)
+    #  Only returns up to :max_results items.
+    # @option params [Integer] :link_type_weight (1)
+    #  Here link_type should be replace with one of the actual link types in
+    #  use in your database, i.e. :purchase_weight and specifies how strongly
+    #  links of that type should be weighted related to other link types.  For
+    #  Instance if you wanted 20% ratings and 80% purchases you would specify:
+    #  :purchases_weight => 8, :ratings_weight => 2
     #
     # This will not reflect any unsaved changes to items.
+    #
+    # @see Item#recommended
 
     def related(tags=Set.new, params={})
-      params = normalize_params(params)
+      normalize_params!(params)
       params['tags'] = tags.to_a.join(',')
       if params['includeProperties'] == 'true'
         property_hash_from_document(read_document('related', params), 'related')
@@ -595,19 +715,37 @@ module DirectedEdge
       end
     end
 
-    # Returns the list of items recommended for this item, usually a user.
-    # Unlike "related" this does not include items linked from this item.  If
-    # any tags are specified, only items which have one or more of the specified
-    # tags will be returned.
+    # related and recommended are the two main methods for querying for
+    # recommendations with the Directed Edge API.  Related is for *similar*
+    # items, e.g. "products like this product", whereas recommended is for
+    # personalized recommendations, i.e. "We think you'd like..."
+    #
+    # @return [Array] List of item IDs recommeded for this item with the most
+    # strongly recommended items first.
+    # 
+    # @param [Set] tags Only items which have at least one of the provided tags
+    # will be returned.
+    #
+    # @param [Hash] options A set of options which are passed directly on to
+    # the web services API in the query string.
     #
-    # Parameters that may be passed in include:
-    # - :exclude_linked (true / false)
-    # - :max_results (integer)
+    # @option params [Boolean] :exclude_linked (false)
+    #  Exclude items which are linked directly from this item.
+    # @option params [Integer] :max_results (20)
+    #  Only returns up to :max_results items.
+    # @option params [Integer] :link_type_weight (1)
+    #  Here link_type should be replace with one of the actual link types in
+    #  use in your database, i.e. :purchase_weight and specifies how strongly
+    #  links of that type should be weighted related to other link types.  For
+    #  Instance if you wanted 20% ratings and 80% purchases you would specify:
+    #  :purchases_weight => 8, :ratings_weight => 2
     #
     # This will not reflect any unsaved changes to items.
+    #
+    # @see Item#related
 
     def recommended(tags=Set.new, params={})
-      params = normalize_params(params)
+      normalize_params!(params)
       params['tags'] = tags.to_a.join(',')
       params.key?('excludeLinked') || params['excludeLinked'] = 'true'
       if params['includeProperties'] == 'true'
@@ -617,13 +755,13 @@ module DirectedEdge
       end
     end
 
-    # Returns the ID of the item.
+    # @return [String] The ID of the item.
 
     def to_s
       @id
     end
 
-    # Returns an XML representation of the item as a string not including the
+    # @return [String] An XML representation of the item as a string not including the
     # usual document regalia, e.g. starting with <item> (used for exporting the
     # item to a file)
 
@@ -638,45 +776,41 @@ module DirectedEdge
 
     def read
       unless @cached
-        begin
-          document = read_document
-
-          document.elements.each('//link') do |link_element|
-            type = link_element.attribute('type')
-            type = type ? type.to_s : ''
-            weight = link_element.attribute('weight').to_s.to_i
-            target = link_element.text
-            @links[type][target] = weight unless @links[type][target]
-          end
-
-          @tags.merge(list_from_document(document, 'tag'))
-          @preselected.concat(list_from_document(document, 'preselected'))
-          @blacklisted.merge(list_from_document(document, 'blacklisted'))
-
-          document.elements.each('//property') do |element|
-            name = element.attribute('name').value
-            @properties[name] = element.text unless @properties.has_key?(name)
-          end
-
-          @links_to_remove.each do |type, links|
-            links.each { |link, weight| @links[type].delete(link) }
-          end
-
-          @tags_to_remove.each { |tag| @tags.delete(tag) }
-          @preselected_to_remove.each { |p| @preselected.delete(p) }
-          @blacklisted_to_remove.each { |b| @blacklisted.delete(b) }
-          @properties_to_remove.each { |property| @properties.delete(property) }
+        document = read_document
+
+        document.elements.each('//link') do |link_element|
+          type = link_element.attribute('type')
+          type = type ? type.to_s : ''
+          weight = link_element.attribute('weight').to_s.to_i
+          target = link_element.text
+          @links[type][target] = weight unless @links[type][target]
+        end
 
-          @links_to_remove.clear
-          @tags_to_remove.clear
-          @preselected_to_remove.clear
-          @blacklisted_to_remove.clear
-          @properties_to_remove.clear
+        @tags.merge(list_from_document(document, 'tag'))
+        @preselected.concat(list_from_document(document, 'preselected'))
+        @blacklisted.merge(list_from_document(document, 'blacklisted'))
+
+        document.elements.each('//property') do |element|
+          name = element.attribute('name').value
+          @properties[name] = element.text unless @properties.has_key?(name)
+        end
 
-          @cached = true
-        rescue => ex
-          puts "Couldn't read \"#{@id}\" from the database, #{ex}"
+        @links_to_remove.each do |type, links|
+          links.each { |link, weight| @links[type].delete(link) }
         end
+
+        @tags_to_remove.each { |tag| @tags.delete(tag) }
+        @preselected_to_remove.each { |p| @preselected.delete(p) }
+        @blacklisted_to_remove.each { |b| @blacklisted.delete(b) }
+        @properties_to_remove.each { |property| @properties.delete(property) }
+
+        @links_to_remove.clear
+        @tags_to_remove.clear
+        @preselected_to_remove.clear
+        @blacklisted_to_remove.clear
+        @properties_to_remove.clear
+
+        @cached = true
       end
     end
 

data/test/test_directed_edge.rb

@@ -258,6 +258,8 @@ class TestDirectedEdge < Test::Unit::TestCase
   def test_load
     return if ENV['NO_LOAD_TEST']
 
+    Process.setrlimit(Process::RLIMIT_NOFILE, 4096, 65536)
+
     def run_load_test(prefix, count)
       (1..count).concurrently do |i|
         item = DirectedEdge::Item.new(@database, "test_item_#{prefix}_#{i}")
@@ -295,13 +297,13 @@ class TestDirectedEdge < Test::Unit::TestCase
     # Test an out of range ranking.
 
     customer1.links[customer2] = -1
-    assert_raise(RestClient::RequestFailed) { customer1.save }
+    assert_raise(RestClient::UnprocessableEntity) { customer1.save }
 
     # And another.
 
     customer1.reload
     customer1.links[customer2] = 100
-    assert_raise(RestClient::RequestFailed) { customer1.save }
+    assert_raise(RestClient::UnprocessableEntity) { customer1.save }
 
     customer1.reload
     customer1.link_to(customer3, 10)
@@ -322,6 +324,13 @@ class TestDirectedEdge < Test::Unit::TestCase
 
     item = DirectedEdge::Item.new(@database, ';@%&!')
     assert(item['foo'] == 'bar')
+
+    item = DirectedEdge::Item.new(@database, 'foo/bar')
+    item['foo'] = 'bar'
+    item.save
+
+    item = DirectedEdge::Item.new(@database, 'foo/bar')
+    assert(item['foo'] == 'bar')
   end
 
   def test_bad_links
@@ -330,7 +339,7 @@ class TestDirectedEdge < Test::Unit::TestCase
 
     item = DirectedEdge::Item.new(@database, 'customer1')
     item.link_to('also does not exist')
-    assert_raise(RestClient::RequestFailed) { item.save }
+    assert_raise(RestClient::UnprocessableEntity) { item.save }
   end
 
   def test_query_parameters
@@ -414,4 +423,23 @@ class TestDirectedEdge < Test::Unit::TestCase
     assert(!customer.blacklisted.include?(first))
     assert(customer.recommended(['product']).include?(first))
   end
+
+  def test_timeout
+    timeout = 5
+    database = DirectedEdge::Database.new('dummy', 'dummy', 'http',
+                                          :host => 'localhost:4567', :timeout => timeout)
+    start = Time.now
+    timed_out = false
+
+    begin
+      item = DirectedEdge::Item.new(database, 'dummy')
+      item.tags
+    rescue RestClient::RequestTimeout
+      timed_out = true
+      assert(Time.now - start < timeout + 1)
+    rescue
+    end
+
+    assert(timed_out)
+  end
 end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: directed-edge
 version: !ruby/object:Gem::Version 
+  hash: 21
   prerelease: false
   segments: 
   - 0
   - 2
-  - 0
-  version: 0.2.0
+  - 1
+  version: 0.2.1
 platform: ruby
 authors: 
 - Directed Edge
@@ -14,16 +15,18 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-25 00:00:00 +02:00
+date: 2010-11-19 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rest-client
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
@@ -53,28 +56,32 @@ homepage: http://developer.directededge.com/
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Bindings for the Directed Edge webservices API