7digital 0.0.7 → 0.1.0

data/lib/sevendigital/digestion_tract/download_url_digestor.rb

@@ -3,18 +3,21 @@ module Sevendigital
   #@private
   class DownloadUrlDigestor < Digestor # :nodoc:
 
-    def default_element_name; :download_url end
-    def default_list_element_name; :download_urls end
+    def default_element_name; :downloadUrl end
+    def default_list_element_name; :downloadUrls end
+
+    def from_xml_doc(xml_node)
+        make_sure_eating_nokogiri_node(xml_node)
 
-    def from_proxy(download_url_proxy)
-        make_sure_not_eating_nil (download_url_proxy)
         download_url = DownloadUrl.new()
-        download_url.url = download_url_proxy.url.value.to_s
-        download_url.format = @api_client.format_digestor.from_proxy(download_url_proxy.format)
 
-        return download_url
+        download_url.url = get_required_value(xml_node,"url")
+        download_url.format = get_required_node(xml_node, "format") {|v| @api_client.format_digestor.from_xml_doc(v)}
+
+        download_url
     end
 
+
   end
 
 end

data/lib/sevendigital/digestion_tract/format_digestor.rb

@@ -6,15 +6,17 @@ module Sevendigital
     def default_element_name; :format end
     def default_list_element_name; :formats end
 
-    def from_proxy(format_proxy)
-        make_sure_not_eating_nil (format_proxy)
-        format = Format.new()
-        format.id = format_proxy.id.to_i
-        format.file_format = format_proxy.file_format.value.to_sym
-        format.bit_rate = format_proxy.bit_rate.value.to_i
-        format.drm_free = format_proxy.drm_free.value.to_s.downcase == "true"
-
-        return format
+    def from_xml_doc(xml_node)
+      make_sure_eating_nokogiri_node(xml_node)
+
+      format = Sevendigital::Format.new()
+
+      format.id = get_required_attribute(xml_node,"id").to_i
+      format.file_format = get_required_value(xml_node,"fileFormat").to_sym
+      format.bit_rate = get_required_value(xml_node,"bitRate").to_i
+      format.drm_free = get_required_value(xml_node,"drmFree").downcase == "true"
+
+      format
     end
 
   end

data/lib/sevendigital/digestion_tract/label_digestor.rb

@@ -5,16 +5,17 @@ module Sevendigital
 
     def default_element_name; :label end
     def default_list_element_name; :labels end
-    
-    def from_proxy(label_proxy)
-      make_sure_not_eating_nil(label_proxy)
+
+    def from_xml_doc(xml_node)
+      make_sure_eating_nokogiri_node(xml_node)
 
       label = Label.new()
-      label.id = label_proxy.id.to_i
-      label.name = label_proxy.name.value.to_s
 
-      return label
-      end
+      label.id = get_required_attribute(xml_node, "id").to_i
+      label.name = get_required_value(xml_node, "name")
+
+      label
+    end
 
   end
 

data/lib/sevendigital/digestion_tract/list_digestor.rb

@@ -0,0 +1,24 @@
+module Sevendigital
+
+  #@private
+  class ListDigestor < Digestor # :nodoc:
+
+    def default_element_name; :list end
+
+    def from_xml_doc(xml_node)
+      make_sure_eating_nokogiri_node(xml_node)
+
+      list = List.new(@api_client)
+
+      list.id = get_required_attribute(xml_node, "id").to_i
+      list.key = get_required_value(xml_node, "key")
+      list.list_items = get_required_node(xml_node, "listItems") do |v|
+        @api_client.list_item_digestor.list_from_xml_doc(v)
+      end
+
+      list
+    end
+
+  end
+
+end

data/lib/sevendigital/digestion_tract/list_item_digestor.rb

@@ -0,0 +1,26 @@
+module Sevendigital
+
+  #@private
+  class ListItemDigestor < Digestor # :nodoc:
+    
+    def default_element_name; :listItem end
+    def default_list_element_name; :listItems end
+
+    def from_xml_doc(xml_node)
+      make_sure_eating_nokogiri_node(xml_node)
+
+      list_item = Sevendigital::ListItem.new(@api_client)
+
+      list_item.id = get_required_attribute(xml_node, "id").to_i
+      list_item.type = get_required_value(xml_node, "type").to_sym
+
+      list_item.release = get_required_node(xml_node, "release") do |v|
+        @api_client.release_digestor.from_xml_doc(v)
+      end
+
+      list_item
+    end
+
+  end
+
+end

data/lib/sevendigital/digestion_tract/locker_digestor.rb

@@ -5,12 +5,16 @@ module Sevendigital
 
     def default_element_name; :locker end
 
-    def from_proxy(locker_proxy)
-        make_sure_not_eating_nil (locker_proxy)
-        locker = Locker.new(@api_client)
-        locker.locker_releases = @api_client.locker_release_digestor.list_from_proxy(locker_proxy.locker_releases)
+    def from_xml_doc(xml_node)
+      make_sure_eating_nokogiri_node(xml_node)
 
-        return locker
+      locker = Locker.new(@api_client)
+
+      locker.locker_releases = get_required_node(xml_node, "lockerReleases") do |v|
+        @api_client.locker_release_digestor.list_from_xml_doc(v)
+      end
+
+      locker
     end
 
   end

data/lib/sevendigital/digestion_tract/locker_release_digestor.rb

@@ -3,16 +3,22 @@ module Sevendigital
   #@private
   class LockerReleaseDigestor < Digestor # :nodoc:
     
-    def default_element_name; :locker_release end
-    def default_list_element_name; :locker_releases end
+    def default_element_name; :lockerRelease end
+    def default_list_element_name; :lockerReleases end
+
+    def from_xml_doc(xml_node)
+      make_sure_eating_nokogiri_node(xml_node)
 
-    def from_proxy(locker_release_proxy)
-      make_sure_not_eating_nil(locker_release_proxy)
       locker_release = Sevendigital::LockerRelease.new(@api_client)
-      locker_release.release = @api_client.release_digestor.from_xml(locker_release_proxy.release)
-      locker_release.locker_tracks = @api_client.locker_track_digestor.list_from_xml(locker_release_proxy.locker_tracks, :locker_tracks)
 
-      return locker_release
+      locker_release.release = get_required_node(xml_node, "release") do |v|
+        @api_client.release_digestor.from_xml_doc(v)
+      end
+      locker_release.locker_tracks = get_required_node(xml_node, "lockerTracks") do |v|
+        @api_client.locker_track_digestor.list_from_xml_doc(v)
+      end
+
+      locker_release
     end
 
   end

data/lib/sevendigital/digestion_tract/locker_track_digestor.rb

@@ -3,18 +3,22 @@ module Sevendigital
   #@private
   class LockerTrackDigestor < Digestor # :nodoc:
     
-    def default_element_name; :locker_track end
-    def default_list_element_name; :locker_tracks end
+    def default_element_name; :lockerTrack end
+    def default_list_element_name; :lockerTracks end
+
+    def from_xml_doc(xml_node)
+      make_sure_eating_nokogiri_node(xml_node)
 
-    def from_proxy(locker_track_proxy)
-      make_sure_not_eating_nil(locker_track_proxy)
       locker_track = Sevendigital::LockerTrack.new(@api_client)
-      locker_track.track = @api_client.track_digestor.from_xml(locker_track_proxy.track)
-      locker_track.remaining_downloads = locker_track_proxy.remaining_downloads.value.to_i
-      locker_track.purchase_date =  DateTime.parse(locker_track_proxy.purchase_date.value.to_s)
-      locker_track.download_urls = @api_client.download_url_digestor.list_from_xml(locker_track_proxy.download_urls)
 
-      return locker_track
+      locker_track.track = get_required_node(xml_node, "track") {|v| @api_client.track_digestor.from_xml_doc(v)}
+      locker_track.remaining_downloads = get_required_value(xml_node, "remainingDownloads").to_i
+      locker_track.purchase_date = DateTime.parse(get_required_value(xml_node, "purchaseDate"))
+      locker_track.download_urls = get_required_node(xml_node, "downloadUrls") do |v|
+        @api_client.download_url_digestor.list_from_xml_doc(v)
+      end
+
+      locker_track
     end
 
   end

data/lib/sevendigital/digestion_tract/oauth_access_token_digestor.rb

@@ -5,9 +5,13 @@ module Sevendigital
 
     def default_element_name; :oauth_access_token end
 
-    def from_proxy(token_proxy)
-      make_sure_not_eating_nil(token_proxy)
-      OAuth::AccessToken.new(@api_client.oauth_consumer, token_proxy.oauth_token.value, token_proxy.oauth_token_secret.value)
+    def from_xml_doc(xml_node)
+      make_sure_eating_nokogiri_node(xml_node)
+      OAuth::AccessToken.new(
+              @api_client.oauth_consumer,
+              get_required_value(xml_node,"oauth_token"),
+              get_required_value(xml_node,"oauth_token_secret")
+      )
     end
 
   end

data/lib/sevendigital/digestion_tract/oauth_request_token_digestor.rb

@@ -5,9 +5,13 @@ module Sevendigital
 
     def default_element_name; :oauth_request_token end
 
-    def from_proxy(token_proxy)
-      make_sure_not_eating_nil(token_proxy)
-      OAuth::RequestToken.new(@api_client.oauth_consumer, token_proxy.oauth_token.value, token_proxy.oauth_token_secret.value)
+    def from_xml_doc(xml_node)
+      make_sure_eating_nokogiri_node(xml_node)
+      OAuth::RequestToken.new(
+              @api_client.oauth_consumer,
+              get_required_value(xml_node,"oauth_token"),
+              get_required_value(xml_node,"oauth_token_secret")
+      )
     end
 
   end

data/lib/sevendigital/digestion_tract/pager_digestor.rb

@@ -6,18 +6,22 @@ module Sevendigital
     def default_element_name; :results end
     def default_list_element_name; nil end
 
-    def from_proxy(pager_proxy)
-      make_sure_not_eating_nil(pager_proxy)
-      return nil unless paging_info_available?(pager_proxy)
+    def from_xml_doc(xml_node)
+      make_sure_eating_nokogiri_node(xml_node)
+
+      return nil unless paging_info_available?(xml_node)
+
       pager = Pager.new
-      pager.page = pager_proxy.page.value.to_i
-      pager.page_size = pager_proxy.page_size.value.to_i
-      pager.total_items = pager_proxy.total_items.value.to_i
-      return pager
+
+      pager.page = get_required_value(xml_node,"page").to_i
+      pager.page_size = get_required_value(xml_node,"pageSize").to_i
+      pager.total_items = get_required_value(xml_node,"totalItems").to_i
+
+      pager
     end
 
-    def paging_info_available?(pager_proxy)
-      pager_proxy.page && pager_proxy.page_size && pager_proxy.total_items
+    def paging_info_available?(xml_doc)
+      xml_doc.at_xpath("./page") && xml_doc.at_xpath("./pageSize") && xml_doc.at_xpath("./totalItems")
     end
 
   end

data/lib/sevendigital/digestion_tract/price_digestor.rb

@@ -7,19 +7,22 @@ module Sevendigital
     def default_element_name; :price end
     def default_list_element_name; nil end
   
-    def from_proxy(price_proxy)
-        make_sure_not_eating_nil(price_proxy)
-        price = Sevendigital::Price.new()
-        price.currency_code = price_proxy.currency.code.to_s.upcase.to_sym
-        price.currency_symbol= price_proxy.currency.value
-        price.value= price_proxy.value.value.to_f if !price_proxy.value.value.to_s.empty?
-        price.formatted_price= price_proxy.formatted_price.value
-        price.rrp= price_proxy.rrp.value.to_f if price_proxy.rrp
-        price.formatted_rrp= price_proxy.formatted_rrp.value if price_proxy.formatted_rrp
-        price.on_sale = price_proxy.on_sale.value.to_s.downcase == "true" if price_proxy.on_sale
-
-        return price
+    def from_xml_doc(xml_node)
+      make_sure_eating_nokogiri_node(xml_node)
+      price = Sevendigital::Price.new()
+      get_required_node(xml_node, "currency") do |c|
+        price.currency_code = get_required_attribute(c, "code") {|v| v.upcase.to_sym}
       end
+      price.currency_symbol = get_required_value(xml_node, "currency")
+      price.value = get_required_value(xml_node,"value") {|v| v.to_d unless v.empty?}
+      price.formatted_price = get_required_value(xml_node,"formattedPrice")
+      price.rrp = get_optional_value(xml_node,"rrp") {|v| v.to_d unless v.empty?}
+      price.formatted_rrp = get_optional_value(xml_node,"formattedRrp")
+      price.on_sale = get_optional_value(xml_node,"onSale") {|v| v.downcase == "true"}
+
+      price
+    end
+
 
     end
 

data/lib/sevendigital/digestion_tract/release_digestor.rb

@@ -8,45 +8,37 @@ module Sevendigital
     def default_element_name; :release end
     def default_list_element_name; :releases end
 
-    def from_proxy(release_proxy)
-      make_sure_not_eating_nil(release_proxy)
+    def from_xml_doc(xml_node)
+      make_sure_eating_nokogiri_node(xml_node)
+
       release = Release.new(@api_client)
 
-      populate_required_properties(release, release_proxy)
-      populate_optional_properties(release, release_proxy)
-      populate_formats(release, release_proxy)
+      populate_required_properties(release, xml_node)
+      populate_optional_properties(release, xml_node)
+
+      release
+    end
 
-      return release
+    def populate_required_properties(release, xml_node)
+      release.id = get_required_attribute(xml_node, "id").to_i
+      release.title = get_required_value(xml_node, "title")
+      release.artist = get_required_node(xml_node, "artist") {|v| @api_client.artist_digestor.from_xml_doc(v) }
     end
 
-      def populate_required_properties(release, release_proxy)
-        release.id = release_proxy.id.to_i
-        release.title = release_proxy.title.value.to_s
-        release.artist = @api_client.artist_digestor.from_proxy(release_proxy.artist)
-      end
-
-      def populate_optional_properties(release, release_proxy)
-        release.version = release_proxy.version.value.to_s if release_proxy.version
-        release.type = release_proxy.type.value.downcase.to_sym if value_present?(release_proxy.type)
-        release.barcode = release_proxy.barcode.value.to_s if value_present?(release_proxy.barcode)
-        release.year = release_proxy.year.value.to_i if value_present?(release_proxy.year)
-        release.explicit_content = release_proxy.explicit_content.value.to_s.downcase == "true" if value_present?(release_proxy.explicit_content)
-        release.release_date = DateTime.parse(release_proxy.release_date.value.to_s) if value_present?(release_proxy.release_date)
-        release.added_date = DateTime.parse(release_proxy.added_date.value.to_s) if value_present?(release_proxy.added_date)
-        release.label =  @api_client.label_digestor.from_proxy(release_proxy.label) if content_present?(release_proxy.label)
-        release.image = release_proxy.image.value.to_s if value_present?(release_proxy.image)
-        release.url = release_proxy.url.value.to_s if value_present?(release_proxy.url)
-        release.price =  @api_client.price_digestor.from_proxy(release_proxy.price) if content_present?(release_proxy.price)
-      end
-
-      def populate_formats(release, release_proxy)
-        if release_proxy.formats && release_proxy.formats.format then
-          release.formats = Array.new
-          release_proxy.formats.format.each do |format|
-            release.formats <<  @api_client.format_digestor.from_proxy(format)
-          end
-        end
-      end
+    def populate_optional_properties(release, xml_node)
+      release.version = get_optional_value(xml_node, "version")
+      release.type = get_optional_value(xml_node, "type") {|v| v.to_s.downcase.to_sym}
+      release.barcode = get_optional_value(xml_node, "barcode")
+      release.year = get_optional_value(xml_node, "year") {|v| v.to_i}
+      release.explicit_content = get_optional_value(xml_node, "explicitContent") {|v| v.to_s.downcase == "true"}
+      release.release_date = get_optional_value(xml_node, "releaseDate") {|v| DateTime.parse(v)}
+      release.added_date = get_optional_value(xml_node, "addedDate") {|v| DateTime.parse(v)}
+      release.label = get_optional_node(xml_node, "label") {|v| @api_client.label_digestor.from_xml_doc(v)}
+      release.image = get_optional_value(xml_node, "image")
+      release.url = get_optional_value(xml_node, "url")
+      release.price = get_optional_node(xml_node, "price") {|v| @api_client.price_digestor.from_xml_doc(v)}
+      release.formats = get_optional_node(xml_node, "formats") {|v| @api_client.format_digestor.list_from_xml_doc(v)}
+    end
 
   end
 

data/lib/sevendigital/digestion_tract/tag_digestor.rb

@@ -6,16 +6,17 @@ module Sevendigital
     def default_element_name; :tag end
     def default_list_element_name; :tags end
     
-    def from_proxy(tag_proxy)
-      make_sure_not_eating_nil(tag_proxy)
+    def from_xml_doc(xml_node)
+      make_sure_eating_nokogiri_node(xml_node)
 
       tag = Tag.new()
-      tag.id = tag_proxy.id.to_s
-      tag.text = tag_proxy.text.value.to_s
-      tag.url = tag_proxy.url.value.to_s if value_present?(tag_proxy.url)
-      tag.count = tag_proxy.count_.value.to_i  if value_present?(tag_proxy.count_)
 
-      return tag
+      tag.id = get_required_attribute(xml_node, "id")
+      tag.text = get_required_value(xml_node, "text")
+      tag.url = get_optional_value(xml_node, "url")
+      tag.count = get_optional_value(xml_node, "count") {|v| v.to_i}
+
+      tag
     end
 
   end

data/lib/sevendigital/digestion_tract/track_digestor.rb

@@ -6,33 +6,32 @@ module Sevendigital
     def default_element_name; :track end
     def default_list_element_name; :tracks end
 
-
-    def from_proxy(track_proxy)
-      make_sure_not_eating_nil (track_proxy)
-
-      track = Track.new(@api_client)
-      populate_required_properties(track, track_proxy)
-      populate_optional_properties(track, track_proxy)
-
-      return track
-    end
-
-    def populate_required_properties(track, track_proxy)
-      track.id = track_proxy.id.to_i
-      track.title = track_proxy.title.value.to_s
-      track.artist = @api_client.artist_digestor.from_proxy(track_proxy.artist)
-    end
-
-    def populate_optional_properties(track, track_proxy)
-      track.version = track_proxy.version.value.to_s if track_proxy.version
-      track.track_number = track_proxy.track_number.value.to_i if track_proxy.track_number
-      track.duration = track_proxy.duration.value.to_i if track_proxy.duration
-      track.release = @api_client.release_digestor.from_proxy(track_proxy.release) if track_proxy.release
-      track.explicit_content = track_proxy.explicit_content.value.to_s.downcase == "true" if track_proxy.explicit_content
-      track.isrc = track_proxy.isrc.value.to_s if track_proxy.isrc
-      track.image = track_proxy.image.value.to_s if track_proxy.image
-      track.url = track_proxy.url.value.to_s if track_proxy.url
-      track.price = @api_client.price_digestor.from_proxy(track_proxy.price) if track_proxy.price
-    end
+    def from_xml_doc(xml_node)
+         make_sure_eating_nokogiri_node(xml_node)
+
+         track = Track.new(@api_client)
+
+         populate_required_properties(track, xml_node)
+         populate_optional_properties(track, xml_node)
+
+         track
+       end
+
+       def populate_required_properties(track, xml_node)
+         track.id = get_required_attribute(xml_node, "id").to_i
+         track.title = get_required_value(xml_node, "title")
+         track.artist = get_required_node(xml_node, "artist") {|v| @api_client.artist_digestor.from_xml_doc(v) }
+       end
+
+       def populate_optional_properties(track, xml_node)
+         track.version = get_optional_value(xml_node, "version")
+         track.track_number = get_optional_value(xml_node, "trackNumber") {|v| v.to_i}
+         track.duration = get_optional_value(xml_node, "duration") {|v| v.to_i}
+         track.release = get_optional_node(xml_node, "release") {|v |@api_client.release_digestor.from_xml_doc(v)}
+         track.explicit_content = get_optional_value(xml_node, "explicitContent") {|v| v.downcase == "true"}
+         track.isrc = get_optional_value(xml_node, "isrc")
+         track.url = get_optional_value(xml_node, "url")
+         track.price =  get_optional_node(xml_node, "price") {|v| @api_client.price_digestor.from_xml_doc(v)}
+       end
   end
 end