geocaching 0.7.1 → 0.8.0

data/lib/geocaching/cache.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
-require "geocaching/parsers/cache_simple"
-require "geocaching/parsers/cache_gpx"
+require "geocaching/parsers/cache_simple_parser"
+require "geocaching/parsers/cache_gpx_parser"
 
 module Geocaching
   class Cache
@@ -29,11 +29,11 @@ module Geocaching
     attr_accessor :attributes
 
     def self.from_xml(doc)
-      Parsers::CacheSimple.new(doc).parse
+      Parsers::CacheSimpleParser.new(doc).parse
     end
 
     def self.from_gpx(doc)
-      Parsers::CacheGPX.new(doc).parse
+      Parsers::CacheGPXParser.new(doc).parse
     end
 
     def initialize(attributes = {})

data/lib/geocaching/cache_attribute.rb

@@ -1,13 +1,13 @@
 # encoding: utf-8
 
-require "geocaching/parsers/cache_attribute"
+require "geocaching/parsers/cache_attribute_parser"
 
 module Geocaching
   class CacheAttribute
     attr_accessor :name
 
     def self.from_xml(doc)
-      Parsers::CacheAttribute.new(doc).parse
+      Parsers::CacheAttributeParser.new(doc).parse
     end
 
     def initialize(attributes = {})

data/lib/geocaching/log.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-require "geocaching/parsers/log"
+require "geocaching/parsers/log_parser"
 
 module Geocaching
   class Log
@@ -13,7 +13,7 @@ module Geocaching
     attr_reader   :type
 
     def self.from_xml(doc)
-      Parsers::Log.new(doc).parse
+      Parsers::LogParser.new(doc).parse
     end
 
     def initialize(attributes = {})

data/lib/geocaching/parsers/{cache_attribute.rb → cache_attribute_parser.rb}

@@ -2,7 +2,7 @@
 
 module Geocaching
   module Parsers
-    class CacheAttribute
+    class CacheAttributeParser
       def initialize(doc)
         @doc = doc
       end

data/lib/geocaching/parsers/cache_gpx_parser.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require "geocaching/parsers/gpx_cache_waypoint_parser"
+require "geocaching/parsers/gpx_additional_waypoint_parser"
+
+module Geocaching
+  module Parsers
+    class CacheGPXParser
+      def initialize(doc)
+        @doc = doc
+      end
+
+      def parse
+        cache = nil
+        is_first_wpt = true
+
+        @doc.xpath("//xmlns:gpx/xmlns:wpt").each do |wpt_node|
+          if is_first_wpt
+            cache = GPXCacheWaypointParser.new(wpt_node).parse
+            is_first_wpt = false
+          else
+            cache.waypoints << GPXAdditionalWaypointParser.new(wpt_node).parse
+          end
+        end
+
+        cache
+      end
+    end
+  end
+end

data/lib/geocaching/parsers/{cache_simple.rb → cache_simple_parser.rb}

@@ -2,10 +2,7 @@
 
 module Geocaching
   module Parsers
-    class CacheSimple
-      CACHE_CODE_REGEXP = /^GC[A-Z0-9]+$/
-      COORDINATE_REGEXP = /^-?[0-9]{1,3}\.[0-9]{1,}$/
-
+    class CacheSimpleParser
       def initialize(doc)
         @doc = doc
       end
@@ -33,11 +30,7 @@ module Geocaching
 
       def parse_code(cache_node)
         if node = cache_node.xpath("./xmlns:CacheCode").first
-          if node.text =~ CACHE_CODE_REGEXP
-            node.text
-          else
-            raise ParseError, "Got an invalid value for cache code from API"
-          end
+          node.text
         else
           raise ParseError, "Could not parse cache code from XML"
         end
@@ -53,11 +46,7 @@ module Geocaching
 
       def parse_latitude(cache_node)
         if node = cache_node.xpath("./xmlns:Latitude").first
-          if node.text =~ COORDINATE_REGEXP
-            node.text.to_f
-          else
-            raise ParseError, "Got a non-numeric value for latitude from API"
-          end
+          node.text.to_f
         else
           raise ParseError, "Could not parse latitude from XML"
         end
@@ -65,11 +54,7 @@ module Geocaching
 
       def parse_longitude(cache_node)
         if node = cache_node.xpath("./xmlns:Longitude").first
-          if node.text =~ COORDINATE_REGEXP
-            node.text.to_f
-          else
-            raise ParseError, "Got a non-numeric value for longitude from API"
-          end
+          node.text.to_f
         else
           raise ParseError, "Could not parse longitude from XML"
         end

data/lib/geocaching/parsers/{cache_gpx_additional_waypoint.rb → gpx_additional_waypoint_parser.rb}

@@ -2,9 +2,7 @@
 
 module Geocaching
   module Parsers
-    class CacheGPXAdditionalWaypoint
-      COORDINATE_REGEXP = /^-?[0-9]{1,3}\.[0-9]{1,}$/
-
+    class GPXAdditionalWaypointParser
       def initialize(wpt_node)
         @wpt_node = wpt_node
       end
@@ -33,7 +31,7 @@ module Geocaching
       end
 
       def parse_latitude(wpt_node)
-        if wpt_node["lat"] =~ COORDINATE_REGEXP
+        if wpt_node["lat"]
           wpt_node["lat"].to_f
         else
           raise ParseError, "Invalid waypoint latitude in GPX"
@@ -41,7 +39,7 @@ module Geocaching
       end
 
       def parse_longitude(wpt_node)
-        if wpt_node["lon"] =~ COORDINATE_REGEXP
+        if wpt_node["lon"]
           wpt_node["lon"].to_f
         else
           raise ParseError, "Invalid waypoint longitude in GPX"

data/lib/geocaching/parsers/{cache_gpx_cache_waypoint.rb → gpx_cache_parser.rb}

@@ -2,35 +2,19 @@
 
 module Geocaching
   module Parsers
-    class CacheGPXCacheWaypoint
-      CACHE_CODE_REGEXP = /^GC[A-Z0-9]+$/
-      COORDINATE_REGEXP = /^-?[0-9]{1,3}\.[0-9]{1,}$/
-
-      WPT_NODE_ATTRIBUTES = %w(guid code latitude longitude hidden_at)
-
-      def initialize(wpt_node)
-        @wpt_node = wpt_node
+    class GPXCacheParser
+      def initialize(cache_node)
+        @cache_node = cache_node
       end
 
       def parse
         cache = Cache.new
 
-        WPT_NODE_ATTRIBUTES.each do |attribute|
-          value = send("parse_#{attribute}", @wpt_node)
-          cache.send("#{attribute}=", value) unless value.nil?
-        end
-
-        if cache_node = @wpt_node.xpath("./gpx:extensions/cache:cache", ns).first
-          private_methods.each do |method|
-            if method.to_s =~ /^parse_([a-z_]+)$/
-              unless WPT_NODE_ATTRIBUTES.include?($1)
-                value = send(method, cache_node)
-                cache.send("#{$1}=", value) unless value.nil?
-              end
-            end
+        private_methods.each do |method|
+          if method.to_s =~ /^parse_([a-z_]+)$/
+            value = send(method, @cache_node)
+            cache.send("#{$1}=", value) unless value.nil?
           end
-        else
-          raise ParseError, "Could not parse GPX"
         end
 
         cache
@@ -38,51 +22,6 @@ module Geocaching
 
     private
 
-      def parse_code(wpt_node)
-        if node = wpt_node.xpath("./gpx:name", ns).first
-          node.text
-        else
-          raise ParseError, "Could not parse cache code from GPX"
-        end
-      end
-
-      def parse_guid(wpt_node)
-        if node = wpt_node.xpath("./gpx:link", ns).first and node["href"] =~ /guid=([a-f0-9-]{36})/
-          $1
-        else
-          raise ParseError, "Could not parse cache GUID from GPX"
-        end
-      end
-
-      def parse_latitude(wpt_node)
-        if wpt_node["lat"] =~ COORDINATE_REGEXP
-          wpt_node["lat"].to_f
-        else
-          raise ParseError, "Invalid latitude in GPX"
-        end
-      end
-
-      def parse_longitude(wpt_node)
-        if wpt_node["lon"] =~ COORDINATE_REGEXP
-          wpt_node["lon"].to_f
-        else
-          raise ParseError, "Invalid longitude in GPX"
-        end
-      end
-
-      def parse_hidden_at(wpt_node)
-        if node = wpt_node.xpath("./gpx:time", ns).first
-          begin
-            time = Time.parse(node.text)
-            Time.mktime(time.year, time.month, time.day)
-          rescue ArgumentError
-            raise ParseError, "Invalid hidden date in GPX"
-          end
-        else
-          raise ParseError, "Could not parse hidden date from GPX"
-        end
-      end
-
       def parse_name(cache_node)
         if node = cache_node.xpath("./cache:name", ns).first
           node.text
@@ -225,7 +164,7 @@ module Geocaching
 
       def ns
         {
-          "gpx" => "http://www.topografix.com/GPX/1/1",
+          "gpx" => "http://www.topografix.com/GPX/1/0",
           "cache" => "http://www.groundspeak.com/cache/1/0"
         }
       end

data/lib/geocaching/parsers/gpx_cache_waypoint_parser.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+
+require "geocaching/parsers/gpx_cache_parser"
+
+module Geocaching
+  module Parsers
+    class GPXCacheWaypointParser
+      def initialize(wpt_node)
+        @wpt_node = wpt_node
+      end
+
+      def parse
+        cache = Cache.new
+
+        if cache_node = @wpt_node.xpath("./gpx:extensions/cache:cache", ns).first
+          cache = GPXCacheParser.new(cache_node).parse
+        else
+          cache = Cache.new
+        end
+
+        %w(guid code latitude longitude hidden_at).each do |attribute|
+          value = send("parse_#{attribute}", @wpt_node)
+          cache.send("#{attribute}=", value) unless value.nil?
+        end
+
+        cache
+      end
+
+    private
+
+      def parse_code(wpt_node)
+        if node = wpt_node.xpath("./gpx:name", ns).first
+          node.text
+        else
+          raise ParseError, "Could not parse cache code from GPX"
+        end
+      end
+
+      def parse_guid(wpt_node)
+        if node = wpt_node.xpath("./gpx:link", ns).first and node["href"] =~ /guid=([a-f0-9-]{36})/
+          $1
+        else
+          raise ParseError, "Could not parse cache GUID from GPX"
+        end
+      end
+
+      def parse_latitude(wpt_node)
+        if wpt_node["lat"]
+          wpt_node["lat"].to_f
+        else
+          raise ParseError, "Could not parse latitude from GPX"
+        end
+      end
+
+      def parse_longitude(wpt_node)
+        if wpt_node["lon"]
+          wpt_node["lon"].to_f
+        else
+          raise ParseError, "Could not parse longitude from GPX"
+        end
+      end
+
+      def parse_hidden_at(wpt_node)
+        if node = wpt_node.xpath("./gpx:time", ns).first
+          begin
+            time = Time.parse(node.text)
+            Time.mktime(time.year, time.month, time.day)
+          rescue ArgumentError
+            raise ParseError, "Invalid hidden date in GPX"
+          end
+        else
+          raise ParseError, "Could not parse hidden date from GPX"
+        end
+      end
+
+      def ns
+        {
+          "gpx" => "http://www.topografix.com/GPX/1/1",
+          "cache" => "http://www.groundspeak.com/cache/1/0"
+        }
+      end
+    end
+  end
+end

data/lib/geocaching/parsers/{log.rb → log_parser.rb}

@@ -2,7 +2,7 @@
 
 module Geocaching
   module Parsers
-    class Log
+    class LogParser
       def initialize(doc)
         @doc = doc
       end

data/lib/geocaching/parsers/pocket_query_data_set_parser.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+
+module Geocaching
+  module Parsers
+    class PocketQueryDataSetParser
+      def initialize(doc)
+        @doc = doc
+      end
+
+      def parse
+        pocket_queries = []
+
+        @doc.xpath("//xmlns:PocketQueryDataSet/xmlns:PocketQuery").each do |pocket_query_node|
+          pocket_query = PocketQuery.new
+
+          private_methods.each do |method|
+            if method.to_s =~ /^parse_([a-z_]+)$/
+              value = send(method, pocket_query_node)
+              pocket_query.send("#{$1}=", value) unless value.nil?
+            end
+          end
+
+          pocket_queries << pocket_query
+        end
+
+        pocket_queries
+      end
+
+    private
+
+      def parse_guid(pocket_query_node)
+        if node = pocket_query_node.xpath("./xmlns:PQGuid").first
+          node.text
+        else
+          raise ParseError, "Could not parse Pocket Query GUID"
+        end
+      end
+
+      def parse_name(pocket_query_node)
+        if node = pocket_query_node.xpath("./xmlns:Name").first
+          node.text
+        else
+          raise ParseError, "Could not parse Pocket Query name"
+        end
+      end
+
+      def parse_generated_at(pocket_query_node)
+        if node = pocket_query_node.xpath("./xmlns:LastGenerated").first
+          begin
+            Time.parse(node.text)
+          rescue ArgumentError
+            raise ParseError, "Invalid Pocket Query generation date"
+          end
+        else
+          raise ParseError, "Could not parse Pocket Query generation date"
+        end
+      end
+
+      def parse_is_download_available(pocket_query_node)
+        if node = pocket_query_node.xpath("./xmlns:DownloadAvailable").first
+          if %w(true false).include?(node.text)
+            node.text == "true"
+          else
+            raise ParseError, "Invalid Pocket Query download availability"
+          end
+        else
+          raise ParseError, "Could not parse Pocket Query download availability"
+        end
+      end
+
+      def parse_filesize(pocket_query_node)
+        if node = pocket_query_node.xpath("./xmlns:FileSizeInBytes").first
+          node.text.to_i unless node.text.to_i == -1
+        else
+          raise ParseError, "Could not parse Pocket Query file size"
+        end
+      end
+
+      def parse_results_count(pocket_query_node)
+        if node = pocket_query_node.xpath("./xmlns:LastRunCount").first
+          node.text.to_i unless node.text.to_i == -1
+        else
+          raise ParseError, "Could not parse Pocket Query results count"
+        end
+      end
+    end
+  end
+end

data/lib/geocaching/parsers/pocket_query_parser.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+
+require "geocaching/parsers/gpx_cache_parser"
+
+module Geocaching
+  module Parsers
+    class PocketQueryParser
+      def initialize(xml)
+        @doc = Nokogiri::XML.parse(xml)
+      rescue
+        raise ParseError, "Could not parse Pocket Query XML"
+      end
+
+      def parse
+        pocket_query = PocketQuery.new
+
+        pocket_query.name = parse_name(@doc)
+        pocket_query.generated_at = parse_generated_at(@doc)
+
+        @doc.xpath("//gpx:gpx/gpx:wpt", ns).each do |wpt_node|
+          cache = nil
+
+          if cache_node = wpt_node.xpath("./cache:cache", ns).first
+            cache = GPXCacheParser.new(cache_node).parse
+          else
+            cache = Cache.new
+          end
+
+          %w(latitude longitude code).each do |attribute|
+            value = send("parse_#{attribute}", wpt_node)
+            cache.send("#{attribute}=", value) unless value.nil?
+          end
+
+          pocket_query.caches << cache
+        end
+
+        pocket_query
+      end
+
+    private
+
+      def parse_name(doc)
+        if node = doc.xpath("//gpx:name", ns).first
+          node.text
+        else
+          raise ParseError, "Could not parse Pocket Query name from XML"
+        end
+      end
+
+      def parse_generated_at(doc)
+        if node = doc.xpath("//gpx:time", ns).first
+          begin
+            Time.parse(node.text)
+          rescue ArgumentError
+            raise ParseError, "Invalid generation date in Pocket Query XML"
+          end
+        else
+          raise ParseError, "Could not parse Pocket Query generation date from XML"
+        end
+      end
+
+      def parse_code(wpt_node)
+        if node = wpt_node.xpath("./gpx:name", ns).first
+          node.text
+        else
+          raise ParseError, "Could not parse cache code from Pocket Query XML"
+        end
+      end
+
+      def parse_latitude(wpt_node)
+        if wpt_node["lat"]
+          wpt_node["lat"].to_f
+        else
+          raise ParseError, "Invalid latitude in GPX"
+        end
+      end
+
+      def parse_longitude(wpt_node)
+        if wpt_node["lon"]
+          wpt_node["lon"].to_f
+        else
+          raise ParseError, "Invalid longitude in GPX"
+        end
+      end
+
+      def ns
+        {
+          "gpx" => "http://www.topografix.com/GPX/1/0",
+          "cache" => "http://www.groundspeak.com/cache/1/0"
+        }
+      end
+    end
+  end
+end

data/lib/geocaching/parsers/{trackable.rb → trackable_parser.rb}

@@ -2,7 +2,7 @@
 
 module Geocaching
   module Parsers
-    class Trackable
+    class TrackableParser
       def initialize(doc)
         @doc = doc
       end

data/lib/geocaching/pocket_query.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require "geocaching/parsers/pocket_query_parser"
+require "geocaching/parsers/pocket_query_data_set_parser"
+
+module Geocaching
+  class PocketQuery
+    attr_accessor :guid
+    attr_accessor :name
+    attr_accessor :caches
+    attr_reader   :generated_at
+    attr_accessor :is_download_available
+    attr_accessor :filesize
+    attr_accessor :results_count
+
+    def self.from_file(file)
+      from_gpx(File.read(file))
+    end
+
+    def self.from_gpx(xml)
+      Parsers::PocketQueryParser.new(xml).parse
+    end
+
+    def self.from_xml(doc)
+      Parsers::PocketQueryDataSetParser.new(doc).parse
+    end
+
+    def initialize(attributes = {})
+      @caches = []
+
+      attributes.each do |key, value|
+        if respond_to?("#{key}=")
+          send("#{key}=", value)
+        else
+          raise ArgumentError, "Unknown attribute `#{key}'"
+        end
+      end
+    end
+
+    alias :download_available? :is_download_available
+
+    def generated_at=(time)
+      if time.kind_of?(Time)
+        @generated_at = time
+      else
+        raise TypeError, "`generated_at' must be an instance of Time"
+      end
+    end
+  end
+end

data/lib/geocaching/session/pocket_queries.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+require "base64"
+
+module Geocaching
+  class Session
+    module PocketQueries
+      def get_pocket_queries
+        response = request("GetPocketQueryList", {
+          "sessionToken"   => session_token
+        })
+
+        if response.status and response.status == "NoResults"
+          []
+        else
+          PocketQuery.from_xml(response.doc)
+        end
+      end
+
+      def download_pocket_query_by_guid(pocket_query_guid)
+        response = request("GetPocketQueryZippedFile", {
+          "sessionToken"    => session_token,
+          "PocketQueryGuid" => pocket_query_guid
+        })
+
+        if node = response.doc.xpath("//xmlns:PocketQueryZippedFileDataSet/xmlns:PocketQueryZippedFile/xmlns:FileData").first
+          Base64.decode64(node.text)
+        end
+      end
+    end
+  end
+end

data/lib/geocaching/session.rb

@@ -6,6 +6,7 @@ require "nokogiri"
 
 require "geocaching/session/caches"
 require "geocaching/session/logs"
+require "geocaching/session/pocket_queries"
 require "geocaching/session/trackables"
 
 module Geocaching
@@ -115,6 +116,7 @@ module Geocaching
 
     include Geocaching::Session::Caches
     include Geocaching::Session::Logs
+    include Geocaching::Session::PocketQueries
     include Geocaching::Session::Trackables
   end
 end

data/lib/geocaching/trackable.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-require "geocaching/parsers/trackable"
+require "geocaching/parsers/trackable_parser"
 
 module Geocaching
   class Trackable
@@ -15,7 +15,7 @@ module Geocaching
     attr_reader   :current_user
 
     def self.from_xml(doc)
-      Parsers::Trackable.new(doc).parse
+      Parsers::TrackableParser.new(doc).parse
     end
 
     def initialize(attributes = {})

data/lib/geocaching.rb

@@ -9,6 +9,7 @@ require "geocaching/container_type"
 require "geocaching/errors"
 require "geocaching/log"
 require "geocaching/log_type"
+require "geocaching/pocket_query"
 require "geocaching/session"
 require "geocaching/user"
 require "geocaching/trackable"
@@ -17,5 +18,5 @@ require "geocaching/waypoint"
 require "geocaching/waypoint_type"
 
 module Geocaching
-  VERSION = "0.7.1"
+  VERSION = "0.8.0"
 end

metadata

@@ -2,7 +2,7 @@
 name: geocaching
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors: 
 - Thomas Cyron
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-28 00:00:00 +02:00
+date: 2011-04-30 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -52,16 +52,21 @@ files:
 - lib/geocaching/errors.rb
 - lib/geocaching/log.rb
 - lib/geocaching/log_type.rb
-- lib/geocaching/parsers/cache_attribute.rb
-- lib/geocaching/parsers/cache_gpx.rb
-- lib/geocaching/parsers/cache_gpx_additional_waypoint.rb
-- lib/geocaching/parsers/cache_gpx_cache_waypoint.rb
-- lib/geocaching/parsers/cache_simple.rb
-- lib/geocaching/parsers/log.rb
-- lib/geocaching/parsers/trackable.rb
+- lib/geocaching/parsers/cache_attribute_parser.rb
+- lib/geocaching/parsers/cache_gpx_parser.rb
+- lib/geocaching/parsers/cache_simple_parser.rb
+- lib/geocaching/parsers/gpx_additional_waypoint_parser.rb
+- lib/geocaching/parsers/gpx_cache_parser.rb
+- lib/geocaching/parsers/gpx_cache_waypoint_parser.rb
+- lib/geocaching/parsers/log_parser.rb
+- lib/geocaching/parsers/pocket_query_data_set_parser.rb
+- lib/geocaching/parsers/pocket_query_parser.rb
+- lib/geocaching/parsers/trackable_parser.rb
+- lib/geocaching/pocket_query.rb
 - lib/geocaching/session/attributes.rb
 - lib/geocaching/session/caches.rb
 - lib/geocaching/session/logs.rb
+- lib/geocaching/session/pocket_queries.rb
 - lib/geocaching/session/trackables.rb
 - lib/geocaching/session.rb
 - lib/geocaching/trackable.rb

data/lib/geocaching/parsers/cache_gpx.rb

@@ -1,39 +0,0 @@
-# encoding: utf-8
-
-require "geocaching/parsers/cache_gpx_cache_waypoint"
-require "geocaching/parsers/cache_gpx_additional_waypoint"
-
-module Geocaching
-  module Parsers
-    class CacheGPX
-      def initialize(doc)
-        @doc = doc
-      end
-
-      def parse
-        cache = nil
-        is_first_wpt = true
-
-        @doc.xpath("//gpx:gpx/gpx:wpt", ns).each do |wpt_node|
-          if is_first_wpt
-            cache = CacheGPXCacheWaypoint.new(wpt_node).parse
-            is_first_wpt = false
-          else
-            cache.waypoints << CacheGPXAdditionalWaypoint.new(wpt_node).parse
-          end
-        end
-
-        cache
-      end
-
-    private
-
-      def ns
-        {
-          "gpx" => "http://www.topografix.com/GPX/1/1",
-          "cache" => "http://www.groundspeak.com/cache/1/0"
-        }
-      end
-    end
-  end
-end