geocaching 0.6.1 → 0.7.0

data/lib/geocaching/parsers/cache_gpx.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require "nokogiri"
+require "time"
+
+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

data/lib/geocaching/parsers/cache_gpx_additional_waypoint.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+
+module Geocaching
+  module Parsers
+    class CacheGPXAdditionalWaypoint
+      COORDINATE_REGEXP = /^-?[0-9]{1,3}\.[0-9]{1,}$/
+
+      def initialize(wpt_node)
+        @wpt_node = wpt_node
+      end
+
+      def parse
+        waypoint = Waypoint.new
+
+        private_methods.each do |method|
+          if method.to_s =~ /^parse_([a-z_]+)$/
+            value = send(method, @wpt_node)
+            waypoint.send("#{$1}=", value) unless value.nil?
+          end
+        end
+
+        waypoint
+      end
+
+    private
+
+      def parse_code(wpt_node)
+        if node = wpt_node.xpath("./gpx:name", ns).first
+          node.text
+        else
+          raise ParseError, "Could not parse waypoint code from GPX"
+        end
+      end
+
+      def parse_latitude(wpt_node)
+        if wpt_node["lat"] =~ COORDINATE_REGEXP
+          wpt_node["lat"].to_f
+        else
+          raise ParseError, "Invalid waypoint 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 waypoint longitude in GPX"
+        end
+      end
+
+      def parse_created_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 waypoint creation date in GPX"
+          end
+        else
+          raise ParseError, "Could not parse waypoint creation date from GPX"
+        end
+      end
+
+      def parse_name(wpt_node)
+        if node = wpt_node.xpath("./gpx:desc", ns).first
+          node.text
+        else
+          raise ParseError, "Could not parse waypoint name from GPX"
+        end
+      end
+
+      def parse_note(wpt_node)
+        if node = wpt_node.xpath("./gpx:cmt", ns).first
+          node.text
+        else
+          raise ParseError, "Could not parse waypoint note from GPX"
+        end
+      end
+
+      def parse_type(wpt_node)
+        if node = wpt_node.xpath("./gpx:sym", ns).first
+          if waypoint_type = WaypointType.from_name(node.text)
+            waypoint_type
+          else
+            raise ParseError, "Unknown waypoint type in GPX"
+          end
+        else
+          raise ParseError, "Could not parse waypoint type 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/cache_gpx_cache_waypoint.rb

@@ -0,0 +1,234 @@
+# encoding: utf-8
+
+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
+      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
+          end
+        else
+          raise ParseError, "Could not parse GPX"
+        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"] =~ 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
+        else
+          raise ParseError, "Could not parse cache name from GPX"
+        end
+      end
+
+      def parse_type(cache_node)
+        if node = cache_node.xpath("./cache:type", ns).first
+          if cache_type = CacheType.from_name(node.text)
+            cache_type
+          else
+            raise ParseError, "Unknown cache type in GPX"
+          end
+        else
+          raise ParseError, "Could not parse cache type from GPX"
+        end
+      end
+
+      def parse_container_type(cache_node)
+        if node = cache_node.xpath("./cache:container", ns).first
+          if container_type = ContainerType.from_name(node.text)
+            container_type
+          else
+            raise ParseError, "Unknown container type in GPX"
+          end
+        else
+          raise ParseError, "Could not parse cache container type from GPX"
+        end
+      end
+
+      def parse_owner(cache_node)
+        if node = cache_node.xpath("./cache:owner", ns).first and node.text
+          User.new(:name => node.text)
+        else
+          raise ParseError, "Could not parse cache owner from GPX"
+        end
+      end
+
+      def parse_is_available(cache_node)
+        if cache_node["available"]
+          if %w(True False).include?(cache_node["available"])
+            cache_node["available"] == "True"
+          else
+            raise ParseError, "Invalid cache availability in GPX"
+          end
+        else
+          raise ParseError, "Could not parse cache availability from GPX"
+        end
+      end
+
+      def parse_is_archived(cache_node)
+        if cache_node["archived"]
+          if %w(True False).include?(cache_node["archived"])
+            cache_node["archived"] == "True"
+          else
+            raise ParseError, "Invalid cache archive status in GPX"
+          end
+        else
+          raise ParseError, "Could not parse cache archive status from GPX"
+        end
+      end
+
+      def parse_difficulty(cache_node)
+        if node = cache_node.xpath("./cache:difficulty", ns).first
+          difficulty = node.text.to_f
+
+          if difficulty > 0
+            difficulty
+          else
+            raise ParseError, "Invalid difficulty rating in GPX"
+          end
+        else
+          raise ParseError, "Could not parse difficulty rating from GPX"
+        end
+      end
+
+      def parse_terrain(cache_node)
+        if node = cache_node.xpath("./cache:terrain", ns).first
+          terrain = node.text.to_f
+
+          if terrain > 0
+            terrain
+          else
+            raise ParseError, "Invalid terrain terrain rating in GPX"
+          end
+        else
+          raise ParseError, "Could not parse terrain rating from GPX"
+        end
+      end
+
+      def parse_country(cache_node)
+        if node = cache_node.xpath("./cache:country", ns).first
+          node.text
+        else
+          raise ParseError, "Could not parse country from GPX"
+        end
+      end
+
+      def parse_state(cache_node)
+        if node = cache_node.xpath("./cache:state", ns).first
+          node.text unless node.text == "None"
+        else
+          raise ParseError, "Could not parse state from GPX"
+        end
+      end
+
+      def parse_placed_by(cache_node)
+        if node = cache_node.xpath("./cache:placed_by", ns).first
+          node.text
+        else
+          raise ParseError, "Could not parse placed by name from GPX"
+        end
+      end
+
+      def parse_short_description(cache_node)
+        if node = cache_node.xpath("./cache:short_description", ns).first
+          node.text
+        else
+          raise ParseError, "Could not parse short description from GPX"
+        end
+      end
+
+      def parse_long_description(cache_node)
+        if node = cache_node.xpath("./cache:long_description", ns).first
+          node.text
+        else
+          raise ParseError, "Could not parse long description from GPX"
+        end
+      end
+
+      def parse_hint(cache_node)
+        if node = cache_node.xpath("./cache:encoded_hints", ns).first
+          node.text
+        else
+          raise ParseError, "Could not parse hint 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/cache_simple.rb

@@ -0,0 +1,219 @@
+# encoding: utf-8
+
+require "nokogiri"
+require "time"
+
+module Geocaching
+  module Parsers
+    class CacheSimple
+      CACHE_CODE_REGEXP = /^GC[A-Z0-9]+$/
+      COORDINATE_REGEXP = /^-?[0-9]{1,3}\.[0-9]{1,}$/
+
+      def initialize(doc)
+        @doc = doc
+      end
+
+      def parse
+        caches = []
+
+        @doc.xpath("//xmlns:CacheSimpleDataSet/xmlns:Cache").each do |cache_node|
+          cache = Cache.new
+
+          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
+          end
+
+          caches << cache
+        end
+
+        caches
+      end
+
+    private
+
+      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
+        else
+          raise ParseError, "Could not parse cache code from XML"
+        end
+      end
+
+      def parse_name(cache_node)
+        if node = cache_node.xpath("./xmlns:Name").first
+          node.text
+        else
+          raise ParseError, "Could not parse cache name from XML"
+        end
+      end
+
+      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
+        else
+          raise ParseError, "Could not parse latitude from XML"
+        end
+      end
+
+      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
+        else
+          raise ParseError, "Could not parse longitude from XML"
+        end
+      end
+
+      def parse_difficulty(cache_node)
+        if node = cache_node.xpath("./xmlns:DifficultyRating").first
+          difficulty = node.text.to_f
+
+          if difficulty > 0
+            difficulty
+          else
+            raise ParseError, "Got a non-numeric value for cache difficulty rating from API"
+          end
+        else
+          raise ParseError, "Could not parse difficulty rating from XML"
+        end
+      end
+
+      def parse_terrain(cache_node)
+        if node = cache_node.xpath("./xmlns:TerrainRating").first
+          terrain = node.text.to_f
+
+          if terrain > 0
+            terrain
+          else
+            raise ParseError, "Got a non-numeric value for cache terrain rating from API"
+          end
+        else
+          raise ParseError, "Could not parse terrain rating from XML"
+        end
+      end
+
+      def parse_country(cache_node)
+        if node = cache_node.xpath("./xmlns:CountryName").first
+          node.text
+        else
+          raise ParseError, "Could not parse country from XML"
+        end
+      end
+
+      def parse_state(cache_node)
+        if node = cache_node.xpath("./xmlns:StateName").first
+          node.text unless node.text == "None"
+        else
+          raise ParseError, "Could not parse state from XML"
+        end
+      end
+
+      def parse_placed_by(cache_node)
+        if node = cache_node.xpath("./xmlns:ContactName").first
+          node.text
+        else
+          raise ParseError, "Could not parse placed by name from XML"
+        end
+      end
+
+      def parse_is_available(cache_node)
+        if node = cache_node.xpath("./xmlns:IsAvailable").first
+          if %w(true false).include?(node.text)
+            node.text == "true"
+          else
+            raise ParseError, "Got a non-bool value for cache availability from API"
+          end
+        else
+          raise ParseError, "Could not parse cache availability from XML"
+        end
+      end
+
+      def parse_is_archived(cache_node)
+        if node = cache_node.xpath("./xmlns:IsArchived").first
+          if %w(true false).include?(node.text)
+            node.text == "true"
+          else
+            raise ParseError, "Got a non-bool value for cache archived status from API"
+          end
+        else
+          raise ParseError, "Could not parse cache archived status from XML"
+        end
+      end
+
+      def parse_is_premium(cache_node)
+        if node = cache_node.xpath("./xmlns:IsPremiumListing").first
+          if %w(true false).include?(node.text)
+            node.text == "true" 
+          else
+            raise ParseError, "Got a non-bool value for cache premium status from API"
+          end
+        else
+          raise ParseError, "Could not parse cache premium status from XML"
+        end
+      end
+
+      def parse_hidden_at(cache_node)
+        if node = cache_node.xpath("./xmlns:Created").first
+          begin
+            time = Time.parse(node.text)
+            Time.mktime(time.year, time.month, time.day)
+          rescue ArgumentError
+            raise ParseError, "Got an invalid hidden date from API"
+          end
+        else
+          raise ParseError, "Could not parse hidden date from XML"
+        end
+      end
+
+      def parse_type(cache_node)
+        if node = cache_node.xpath("./xmlns:CacheTypeName").first
+          if cache_type = CacheType.from_name(node.text)
+            cache_type
+          else
+            raise ParseError, "Got an unknown cache type from API"
+          end
+        else
+          raise ParseError, "Could not parse cache type from XML"
+        end
+      end
+
+      def parse_container_type(cache_node)
+        if node = cache_node.xpath("./xmlns:ContainerName").first
+          if container_type = ContainerType.from_name(node.text)
+            container_type
+          else
+            raise ParseError, "Got an unknown container type from API"
+          end
+        else
+          raise ParseError, "Could not parse container type from XML"
+        end
+      end
+
+      def parse_owner(cache_node)
+        if user_guid_node = cache_node.xpath("./xmlns:UserGUID").first
+          if user_name_node = cache_node.xpath("./xmlns:UserName").first
+            User.new(:guid => user_guid_node.text, :name => user_name_node.text)
+          else
+            raise ParseError, "Could not parse owner name from XML"
+          end
+        else
+          raise ParseError, "Could not parse owner GUID from XML"
+        end
+      end
+    end
+  end
+end