$Id: NEWS,v 1.4 2008/05/19 10:15:52 ianmacd Exp $


0.3.0
-----

The version of the Amazon AWS API requested when performing operations is now
2008-04-07. This is the latest at the time of writing.

Remote shopping carts are now implemented. See the Amazon::AWS::ShoppingCart
module and the Amazon::AWS::ShoppingCart::Cart class in
./amazon/aws/shoppingcart.rb for more details.

Basically, the new methods are Cart.new, Cart#cart_create, Cart#cart_add,
Cart#cart_modify and Cart#cart_clear. There's also Cart#each for iterating
over the items in a cart.

This adds the following AWS operations to the list of those supported:

  CartCreate
  CartAdd
  CartModify
  CartClear

It's currently not possible to update a wishlist at purchase time by referring
to the item's ListItemId when adding it to a cart.

It's also currently not possible to add items to the 'Saved For Later' section
of the cart.

A new iterator method, AWSObject#each, yields each |property, value| of the
AWSObject.

The AWSObject and AWSArray classes have received a few new helper methods that
should make AWSObject and single element AWSArray objects behave more akin to
strings when they are being compared with strings, matched against regexes,
etc.

An otherwise undocumented method, AWSObject#kernel, provides unnested (i.e.
top level) AWSObject objects with a shortcut reference to the data most likely
of interest to the user.

For example, if a top level AWSObject is formed as the result of an
ItemSearch, one might normally refer to the items returned with something like
this:

  foo.item_search_response[0].items[0].item

AWSObject#kernel allows the same data to be referred to as follows:

  foo.kernel

The path to the data is programatically determined, so this method only works
for top level AWSObject objects created by a class of operation whose name can
be used to derive the path. This is why this method is not documented.

When searches are performed, greater efforts are now made to determine whether
Amazon returned any errors. In particular, batch operations and
MultipleOperations may return errors at different locations in the XML tree
than normal operations.

A bug that materialised only when using an HTTP proxy has been fixed.


0.2.0
-----

In previous versions, only 5 types of operation were supported:

  BrowseNodeLookup
  ItemLookup
  ItemSearch
  ListSearch
  SellerListingSearch

This version supports all remaining non-shopping-cart operations:

  CustomerContentLookup
  CustomerContentSearch
  Help
  ListLookup
  SellerListingSearch
  SellerLookup
  SimilarityLookup
  TagLookup
  TransactionLookup

Examples of each of these can be found in ./examples/

It is hoped that shopping carts will make their debut in the next release of
Ruby/AWS.

One can now use a Symbol for search indices and hash keys when instantiating
operation objects and response group objects.

For example:

  is = ItemSearch.new( 'Books', { 'Title' => 'Ruby' } )
  rg = ResponseGroup.new( 'Large' )

can now be written like this:

  is = ItemSearch.new( :Books, { :Title => 'Ruby' } )
  rg = ResponseGroup.new( :Large )

It's up to you which form you use. The Symbol form saves one character. :-)

AWSObject#to_s has been improved to provide something better looking. There's
still room for improvement, though.

AWSObject#to_i has been added. This allows, for example, AWSObjects to be used
with the %d format specifier in formatted strings. It's up to you, though, to
know when an AWSObject can be expected to contain a String that's usable as an
Integer.

Objects of a class whose name matches AWSObject::.*Image typically have a @url
attribute that points to the URL of the image in question. Such objects now
have a #get method, which can be used to retrieve the image in question. This
method takes a single parameter, an integer precentage, which causes the
retrieved image to be overlayed with a discount icon.

Various compatibility fixes were made to allow Ruby/AWS to work under Ruby
1.9. The use of Ruby/AWS with this version is still not recommended, however.
For one thing, Ruby 1.9 seems to use #inspect in places that Ruby 1.8 used
#to_s.


0.1.0
-----

Version 0.1.0 of Ruby/AWS has undergone fundamental changes from the previous,
very crude versions, 0.0.1 and 0.0.2.

For one thing, the AWS XML parser has been completely rewritten. In this new
version, classes are dynamically generated as required, based on the elements
present in the XML pages returned by AWS.

Previous versions of Ruby/AWS (and also Ruby/Amazon), manually defined most
of these classes, based on Amazon's developer documentation and examination of
AWS XML reponses. This time-consuming, unwieldy and unnecessary approach was
largely the result of my own lack of aptitude with the Ruby REXML library.

While these manually defined classes accounted for much of the data returned
by AWS, a smaller section of the data was, nevertheless, dynamically converted
to Ruby data structures. This mix of manually and automatically treated
objects led to inconsistencies in the Ruby representation of the hierarchical
XML structure. This meant that it was not quite possible to look at an AWS XML
response and reliably determine how the resulting Ruby data structure would
look.

That inconsistency has been ironed out in version 0.1.0. As of now,
_everything_ is dynamically generated from the AWS XML response. All manual
class definitions have been removed and all classes are now defined at the
time they first need to be instantiated.

This has the following advantages:

- Changes in the structure of AWS XML responses will not break Ruby/AWS. They
  may break user code (if, for example, you depend on the presence of a piece
  of data that later disappears from AWS responses [and even this should not
  happen, because AWS v4 has a versioned API]), but they will not break the
  library. The library will always create whichever classes are needed to
  represent any given XML structure returned by AWS.

- Changes in the structure of AWS XML that results in new data being
  included in responses will automatically cause said data to be made
  available via Ruby/AWS. If, for example, Amazon starts to return data about
  the duration of each CD in their catalogue, perhaps using a <Duration> tag,
  foo.duration would automatically start to return that property.

- It should be faster, but I haven't verified this.

Multiple operations are now supported.

Geolocation of locale is now working.

Documentation in this version has been radically improved, but is still
lacking.
