7digital 0.0.7 → 0.1.0

data/lib/sevendigital/client.rb

@@ -53,7 +53,13 @@ module Sevendigital
     end
 
     def configuration
-      return @configuration
+      @configuration
+    end
+
+    def log(severity, &block)
+      if self.send("#{severity}?")
+        logger.info(yield) if block_given?
+      end
     end
 
     def operator
@@ -61,17 +67,17 @@ module Sevendigital
     end
 
     def verbose?
-     !!(@verbose || @configuration.verbose)
+     very_verbose? || !!@verbose || !!@configuration.verbose
     end
 
     def very_verbose?
-      verbose? && (@verbose || @configuration.verbose).to_s == "very_verbose"
+      @very_verbose || @configuration.verbose.to_s == "very_verbose"
     end
 
   #@private
   def api_host_and_version(api_service=nil)
      service = api_service && !api_service.to_s.empty? ? "#{api_service}_" : ""
-     return configuration.send("#{service}api_url".to_sym), configuration.send("#{service}api_version".to_sym)
+     [configuration.send("#{service}api_url".to_sym), configuration.send("#{service}api_version".to_sym)]
   end
 
   #@private
@@ -107,7 +113,10 @@ module Sevendigital
       params
     end
 
-
+    #@private
+    def logger
+      path = (@configuration.logfile_path.nil? || @configuration.logfile_path.blank?) ? STDOUT : @configuration.logfile_path
+      @logger ||= Logger.new(path)
+    end
   end
-
 end

data/lib/sevendigital/client_configuration.rb

@@ -79,8 +79,5 @@ module Sevendigital
       new_hash = hash.inject({}){|memo,(k,v)| memo[k.to_sym] = transform_keys_to_symbols(v); memo}
       new_hash
     end
-
-
   end
-
 end

data/lib/sevendigital/client_digestors.rb

@@ -27,6 +27,11 @@ module Sevendigital
       @chart_item_digestor ||= ChartItemDigestor.new(self)
     end
 
+    #@private
+    def country_digestor
+      @country_digestor ||= CountryDigestor.new(self)
+    end
+
     #@private
     def download_url_digestor
       @download_url_digestor ||= DownloadUrlDigestor.new(self)
@@ -57,6 +62,16 @@ module Sevendigital
       @locker_track_digestor ||= LockerTrackDigestor.new(self)
     end
 
+    #@private
+    def list_digestor
+      @list_digestor ||= ListDigestor.new(self)
+    end
+
+    #@private
+    def list_item_digestor
+      @list_item_digestor ||= ListItemDigestor.new(self)
+    end
+
     #@private
     def oauth_request_token_digestor
       @oauth_request_token_digestor ||= OAuthRequestTokenDigestor.new(self)

data/lib/sevendigital/client_managers.rb

@@ -4,7 +4,7 @@ module Sevendigital
 
     #@return [ArtistManager]
     def artist
-      @artist_manager ||= ArtistManager.new(self) 
+      @artist_manager ||= ArtistManager.new(self)
     end
 
     #@return [BasketManager]
@@ -12,6 +12,16 @@ module Sevendigital
       @basket_manager ||= BasketManager.new(self)
     end
 
+    #@return [CountrytManager]
+    def country
+      @country_manager ||= CountryManager.new(self)
+    end
+
+    #@return [ListManager]
+    def list
+      @list_manager ||= ListManager.new(self)
+    end
+
     #@return [ReleaseManager]
     def release
       @release_manager ||= ReleaseManager.new(self)

data/lib/sevendigital/digestion_tract/api_response_digestor.rb

@@ -1,58 +1,49 @@
+require 'nokogiri'
+
 module Sevendigital
 
   #@private
   class ApiResponseDigestor < Digestor # :nodoc:
 
-    def from_xml(xml_or_proxy, element_name = :response)
-      return from_proxy(ProxyPolice.ensure_is_proxy(xml_or_proxy, element_name))
-    end
-
-    def from_proxy(proxy)
-      if proxy && proxy.status then
-        return from_ok_response(proxy)  if proxy.status == 'ok'
-        return from_error_response(proxy.error) if proxy.status == 'error' && proxy.error
-      end
-      return from_invalid_xml
-    end
+    def default_element_name; :response end
 
-    def from_invalid_xml
+    def from_http_response(http_response)
       response = ApiResponse.new
-      response.error_code = 10000
-      response.error_message = 'Invalid 7digital API response'
-      return response
-    end
+      response.headers = http_response.header
+      response.content = http_response.body.to_s
 
-    def from_error_response(error)
-      response = ApiResponse.new
-      response.error_code = error.code.to_i
-      response.error_message = error.error_message.value.to_s
-      return response
-    end
+      parse_xml_doc(response.content, response)
 
-    def from_ok_response(response_content)
-      response = ApiResponse.new
-      response.error_code = 0
-      response.content = response_content
-      return response
+      if response.error_code >= 10000 && !http_response.is_a?(Net::HTTPSuccess)
+        response.error_code = Integer(http_response.code)
+        response.error_message= http_response.body.to_s
+      end
+      response
     end
 
-    def from_http_response(http_response)
-      if http_response.is_a?(Net::HTTPSuccess) then
-        response = from_xml(http_response.body.to_s)
+    def parse_xml_doc(xml, response)
+
+      xml_doc = Nokogiri::XML(xml)
+
+      response_node = xml_doc.at_xpath("./response")
+      response_status = nil
+      response_status = get_optional_attribute(response_node, "status") if response_node
+      puts xml.inspect
+      if response_status == 'ok' then
+        response.error_code = 0
       else
-        response = from_invalid_http_response(http_response)
+        if response_status == 'error'
+          error_node = get_required_node(response_node, "error")
+          response.error_code = get_required_attribute(error_node, "code").to_i
+          response.error_message = get_required_value(error_node, "errorMessage")
+        else
+          response.error_code = 10001
+          response.error_message = 'Invalid 7digital API response'
+        end
       end
-      response.headers = http_response.header
-      response
-    end
 
-    def from_invalid_http_response(http_response)
-      response = ApiResponse.new
-      response.error_code = Integer(http_response.code)
-      response.error_message= http_response.body.to_s
-      return response
     end
-  
+
   end
 
 end

data/lib/sevendigital/digestion_tract/artist_digestor.rb

@@ -1,3 +1,5 @@
+require 'nokogiri'
+
 module Sevendigital
 
   #@private
@@ -6,26 +8,27 @@ module Sevendigital
     def default_element_name; :artist end
     def default_list_element_name; :artists end
 
-    def from_proxy(artist_proxy)
-      make_sure_not_eating_nil(artist_proxy)
+    def from_xml_doc(xml_doc)
+      make_sure_eating_nokogiri_node(xml_doc)
       artist = Artist.new(@api_client)
-      populate_required_properties(artist, artist_proxy)
-      populate_optional_properties(artist, artist_proxy)
-      return artist
+      populate_required_properties(artist, xml_doc)
+      populate_optional_properties(artist, xml_doc)
+      artist
     end
 
     private
     
-    def populate_required_properties(artist, artist_proxy)
-      artist.id = artist_proxy.id.to_i
-      artist.name = artist_proxy.name.value.to_s
+    def populate_required_properties(artist, xml_node)
+      artist.id = get_required_attribute(xml_node, "id") {|v| v.to_i}
+      artist.name = get_required_value(xml_node, "name")
     end
 
-    def populate_optional_properties(artist, artist_proxy)
-      artist.sort_name = artist_proxy.sort_name.value.to_s if artist_proxy.sort_name
-      artist.appears_as = artist_proxy.appears_as.value.to_s if artist_proxy.appears_as
-      artist.image = artist_proxy.image.value.to_s if artist_proxy.image
-      artist.url = artist_proxy.url.value.to_s if artist_proxy.url
+    def populate_optional_properties(artist, artist_node)
+      artist.sort_name =  get_optional_value(artist_node, :sortName)
+      artist.appears_as = get_optional_value(artist_node, :appearsAs)
+      artist.image = get_optional_value(artist_node, :image)
+      artist.url = get_optional_value(artist_node, :url)
+      artist.popularity = get_optional_value(artist_node, :popularity) {|v| v.to_s.to_d}
     end
 
   end

data/lib/sevendigital/digestion_tract/basket_digestor.rb

@@ -5,13 +5,13 @@ module Sevendigital
 
     def default_element_name; :basket end
 
-    def from_proxy(basket_proxy)
-        make_sure_not_eating_nil (basket_proxy)
+    def from_xml_doc(xml_node)
+        make_sure_eating_nokogiri_node(xml_node)
         basket = Sevendigital::Basket.new(@api_client)
-        basket.id = basket_proxy.id.to_s
-        basket.basket_items = @api_client.basket_item_digestor.list_from_proxy(basket_proxy.basket_items)
+        basket.id = get_required_attribute(xml_node, "id")
+        basket.basket_items = get_required_node(xml_node, "basketItems") { |v| @api_client.basket_item_digestor.list_from_xml_doc(v) }
 
-        return basket
+        basket
     end
 
   end

data/lib/sevendigital/digestion_tract/basket_item_digestor.rb

@@ -3,22 +3,22 @@ module Sevendigital
   #@private
   class BasketItemDigestor < Digestor # :nodoc:
     
-    def default_element_name; :basket_item end
-    def default_list_element_name; :basket_items end
+    def default_element_name; :basketItem end
+    def default_list_element_name; :basketItems end
 
-    def from_proxy(basket_item_proxy)
-      make_sure_not_eating_nil(basket_item_proxy)
+    def from_xml_doc(xml_node)
+      make_sure_eating_nokogiri_node(xml_node)
       basket_item = BasketItem.new(@api_client)
 
-      basket_item.id = basket_item_proxy.id.to_i
-      basket_item.type = basket_item_proxy.type.value.downcase.to_sym
-      basket_item.artist_name = basket_item_proxy.artist_name.value.to_s
-      basket_item.item_name = basket_item_proxy.item_name.value.to_s
-      basket_item.release_id = basket_item_proxy.release_id.value.to_i
-      basket_item.track_id = basket_item_proxy.track_id.value.to_i
-      basket_item.price = @api_client.price_digestor.from_proxy(basket_item_proxy.price)
+      basket_item.id = get_required_attribute(xml_node, "id") {|v| v.to_i}
+      basket_item.type = get_required_value(xml_node, "type") {|v| v.downcase.to_sym}
+      basket_item.artist_name = get_required_value(xml_node, "artistName")
+      basket_item.item_name = get_required_value(xml_node, "itemName")
+      basket_item.release_id = get_required_value(xml_node, "releaseId") {|v| v.to_i}
+      basket_item.track_id = get_required_value(xml_node, "trackId") {|v| v.to_i}
+      basket_item.price = get_required_node(xml_node, "price") {|v| @api_client.price_digestor.from_xml_doc(v)}
 
-      return basket_item
+      basket_item
     end
 
   end

data/lib/sevendigital/digestion_tract/chart_item_digestor.rb

@@ -3,25 +3,31 @@ module Sevendigital
   #@private
   class ChartItemDigestor < Digestor # :nodoc:
 
-    def default_element_name; :chart_item end
+    def default_element_name; :chartItem end
     def default_list_element_name; :chart end
     
     def from_proxy(chart_item_proxy)
       
-      make_sure_not_eating_nil(chart_item_proxy)
-      
+      from_xml_string(chart_item_proxy.to_s)
+
+    end
+
+    def from_xml_doc(xml_node)
+      make_sure_eating_nokogiri_node(xml_node)
+
       chart_item = ChartItem.new(@client)
-      chart_item.position = chart_item_proxy.position.value.to_i
-      chart_item.change = chart_item_proxy.change.value.to_s.downcase.to_sym
-      if chart_item_proxy.release then
-        chart_item.item = @api_client.release_digestor.from_proxy(chart_item_proxy.release)
-      elsif chart_item_proxy.track
-        chart_item.item = @api_client.track_digestor.from_proxy(chart_item_proxy.track)
+
+      chart_item.position = get_required_value(xml_node, "position") {|v| v.to_i}
+      chart_item.change = get_required_value(xml_node, "change") {|v| v.downcase.to_sym}
+      if xml_node.at_xpath("./release") then
+        chart_item.item = get_required_node(xml_node, "release") {|v| @api_client.release_digestor.from_xml_doc(v) }
+      elsif xml_node.at_xpath("./track")
+        chart_item.item = get_required_node(xml_node, "track") {|v| @api_client.track_digestor.from_xml_doc(v) }
       else
-        chart_item.item = @api_client.artist_digestor.from_proxy(chart_item_proxy.artist)
+        chart_item.item = get_required_node(xml_node, "artist") {|v| @api_client.artist_digestor.from_xml_doc(v) }
       end
       return chart_item
-     end
+    end
 
   end
   

data/lib/sevendigital/digestion_tract/country_digestor.rb

@@ -0,0 +1,16 @@
+module Sevendigital
+
+  #@private
+  class CountryDigestor < Digestor # :nodoc:
+
+    def default_element_name; :country end
+
+    def from_xml_doc(xml_node)
+      make_sure_eating_nokogiri_node(xml_node)
+
+      get_required_value(xml_node, "countryCode")
+    end
+
+  end
+
+end

data/lib/sevendigital/digestion_tract/digestor.rb

@@ -10,50 +10,50 @@ module Sevendigital
         @api_client = api_client
       end
 
-      def from_xml(xml_or_proxy, element_name = default_element_name)
-        return from_proxy(ProxyPolice.ensure_is_proxy(xml_or_proxy, element_name))
+      def from_xml_string(xml, element_name = default_element_name)
+        xml_doc = Nokogiri::XML(xml)
+        from_xml_doc(xml_doc.at_xpath("./#{element_name}"))
       end
 
-      def list_from_xml(xml_or_proxy, list_element_name = default_list_element_name)
-        list_from_proxy(ProxyPolice.ensure_is_proxy(xml_or_proxy, list_element_name))
-      end
+      def list_from_xml_string(xml, list_element_name = default_list_element_name)
+         xml_doc = Nokogiri::XML(xml)
+         list_from_xml_doc(xml_doc.at_xpath("./#{list_element_name}"))
+       end
 
-      def list_from_proxy(object_list_proxy)
-        make_sure_not_eating_nil(object_list_proxy)
-        list = []
-        return list if object_list_proxy.kind_of?(Peachy::SimpleContent)
-        if object_list_proxy.send(default_element_name) then
-          object_list_proxy.send(default_element_name).each { |object_proxy| list << from_proxy(object_proxy) }
-        end
-        paginate_results(object_list_proxy, list)
-      end
+       def list_from_xml_doc(list_node)
+         make_sure_eating_nokogiri_node(list_node)
+         list = []
+         list_node.xpath("./#{default_element_name}").each { |node| list << from_xml_doc(node)}
+         paginate_results(list_node, list)
+       end
 
       #nested parsing for api methods that return standard object inside containers with no additional (useful) information
       #e.g. tagged_item.artist, recommendation.release, search_result.track, etc
 
-      def nested_list_from_xml(xml_or_proxy, container_element_name, list_element_name = default_list_element_name)
-        nested_list_from_proxy(ProxyPolice.ensure_is_proxy(xml_or_proxy, list_element_name), container_element_name)
+      def nested_list_from_xml_string(xml, container_element_name, list_element_name = default_list_element_name)
+        xml_doc = Nokogiri::XML(xml)
+        nested_list_from_xml_doc(xml_doc.at_xpath("./#{container_element_name}"), list_element_name)
       end
 
-      def nested_list_from_proxy(object_list_proxy, container_element_name)
-        make_sure_not_eating_nil(object_list_proxy)
+      def nested_list_from_xml_doc(list_node, list_element_name = default_list_element_name, element_name = default_element_name)
+        puts list_element_name
+        puts element_name
+        puts list_node.inspect
+        make_sure_eating_nokogiri_node(list_node)
         list = []
-        if object_list_proxy.send(container_element_name) then
-          object_list_proxy.send(container_element_name).each do
-            |object_proxy| list << from_proxy(object_proxy.send(default_element_name))
-          end 
-        end
-        return paginate_results(object_list_proxy, list)
+        list_node.xpath("./#{list_element_name}/#{element_name}").each { |node| list << from_xml_doc(node)}
+        paginate_results(list_node, list)
       end
 
-      def paginate_results(xml_results, list)
-        pager = @api_client.pager_digestor.from_xml(xml_results)
+      def paginate_results(results_xml_node, list)
+        pager = @api_client.pager_digestor.from_xml_doc(results_xml_node)
         return list if !pager
         pager.paginate_list(list)
       end
 
-      def make_sure_not_eating_nil(proxy)
-        raise DigestiveProblem, "There's nothing i can digest" unless proxy
+      def make_sure_eating_nokogiri_node(xml)
+        raise DigestiveProblem, "There's nothing i can digest" unless xml
+        raise DigestiveProblem, "I'm not eating this! It's not a Nokogiri XML node.'" unless xml.kind_of?(Nokogiri::XML::Node)
       end
 
       def value_present?(proxy_node)
@@ -64,6 +64,60 @@ module Sevendigital
         !proxy_node.nil?
       end
 
+      def get_required_value(node, element_name)
+        if node.at_xpath("./#{element_name}") then
+          content = node.at_xpath("./#{element_name}").content
+          return yield(content) if block_given?
+          return content
+        end
+        raise DigestiveProblem, "I need #{element_name} element to digest the response"
+      end
+
+      def get_required_node(node, element_name)
+        if node.at_xpath("./#{element_name}") then
+          subnode = node.at_xpath("./#{element_name}")
+          return yield(subnode) if block_given?
+          return subnode
+        end
+        raise DigestiveProblem, "I need #{element_name} element to digest the response"
+      end
+
+      def get_required_attribute(node, attribute_name)
+        if node.at_xpath("@#{attribute_name}") then
+          content = node.at_xpath("@#{attribute_name}").content
+          return yield(content) if block_given?
+          return content
+        end
+        raise DigestiveProblem, "I need #{attribute_name} attribute to digest the response"
+      end
+
+      def get_optional_value(node, element_name)
+        if node.at_xpath("./#{element_name}") then
+          content = node.at_xpath("./#{element_name}").content
+          return yield(content) if block_given?
+          return content
+        end
+        nil
+      end
+
+      def get_optional_node(node, element_name)
+        if node.at_xpath("./#{element_name}") then
+          subnode = node.at_xpath("./#{element_name}")
+          return yield(subnode) if block_given?
+          return subnode
+        end
+        nil
+      end
+
+      def get_optional_attribute(node, attribute_name)
+        if node.at_xpath("@#{attribute_name}") then
+          content = node.at_xpath("@#{attribute_name}").content
+          return yield(content) if block_given?
+          return content
+        end
+        nil
+      end
+
   end
 
   class DigestiveProblem < StandardError;  end