amazon-product-advertising-api-prezjordan 0.2.2

data/.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+._*
+rdoc
+test/test_local.rb

data/EXAMPLE.txt

@@ -0,0 +1,128 @@
+Basic usage
+###########
+
+require 'rubygems'
+require 'amazon_product_advertising_api'
+
+# Setup your API keys - in an initializer or something like that
+AmazonProductAdvertisingApi::Base.access_key_id = "<insert api key here>"
+AmazonProductAdvertisingApi::Base.secret_access_key = "<insert secret access key here>"
+
+# Setup Associates IDs for whichever regions you're selling to
+AmazonProductAdvertisingApi::Base.associate_ids.uk = "<insert UK Associate ID here>"
+AmazonProductAdvertisingApi::Base.associate_ids.us = "<insert US Associate ID here>"
+
+lookup = AmazonProductAdvertisingApi::Operations::Item::ItemLookup.new("0201485419")
+lookup.run
+
+# Returned XML, tidied
+# <?xml version="1.0"?>
+# <ItemLookupResponse xmlns="http://webservices.amazon.com/AWSECommerceService/2005-10-05">
+#   <OperationRequest>
+#     <RequestId>d6c19392-7710-4b05-ad9c-1637755170d8</RequestId>
+#     <Arguments>
+#       <Argument Name="Operation" Value="ItemLookup"/>
+#       <Argument Name="Service" Value="AWSECommerceService"/>
+#       <Argument Name="ItemId" Value="0201485419"/>
+#       <Argument Name="AWSAccessKeyId" Value="<your api key>"/>
+#     </Arguments>
+#     <RequestProcessingTime>0.0376290000000000</RequestProcessingTime>
+#   </OperationRequest>
+#   <Items>
+#     <Request>
+#       <IsValid>True</IsValid>
+#       <ItemLookupRequest>
+#         <Condition>New</Condition>
+#         <DeliveryMethod>Ship</DeliveryMethod>
+#         <IdType>ASIN</IdType>
+#         <MerchantId>Amazon</MerchantId>
+#         <OfferPage>1</OfferPage>
+#         <ItemId>0201485419</ItemId>
+#         <ResponseGroup>Small</ResponseGroup>
+#         <ReviewPage>1</ReviewPage>
+#       </ItemLookupRequest>
+#     </Request>
+#     <Item>
+#       <ASIN>0201485419</ASIN>
+#       <DetailPageURL>http://www.amazon.co.uk/Art-Computer-Programming-Information-Processing/dp/0201485419%3FSubscriptionId%3D<your api key>%26tag%3Dws%26linkCode%3Dxm2%26camp%3D2025%26creative%3D165953%26creativeASIN%3D0201485419</DetailPageURL>
+#       <ItemAttributes>git 
+#         <Author>Donald E. Knuth</Author>
+#         <Manufacturer>Addison Wesley</Manufacturer>
+#         <ProductGroup>Book</ProductGroup>
+#         <Title>The Art of Computer Programming: v. 1-3: Vol 1-3 (Series in Computer Science &amp; Information Processing)</Title>
+#       </ItemAttributes>
+#     </Item>
+#   </Items>
+# </ItemLookupResponse>
+
+# is_valid is part of the api and says whether the request was valid
+lookup.is_valid
+=> true
+
+lookup.response.items.size
+=> 1
+
+lookup.response.items.first
+=> #<AmazonProductAdvertisingApi::Item:0x139154c @detail_page_url="http://www.amazon.co.uk/Art-Computer-Programming-Information-Processing/dp/0201485419%3FSubscriptionId%3D<your api key>%26tag%3Dws%26linkCode%3Dxm2%26camp%3D2025%26creative%3D165953%26creativeASIN%3D0201485419", @item_attributes=#<AmazonProductAdvertisingApi::Container:0x1391448 @manufacturer="Addison Wesley", @product_group="Book", @title="The Art of Computer Programming: v. 1-3: Vol 1-3 (Series in Computer Science &amp; Information Processing)", @author="Donald E. Knuth">, @asin="0201485419">
+
+lookup.response.items.first.asin
+=> "0201485419"
+
+# ItemAttributes is a container element, doesn't return a string
+lookup.response.items.first.item_attributes
+=> #<AmazonProductAdvertisingApi::Container:0x1391448 @manufacturer="Addison Wesley", @product_group="Book", @title="The Art of Computer Programming: v. 1-3: Vol 1-3 (Series in Computer Science &amp; Information Processing)", @author="Donald E. Knuth">
+
+lookup.response.items.first.item_attributes.title
+=> "The Art of Computer Programming: v. 1-3: Vol 1-3 (Series in Computer Science &amp; Information Processing)"
+
+lookup.response.items.first.item_attributes.author
+=> "Donald E. Knuth"
+
+# If you need to debug, you can access all the xml data easily
+lookup.raw_data
+=> <XML string, straight from the request body>
+
+lookup.hpricot_data
+=> <the xml data, having been fed into Hpricot>
+
+# And also the request uri
+lookup.request_uri
+=> #<URI::HTTP:0x1c7021c URL:http://ecs.amazonaws.co.uk/onca/xml?Service=AWSECommerceService&Operation=ItemLookup&ItemId=0201485419&AWSAccessKeyId=%3Cinsert%20api%20key%20here%3E>
+
+
+Error handling - invalid request credentials, url form, etc
+###########################################################
+AmazonProductAdvertisingApi::Base.access_key_id = "<an invalid id>"
+lookup = AmazonProductAdvertisingApi::Operations::Item::ItemLookup.new("0201485419")
+lookup.run
+=> false
+
+lookup.is_valid
+=> false
+
+lookup.errors
+=> <an array of error objects>
+
+lookup.errors.first.code
+=> AWS.InvalidParameterValue
+
+lookup.errors.first.message
+=> <an invalid id> is not a valid value for AWSAccessKeyId. Please change this value and retry your request.
+
+
+Error handling - invalid request credentials, url form, etc
+###########################################################
+AmazonProductAdvertisingApi::Base.access_key_id = "<valid api key>"
+lookup = AmazonProductAdvertisingApi::Operations::Item::ItemLookup.new("<invalid asin>")
+lookup.run
+=> false
+
+# is_valid returns true as the request was well formed, it just doesn't have any valid data to return
+lookup.is_valid
+=> true
+
+lookup.errors.first.code
+=> AWS.InvalidParameterValue
+
+lookup.errors.first.message
+=> <an invalid asin> is not a valid value for ItemId. Please change this value and retry your request.

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Jon Gilbraith, CompletelyNovel Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,99 @@
+= amazon-product-advertising-api
+
+== Introduction
+A nice rubyish interface to the Amazon Product Advertising API, formerly
+known as the Associates Web Service and before that the Amazon E-Commerce
+Service.
+
+The basic design philosophy is the 'Principle of least surprise', so it's:
+- a dsl that should feel familiar to ruby folk.
+- structured generally like the API.
+
+== Prerequisites
+It's assumed you're reasonably familiar with Ruby as a language, and the
+typical coding patterns and styles employed by the community.
+
+It's also assumed that you're familiar with the API. If not go RTFM for a bit,
+it's all pretty straight forward.
+
+== Overview
+As mentioned before, the idea behind this is to model the API so that once
+you're familiar with this library and the API, you'll find this an easy way to
+navigate around it. You should then be able to just refer to the lists of
+Operations, Response Groups and Response Elements in the appendices for all
+you need to know.
+
+You initiate requests by instantiating classes representing api Operations and
+named the same way, i.e. ItemSearch, ItemLookup, etc. The request parameters
+are represented by attributes on those objects and can be manipulated as you
+wish.  If a parameter is required it'll be required or defaulted on
+initialization, but everywhere else we defer to the defaults provided by the
+api.
+
+Once setup, you call 'run' on the operation which will send the request and
+return a response object (and after that also available as operation.response).
+
+The response has a bit less structure than the request operations. There is no
+representation for Response Groups as beyond one level deep there is no clear
+pattern for how returned XML is structured (at least not without going down the
+route trying to define custom handling for each of them). So, instead we group
+the Operations into broad groups which return the same collections of data.
+ItemSearch, ItemLookup and SimilarityLookup all return a Items container
+element with one or more Item tag in it, etc.
+
+Everything beyond one level deep is done with a recursive sweep instantiating
+Element objects as we go.
+
+== Things to know
+- Amazon uses a lot of Camel case in their XML, but to suit Ruby / Rails
+  conventions attributes, etc are converted to underscore style.
+- One gotcha - Response Elements can either be a simple value or a container
+  with more elements inside. We recognise this situation by simply comparing
+  the parent and child names (plural parent, singular child) though that isn't
+  always the pattern so we also look for multiple children of the same name.
+  
+  That means that some situations might creep through and not work as expected.
+  If the parent and child don't follow the same naming convention and there is
+  also only one child element you'd find the child would be defined as
+  parent.child rather than parent.children.first.
+  
+  This is a bug and will have to be addressed (probably by making a list of
+  container elements to check against).
+  
+== Having problems?
+After running the request uri, returned raw xml and hpricot data will be
+available in operation.raw_data and operation.hpricot_data which should tell
+you all you need to know about the response.
+
+== Test coverage
+There aren't any tests at the moment but I'll try to add some.
+
+For the most part there isn't really all that much to test though as it's all
+largely just making http requests, however the XML parsing is quite convoluted
+so some tests would be good there to make sure the parsing is following the
+intended rules.
+
+
+= TODO
+- Implement the rest of the Operations (Cart*, Customer*, Help, List*, Seller*,
+  Tag*, Transaction* and Vehicle*).
+- Implement batch and multiple operation requests, abstracted away from the
+  user within the dsl.
+- Some sort of internal caching mechanism.
+- Ability to bind to different IP addresses, in order to circumvent API rate
+  limiting.
+
+
+= Obtaining
+The main repository is at github but there is also a rubyforge project.
+
+- https://github.com/completelynovel/amazon-product-advertising-api/tree
+- http://amazon-pa-api.rubyforge.org/
+
+
+= Credits
+Created by Jon Gilbraith, jon@completelynovel.com, while working with
+CompletelyNovel.
+
+Contents of support.rb are basically taken and adapted from Rails'
+ActiveSupport.

data/Rakefile

@@ -0,0 +1,29 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Generate documentation for the amazon-product-advertising-api gem.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'AmazonProductAdvertisingApi'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name        = "amazon-product-advertising-api"
+    gemspec.summary     = "A nice rubyish interface to the Amazon Product Advertising API."
+    gemspec.email       = "jon@completelynovel.com"
+    gemspec.homepage    = "http://github.com/completelynovel/amazon-product-advertising-api"
+    gemspec.description = "A nice rubyish interface to the Amazon Product Advertising API, formerly known as the Associates Web Service and before that the Amazon E-Commerce Service."
+    gemspec.authors     = ["Jon Gilbraith"]
+    gemspec.add_dependency("hpricot")
+    gemspec.add_dependency("ruby-hmac")
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.2.1

data/amazon-product-advertising-api.gemspec

@@ -0,0 +1,53 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{amazon-product-advertising-api-prezjordan}
+  s.version = "0.2.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jon Gilbraith", "Jordan Scales"]
+  s.date = %q{2009-07-30}
+  s.description = %q{A nice rubyish interface to the Amazon Product Advertising API (MODIFIED to handle ResponseGroup), formerly known as the Associates Web Service and before that the Amazon E-Commerce Service.}
+  s.email = %q{jon@completelynovel.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "EXAMPLE.txt",
+     "MIT-LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "amazon-product-advertising-api.gemspec",
+     "lib/amazon_product_advertising_api.rb",
+     "lib/amazon_product_advertising_api/base.rb",
+     "lib/amazon_product_advertising_api/operations/base.rb",
+     "lib/amazon_product_advertising_api/operations/browse_node.rb",
+     "lib/amazon_product_advertising_api/operations/item.rb",
+     "lib/amazon_product_advertising_api/response_elements.rb",
+     "lib/amazon_product_advertising_api/support.rb"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/prezjordan/amazon-product-advertising-api}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{A nice rubyish interface to the Amazon Product Advertising API. (MODIFIED to handle ResponseGroup)}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<hpricot>, [">= 0"])
+      s.add_runtime_dependency(%q<ruby-hmac>, [">= 0"])
+    else
+      s.add_dependency(%q<hpricot>, [">= 0"])
+      s.add_dependency(%q<ruby-hmac>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<hpricot>, [">= 0"])
+    s.add_dependency(%q<ruby-hmac>, [">= 0"])
+  end
+end

data/lib/amazon_product_advertising_api.rb

@@ -0,0 +1,18 @@
+require 'net/http'
+require 'cgi'
+require 'hpricot'
+require 'time'
+require 'hmac'
+require 'hmac-sha2'
+require 'base64'
+
+require 'amazon_product_advertising_api/support'
+
+Class.send(:include, AmazonProductAdvertisingApi::CoreExtensions::Class)
+String.send(:include, AmazonProductAdvertisingApi::CoreExtensions::String)
+
+require 'amazon_product_advertising_api/base'
+require 'amazon_product_advertising_api/response_elements'
+require 'amazon_product_advertising_api/operations/base'
+require 'amazon_product_advertising_api/operations/browse_node'
+require 'amazon_product_advertising_api/operations/item'

data/lib/amazon_product_advertising_api/base.rb

@@ -0,0 +1,24 @@
+module AmazonProductAdvertisingApi #:nodoc:
+  
+  # This is the main base class where you define your config data. Setup like so:
+  #   AmazonProductAdvertisingApi.base.access_key_id     = <your Amazon AccessKeyId>
+  #   AmazonProductAdvertisingApi.base.secret_access_key = <your Amazon SecretAccessKey>
+  #
+  # You also setup your Associates codes for different regions here (the right one is supplied)
+  # based on what region you are requesting for.
+  #   AmazonProductAdvertisingApi.base.associate_ids.ca = <your associates CA Affiliate key>
+  #   AmazonProductAdvertisingApi.base.associate_ids.uk = <your associates UK Affiliate key>
+  class Base
+    
+    cattr_accessor :access_key_id
+
+    cattr_accessor :secret_access_key
+
+    cattr_accessor :response_group
+    
+    cattr_accessor :associate_ids
+    @@associate_ids = Struct.new(:ca, :de, :fr, :jp, :uk, :us).new
+    
+  end
+  
+end

data/lib/amazon_product_advertising_api/operations/base.rb

@@ -0,0 +1,184 @@
+module AmazonProductAdvertisingApi #:nodoc:
+  module Operations #:nodoc:
+    module Base #:nodoc:
+      
+      # This is the parent class of any Operations performed.
+      #
+      # Each class should have a constant defined called REQUEST_PARAMETERS which contains the available parameters
+      # as defined in the API docs.  Each class should also override the parse method with a custom version to suit the
+      # particular pattern of XML returned for it.
+      #
+      # Subclasses should also override initialize to take any parameters the API defines as required, and follow the pattern
+      # of the region being the last parameter.
+      #
+      # Before doing that though it should call super back to this one.
+      class Request
+        
+        # String - Amazon API calls can be sent to any of 6 regions, so this defines which one.
+        # It'll also use this data to pick the right Associates key to use.
+        attr_accessor :region
+        
+        # String - The name of the Operation you want to perform, i.e. ItemSearch, ItemLookup, etc.
+        attr_accessor :operation
+        
+        # String - This stores the request that gets sent to Amazon (for investigation if you want to look under the covers).
+        attr_accessor :request_uri
+        
+        # String - This stores the raw data of the request response (again, for investigation if you want to look under the covers).
+        attr_accessor :raw_data
+        
+        # Hpricot - This stores the raw data of the request response should you feel the need / desire to do some parsing yourself.
+        attr_accessor :hpricot_data
+        
+        # Element - This is the root of the structure that the lib assembles from the data when parsed.
+        attr_accessor :response
+        
+        # Boolean - All responses have a field saying whether the request was valid. Note that this refers to the format of the request, etc
+        # and not errors with the request parameters, etc. I.e. a lookup for an item that doesn't exsist is still valid.
+        attr_accessor :is_valid
+        
+        # Array of Struct - Any errors will be added to this attribute and each has an attribute of code or message.
+        attr_accessor :errors
+    
+        SERVICE_URLS = {
+            :us => 'http://ecs.amazonaws.com/onca/xml',
+            :uk => 'http://ecs.amazonaws.co.uk/onca/xml',
+            :ca => 'http://ecs.amazonaws.ca/onca/xml',
+            :de => 'http://ecs.amazonaws.de/onca/xml',
+            :jp => 'http://webservices.amazon.co.jp/onca/xml',
+            :fr => 'http://ecs.amazonaws.fr/onca/xml'
+        }
+        
+        API_VERSION = "2009-03-31"
+    
+        # hacky :(
+        def initialize(arg1, arg2)
+          self.response = AmazonProductAdvertisingApi::Operations::Base::Element.new
+          self.errors   = []
+        end
+        
+        # This takes care of building request, performing it, storing the results, checking for errors then parsing the data (if the request was valid).
+        def query_amazon(params)
+          request_params = {}
+          request_params["Service"]          = "AWSECommerceService"
+          request_params["SignatureVersion"] = 2
+          request_params["SignatureMethod"]  = "HmacSHA256"
+          request_params["Timestamp"]        = Time.now.gmtime.iso8601
+          request_params["AWSAccessKeyId"]   = AmazonProductAdvertisingApi::Base.access_key_id
+          request_params["Operation"]        = self.operation
+          request_params["AssociateTag"]     = AmazonProductAdvertisingApi::Base.associate_ids.send(self.region) unless AmazonProductAdvertisingApi::Base.associate_ids.send(self.region).nil?
+          request_params["Version"]          = API_VERSION
+          request_params["ResponseGroup"]    = AmazonProductAdvertisingApi::Base.response_group.try(:join, ',')
+
+          request_params.merge!(params)
+
+          # Process all params - make sure they're all strings, camelize and escape (where appropriate)
+          request_params = request_params.collect { |var, val| [var.to_s.camelize, val.to_s] }
+          request_params = request_params.collect { |var, val| [var, CGI::escape(val).gsub('+', '%20')] }
+          
+          # Assemble into a full request string
+          unsigned_uri = URI.parse("#{SERVICE_URLS[self.region]}?#{request_params.sort { |a, b| a[0] <=> b[0] }.collect { |var, val| var + "=" + val }.join("&")}")
+
+          # Generate hmac
+          hmac = HMAC::SHA256.new(AmazonProductAdvertisingApi::Base.secret_access_key)
+          hmac.update("GET\n#{unsigned_uri.host}\n#{unsigned_uri.path}\n#{unsigned_uri.query}")
+
+          self.request_uri = URI.parse("#{unsigned_uri}&Signature=#{CGI::escape(Base64.encode64(hmac.digest).chomp)}")
+
+          result = Net::HTTP::get_response(self.request_uri)
+          raise("Error connecting to Amazon - #{result.to_s}") if !result.kind_of?(Net::HTTPSuccess)
+      
+          # Store away the raw data for debugging or if more direct access is required
+          self.raw_data     = result.body
+          self.hpricot_data = Hpricot.XML(self.raw_data)
+      
+          # Now parse the xml and build out the reponse elements
+          self.is_valid = self.hpricot_data.at(:IsValid).inner_html == "True"
+          
+          self.parse
+          
+          # is_valid only refers to the request, so we could still have errors - check and parse if present
+          if !self.hpricot_data.at(:Errors).nil?
+            self.hpricot_data.at(:Errors).search(:Error).each do |error|
+              self.errors << Struct.new(:code, :message).new(error.at(:Code).inner_html, error.at(:Message).inner_html)
+            end
+          end
+          
+          # Return false if it's not a valid request, otherwise return the response
+          self.is_valid ? self.response : false
+        end
+        
+        # The parse method of a request should be overwritted by any subclasses to account for different patterns in the XML.
+        def parse
+          raise "This should be being overridden by it's subclass to provide custom parsing for the particular operation concerned."
+        end
+        
+        # Launches the request's query to Amazon (via query_amazon).
+        def run
+          self.query_amazon(params)
+        end
+        
+        private
+          # When passed an hpricot element it returns true or false based on whether this item is thought to be inside a Container Element.
+          # It does this in the rather crude way of seeing if the parent's name is the pluralized form of it's own, or it is one of
+          # several with the same name. This isn't 100% fool proof so I think at some point using a definitive list of the container elements
+          # would be a better way to go.
+          #
+          # The pluralisation could also do with something a bit more sophisticated.
+          def parent_a_container?(hpricot_element)
+            hpricot_element.parent.name == hpricot_element.name + "s" || hpricot_element.parent.search("> #{hpricot_element.name}").size > 1
+          end
+        
+      end
+      
+      # XML data that is returned by Amazon gets built into a tree of nodes, which are made up of instances of this class.
+      # They represent the 'response element' entity within the API docs.
+      #
+      # As well as various having attributes it can also contain a collection and behave like an array.
+      class Element < Array
+        
+        attr_reader :attributes
+        
+        def initialize
+          @attributes = {}
+        end
+        
+        # Defines a new accessor on the element and if supplied assigns that attribute a value.
+        def add_element(name, value = nil)
+          name = name.underscore
+
+          @attributes[name.to_s] = value
+
+          self.instance_eval %{
+            def self.#{name}
+              @#{name}
+            end
+            def self.#{name}=(value)
+              @#{name} ||= value
+            end
+          }
+
+          if !value.nil?
+            value = value.to_s if value.is_a?(Symbol)
+            self.send("#{name}=", value)
+          end
+
+          # Return the element
+          self.instance_eval("self.#{name}")
+        end
+        
+        def method_missing(method, *args)
+          return super unless RESPONSE_ELEMENTS.include?(method.to_sym)
+
+          if CONTAINER_RESPONSE_ELEMENTS.include?(method.to_sym)
+            self.class.new
+          else
+            nil
+          end
+        end
+        
+      end
+    
+    end
+  end
+end