geocaching 0.6.1 → 0.7.0

data/README.markdown

@@ -1,57 +1,11 @@
-Ruby API for geocaching.com
+Ruby API for Geocaching.com
 ===========================
 
-This Ruby library provides an API for geocaching.com.
+**ruby-geocaching** is a Ruby library providing an API for Geocaching.com.
+It doesn’t scrape their website but rather uses the same API the
+iPhone and Android geocaching apps use.
 
-
-Usage
------
-
-    require "geocaching"
-    
-    # Logging in is not always necessary, but some information are only
-    # accessible when logged in.
-    Geocaching::HTTP.login("username", "password")
-    
-    # Fetch the information for a cache by the cache’s GC code.  You can also
-    # provide the cache’s GUID instead of the GC code.
-    cache = Geocaching::Cache.fetch(:code => "...")
-    
-    # Print some cache information.
-    puts "      Name: #{cache.name}"
-    puts "Difficulty: #{cache.difficulty}"
-    puts "     Owner: #{cache.owner.username}"
-    
-    # Print the number of logs.
-    puts "      Logs: #{cache.logs.size}"
-    
-    # Print the number of users that didn’t find the cache.
-    dnfs = cache.logs.select { |log| log.type == :dnf }.size
-    puts "      DNFs: #{dnfs}"
-    
-    # Fetch the information for a log by its GUID.
-    log = Geocaching::Log.fetch(:guid => "...")
-    
-    # Print some log information.
-    puts "Username: #{log.user.name}"
-    puts "   Words: #{log.message.split.size}"
-    puts "   Cache: #{log.cache.name}"
-    
-    Geocaching::HTTP.logout
-
-The whole library may raise the following exceptions:
-
-* `Geocaching::TimeoutError` when a timeout is hit.
-* `Geocaching::LoginError` when calling a method that requires being
-  logged in and you’re not.
-* `Geocaching::NotFetchedError` when accessing a method that requires the
-  `fetch` method to be called first.
-* `Geocaching::ExtractError` when information could not be extracted
-  out of the website’s HTML code.  This mostly happens after Groundspeak
-  changed their website.
-* `Geocaching::HTTPError` when a HTTP request failed.
-
-All exceptions are subclasses of `Geocaching::Error`.
+See the [website](https://nano.github.com/ruby-geocaching) for more information.
 
 
 Tests
@@ -60,11 +14,11 @@ Tests
 Tests are written using [RSpec](http://relishapp.com/rspec).
 You need [Bundler](http://gembundler.com/) to run the tests.
 
-    $ bundle update
-    $ GC_USERNAME="username" GC_PASSWORD="password" bundle exec rake test
+    $ bundle
+    $ bundle exec rake test USERNAME=username PASSWORD=password
+
 
-Additional environment variables you may specify are:
+License
+-------
 
-* `GC_TIMEOUT` — HTTP timeout in seconds
-* `GC_CACHE_TYPES` — A space-separated list of cache types you want to test.
-* `GC_LOG_TYPES` — A space-separated list of log types you want to test.
+**ruby-geocaching** is released under the terms of the MIT license.

data/lib/geocaching.rb

@@ -1,91 +1,18 @@
 # encoding: utf-8
 
-require "nokogiri"
+require "geocaching/cache"
+require "geocaching/cache_type"
+require "geocaching/container_type"
+require "geocaching/errors"
+require "geocaching/log"
+require "geocaching/log_type"
+require "geocaching/session"
+require "geocaching/user"
+require "geocaching/trackable"
+require "geocaching/trackable_type"
+require "geocaching/waypoint"
+require "geocaching/waypoint_type"
 
-# This is a Ruby library to access information on geocaching.com.  As
-# Groundspeak does not provide a public API yet, one needs to parse the
-# website content.  That’s what this library does.
-#
-# The whole library may raise the following exceptions:
-#
-# * {Geocaching::LoginError}
-# * {Geocaching::NotFetchedError}
-# * {Geocaching::ParseError}
-# * {Geocaching::TimeoutError}
-# * {Geocaching::HTTPError}
-#
-# == Usage
-#
-# To have access to all information, you will need to provide the
-# credentials for an account on geocaching.com and log in:
-#
-#  Geocaching::HTTP.login("username", "password")
-#
-# Make sure to log out when you’re done:
-#
-#  Geocaching::HTTP.logout
-# 
-# You know have access to all information that are available for the
-# account you provided.
-#
-#  cache = Geocaching::Cache.fetch(:code => "GCTEST")
-#  p cache.difficulty #=> 3.5
-#  p cache.latitude #=> 49.17518
-#  p cache.pmonly? #=> false
-#  p cache.logs.size #=> 41
-#
-#  log = Geocaching::Log.new(:guid => "07208985-f7b2-456a-b0a8-bbc26f28b5a9")
-#  log.fetch
-#  p log.cache #=> #<Geocaching::Cache:...>
-#  p log.username #=> Foobar
-#
 module Geocaching
-  # All exceptions raised by this library are subclasses of this class.  It
-  # easily allows to rescue from all exceptions by catching Geocaching::Error.
-  class Error < Exception
-  end
-
-  # This exception is raised when a method that requires being
-  # logged in is called when not logged in.
-  class LoginError < Error
-  end
-
-  # This exception is raised when a timeout is hit.
-  class TimeoutError < Error
-  end
-
-  # This exception is raised if a request exceeds 500 results.
-  class TooManyResultsError < Error
-    def initialize
-      super "Your request exceeded 500 results"
-    end
-  end
-
-  # This exception is raised when a method is called that requires
-  # the #fetch method to be called first.
-  class NotFetchedError < Error
-    def initialize
-      super "Need to call the #fetch method first"
-    end
-  end
-
-  # This exception is raised when information could not be
-  # extracted out of the website’s HTML code.  For example,
-  # this may happen if Groundspeak changed their website.
-  class ParseError < Error
-  end
-
-  # This exception is raised when a HTTP request failed.
-  class HTTPError < Error
-  end
-
-  autoload :Cache,        "geocaching/cache"
-  autoload :CacheType,    "geocaching/cache_type"
-  autoload :HTTP,         "geocaching/http"
-  autoload :Log,          "geocaching/log"
-  autoload :LogType,      "geocaching/log_type"
-  autoload :MyLogs,       "geocaching/my_logs"
-  autoload :User,         "geocaching/user"
-  autoload :VERSION,      "geocaching/version"
-  autoload :Watchlist,    "geocaching/watchlist"
+  VERSION = "0.7.0"
 end

data/lib/geocaching/cache.rb

@@ -1,590 +1,112 @@
 # encoding: utf-8
 
-require "time"
-require "json"
+require "geocaching/parsers/cache_simple"
+require "geocaching/parsers/cache_gpx"
 
 module Geocaching
-  # The {LogsArray} class is a subclass of +Array+ and is used to store all
-  # logs that belong to a cache.  It implements the {#fetch_all} method to
-  # fetch the information of all logs inside the array.
-  class LogsArray < Array
-    # Calls {Geocaching::Log#fetch} for each log inside the array.
-    #
-    # @return [Boolean] Whether all logs could be fetched successfully
-    def fetch_all
-      each { |log| log.fetch }
-      map { |log| log.fetched? }.all?
-    end
-  end
-
-  # The {Cache} class represents a cache on geocaching.com.  Altough some
-  # information are available without being logged in, most information
-  # will only be accessible after a successful login.
-  #
-  # == Usage
-  #
-  #  cache = Geocaching::Cache.fetch(:code => "GCTEST")
-  #  
-  #  puts cache.difficulty #=> 3.5
-  #  puts cache.latitude #=> 49.741541
-  #  puts cache.archived? #=> false
-  #
   class Cache
-    # Creates a new instance and calls the {#fetch} methods afterwards.
-    # One of +:code+ or +:guid+ must be provided as attributes.
-    #
-    # @param [Hash] attributes A hash of attributes, see {#initialize}
-    # @return [Geocaching::Cache]
-    # @raise [ArgumentError] Tried to set an unknown attribute
-    # @raise [ArgumentError] Neither code nor GUID given
-    def self.fetch(attributes)
-      cache = new(attributes)
-      cache.fetch
-      cache
-    end
-
-    # Returns an array of caches that are located within the given bounds.
-    # If the number of results exceeds 500 caches, a
-    # {Geocaching::TooManyResultsError} exception is raised.
-    #
-    # @param [Array<Numeric>] northeast
-    #   An array containing latitude and longitude of the upper right bound
-    # @param [Array<Numeric>] southwest
-    #   An array containing latitude and longitude of the lower left bound
-    # @return [Array<Geocaching::Cache>]
-    #   Array of caches within given bounds
-    # @raise [ArgumentError]
-    #   Invalid arguments
-    # @raise [Geocaching::TooManyResultsError]
-    #   Number of results exceeds 500 caches
-    def self.within_bounds(northeast, southwest)
-      unless northeast.kind_of?(Array) and southwest.kind_of?(Array)
-        raise ArgumentError, "Arguments must be arrays"
-      end
-
-      unless northeast.size == 2 and southwest.size == 2
-        raise ArgumentError, "Arguments must have two elements"
-      end
-
-      unless northeast.map { |a| a.kind_of?(Numeric) }.all? \
-         and southwest.map { |a| a.kind_of?(Numeric) }.all?
-        raise ArgumentError, "Latitude and longitude must be given as numbers"
-      end
-
-      post_data = {
-        "dto" => {
-          "data" => {
-            "c" => 1,
-            "m" => "",
-            "d" => [northeast[0], southwest[0], northeast[1], southwest[1]].join("|")
-          },
-          "ut" => ""
-        }
-      }
-
-      headers = {
-        "Content-Type" => "application/json; charset=UTF-8"
-      }
-
-      resp, data = HTTP.post("/map/default.aspx/MapAction",
-        JSON.generate(post_data), headers)
-
-      begin
-        outer = JSON.parse(data)
-        raise ParseError, "Invalid JSON response" unless outer["d"]
-        results = JSON.parse(outer["d"])
-      rescue JSON::JSONError
-        raise ParseError, "Could not parse response JSON data"
-      end
-
-      raise ParseError, "Invalid JSON response" unless results["cs"]
-      raise TooManyResultsError if results["cs"]["count"] == 501
-
-      if results["cs"]["cc"].kind_of?(Array)
-        results["cs"]["cc"].map do |result|
-          Cache.new \
-            :name      => result["nn"],
-            :code      => result["gc"],
-            :latitude  => result["lat"],
-            :longitude => result["lon"],
-            :type      => CacheType.for_id(result["ctid"])
-        end
-      else
-        []
-      end
+    attr_accessor :code
+    attr_accessor :guid
+    attr_accessor :name
+    attr_accessor :latitude
+    attr_accessor :longitude
+    attr_accessor :difficulty
+    attr_accessor :terrain
+    attr_accessor :hidden_at
+    attr_accessor :placed_by
+    attr_reader   :owner
+    attr_reader   :type
+    attr_reader   :container_type
+    attr_accessor :country
+    attr_accessor :state
+    attr_accessor :is_available
+    attr_accessor :is_archived
+    attr_accessor :is_premium
+    attr_accessor :short_description
+    attr_accessor :long_description
+    attr_accessor :hint
+    attr_accessor :waypoints
+
+    def self.from_xml(doc)
+      Parsers::CacheSimple.new(doc).parse
+    end
+
+    def self.from_gpx(doc)
+      Parsers::CacheGPX.new(doc).parse
     end
 
-    # Creates a new instance.  The following attributes may be specified
-    # as parameters:
-    #
-    # * +:code+ — The cache’s GC code
-    # * +:guid+ — The cache’s Globally Unique Identifier
-    #
-    # @param [Hash] attributes A hash of attributes
-    # @raise [ArgumentError] Trying to set an unknown attribute
     def initialize(attributes = {})
-      @data, @doc, @code, @guid = nil, nil, nil, nil
+      @waypoints = []
 
       attributes.each do |key, value|
-        if [:code, :guid, :name, :type, :latitude, :longitude].include?(key)
-          if key == :type and not value.kind_of?(CacheType)
-            raise TypeError, "Attribute `type' must be an instance of Geocaching::CacheType"
-          end
-
-          instance_variable_set("@#{key}", value)
-        else
-          raise ArgumentError, "Trying to set unknown attribute `#{key}'"
-        end
-      end
-    end
-
-    # Fetches cache information from geocaching.com.
-    #
-    # @return [void]
-    # @raise [ArgumentError] Neither code nor GUID are given
-    def fetch
-      raise ArgumentError, "Neither code nor GUID given" unless @code or @guid
-
-      base_path = "/seek/cache_details.aspx?log=y&"
-      resp, @data = HTTP.get(base_path + (@code ? "wp=#{@code}" : "guid=#{@guid}"))
-      @doc = Nokogiri::HTML.parse(@data)
-    end
-
-    # Returns whether information have successfully been fetched
-    # from geocaching.com.
-    #
-    # @return [Boolean] Have cache information been fetched?
-    def fetched?
-      @data and @doc
-    end
-
-    # Returns the cache’s code.
-    #
-    # @return [String] Code
-    def code
-      @code ||= begin
-        raise NotFetchedError unless fetched?
-        elements = @doc.search("#ctl00_uxWaypointName.GCCode")
-
-        if elements.size == 1 and elements.first.content =~ /(GC[A-Z0-9]+)/
-          HTTP.unescape($1)
-        else
-          raise ParseError, "Could not extract code from website"
-        end
-      end
-    end
-
-    # Returns the cache’s Globally Unique Identifier (GUID).
-    #
-    # @return [String] GUID
-    def guid
-      @guid ||= begin
-        raise NotFetchedError unless fetched?
-
-        elements = @doc.search("#ctl00_ContentBody_lnkPrintFriendly")
-        guid = nil
-
-        if elements.size == 1 and href = elements.first["href"]
-          guid = $1 if href =~ /guid=([0-9a-f-]{36})/
-        end
-
-        guid || begin
-          raise ParseError, "Could not extract GUID from website"
-        end
-      end
-    end
-
-    # Returns the cache’s ID (which is not the UUID).
-    #
-    # @return [Fixnum] ID
-    def id
-      @id ||= begin
-        raise NotFetchedError unless fetched?
-
-        elements = @doc.search("div.CacheDetailNavigationWidget li a[href^='/seek/log.aspx']")
-
-        if elements.size > 0 and elements.first["href"] =~ /ID=(\d+)/
-          id = $1.to_i
-        end
-
-        id || begin
-          raise ParseError, "Could not extract ID from website"
-        end
-      end
-    end
-
-    # Returns the cache’s type ID.
-    #
-    # @return [Fixnum] Type ID
-    def type_id
-      @type_id ||= begin
-        raise NotFetchedError unless fetched?
-
-        if @data =~ /<a.*?title="About Cache Types"><img.*?WptTypes\/(\d+)\.gif".*?<\/a>/
-          $1.to_i
-        else
-          raise ParseError, "Could not extract cache type ID from website"
-        end
-      end
-    end
-
-    # Returns the cache’s type.
-    #
-    # @return [Geocaching::CacheType] Type
-    def type
-      @type ||= CacheType.for_id(type_id)
-    end
-
-    # Returns the cache’s name.
-    #
-    # @return [String] Name
-    def name
-      @name ||= begin
-        raise NotFetchedError unless fetched?
-        elements = @doc.search("span#ctl00_ContentBody_CacheName")
-
-        if elements.size == 1
-          HTTP.unescape(elements.first.content)
-        else
-          raise ParseError, "Could not extract name from website"
-        end
-      end
-    end
-
-    # Returns the cache’s owner.
-    #
-    # @return [Geocaching::User] Owner
-    def owner
-      @owner ||= begin
-        raise NotFetchedError unless fetched?
-        elements = @doc.search("span.minorCacheDetails a[href*='/profile/?guid=']")
-
-        if elements.size == 1 and elements.first["href"] =~ /guid=([a-f0-9-]{36})/
-          @owner_display_name = HTTP.unescape(elements.first.content)
-          User.new(:guid => $1)
+        if respond_to?("#{key}=")
+          send("#{key}=", value)
         else
-          raise ParseError, "Could not extract owner from website"
+          raise ArgumentError, "Unknown attribute `#{key}'"
         end
       end
     end
 
-    # Returns the displayed cache owner name.
-    #
-    # @return [String] Displayed owner name
-    def owner_display_name
-      owner unless @owner_display_name
-      @owner_display_name
-    end
-
-    # Returns the cache’s difficulty rating.
-    #
-    # @return [Float] Difficulty rating
-    def difficulty
-      @difficulty ||= begin
-        raise NotFetchedError unless fetched?
-        elements = @doc.search("#ctl00_ContentBody_uxLegendScale img")
-
-        if elements.size == 1 and elements.first["alt"] =~ /([\d\.]{1,3}) out of 5/
-          $1.to_f
-        else
-          raise ParseError, "Could not extract difficulty rating from website"
-        end
-      end
-    end
-
-    # Returns the cache’s terrain rating.
-    #
-    # @return [Float] Terrain rating
-    def terrain
-      @terrain ||= begin
-        raise NotFetchedError unless fetched?
-        elements = @doc.search("#ctl00_ContentBody_Localize6 img")
+    alias :available? :is_available
+    alias :archived? :is_archived
+    alias :premium? :is_premium
 
-        if elements.size == 1 and elements.first["alt"] =~ /([\d\.]{1,3}) out of 5/
-          $1.to_f
-        else
-          raise ParseError, "Could not extract terrain rating from website"
-        end
-      end
-    end
-
-    # Returns the date the cache has been hidden at.
-    #
-    # @return [Time] Hidden date
-    def hidden_at
-      @hidden_at ||= begin
-        raise NotFetchedError unless fetched?
-
-        if @data =~ /<span class="minorCacheDetails">Hidden\s*?:\s*?(\d{1,2})\/(\d{1,2})\/(\d{4})<\/span>/
-          Time.mktime($3, $1, $2)
-        else
-          raise ParseError, "Could not extract hidden date from website"
-        end
-      end
-    end
-
-    # Returns the date the event has been held.
-    #
-    # @return [Time] Event date
-    def event_date
-      @event_date ||= begin
-        raise NotFetchedError unless fetched?
-        return nil unless [:event, :megaevent, :cito, :lfevent].include?(type.to_sym)
-
-        if @data =~ /<span class="minorCacheDetails">\s*?Event Date:\s*?\w+, (\d+) (\w+) (\d{4})<\/span>/
-          Time.parse([$1, $2, $3].join)
-        else
-          raise ParseError, "Could not extract event date from website"
-        end
-      end
-    end
-
-    # Returns the cache’s container size.  One of the following symbols
-    # is returned:
-    #
-    # * +:micro+
-    # * +:small+
-    # * +:regular+
-    # * +:large+
-    # * +:other+
-    # * +:not_chosen+
-    # * +:virtual+
-    #
-    # @return [Symbol] Cache container size
-    def size
-      @size ||= begin
-        raise NotFetchedError unless fetched?
-        size = nil
-
-        if @data =~ /<img src="\/images\/icons\/container\/(.*?)\.gif" alt="Size: .*?" \/>/
-          size = $1.to_sym if %w(micro small regular large other not_chosen virtual).include?($1)
-        end
-
-        size || begin
-          raise ParseError, "Could not extract cache container size from website"
-        end
-      end
-    end
-
-    # Returns the cache’s latitude.
-    #
-    # @return [Float] Latitude
-    def latitude
-      @latitude ||= begin
-        raise NotFetchedError unless fetched?
-        return nil if type == :locationless
-
-        latitude = nil
-        elements = @doc.search("a#ctl00_ContentBody_lnkConversions")
-
-        if elements.size == 1 and href = elements.first["href"]
-          latitude = $1.to_f if href =~ /lat=(-?[0-9\.]+)/
-        end
-
-        latitude || begin
-          raise ParseError, "Could not extract latitude from website"
-        end
-      end
-    end
-
-    # Returns the cache’s longitude.
-    #
-    # @return [Float] Longitude
-    def longitude
-      @longitude ||= begin
-        raise NotFetchedError unless fetched?
-        return nil if type == :locationless
-
-        longitude = nil
-        elements = @doc.search("a#ctl00_ContentBody_lnkConversions")
-
-        if elements.size == 1 and href = elements.first["href"]
-          longitude = $1.to_f if href =~ /lon=(-?[0-9\.]+)/
-        end
-
-        longitude || begin
-          raise ParseError, "Could not extract longitude from website"
-        end
-      end
-    end
-
-    # Returns the cache’s location name (State, Country).
-    #
-    # @return [String] Location name
-    def location
-      @location ||= begin
-        raise NotFetchedError unless fetched?
-        return nil if type == :locationless
-
-        location = nil
-        elements = @doc.search("span#ctl00_ContentBody_Location")
-
-        if elements.size == 1
-          text = @doc.search("span#ctl00_ContentBody_Location").inner_html
-          location = $1.strip if text =~ /In ([^<]+)/
-        end
-
-        location || begin
-          raise ParseError, "Could not extract location from website"
-        end
-      end
-    end
-
-    # Returns whether the cache is unpublished or not.
-    #
-    # @return [Boolean] Is cache unpublished?
-    def unpublished?
-      @is_unpublished ||= begin
-        raise NotFetchedError unless fetched?
-        !!(@data =~ /<h2>Cache is Unpublished<\/h2>/)
-      end
-    end
-
-    # Returns whether the cache has been archived or not.
-    #
-    # @return [Boolean] Has cache been archived?
-    def archived?
-      @is_archived ||= begin
-        raise NotFetchedError unless fetched?
-        !!(@data =~ /<li>This cache has been archived/)
-      end
-    end
-
-    # Returns whether the cache is only viewable to Premium Member only.
-    #
-    # @return [Boolean] Is cache PM-only?
-    def pmonly?
-      @is_pmonly ||= begin
-        raise NotFetchedError unless fetched?
-
-        @doc.search("#ctl00_ContentBody_basicMemberMsg").size == 1 ||
-          !!(@data =~ /<p class="Warning">This is a Premium Member Only cache\.<\/p>/)
-      end
-    end
-
-    # Returns whether the cache is currently in review.
-    #
-    # @return [Boolean] Is cache currently in review?
-    def in_review?
-      @in_review ||= begin
-        raise NotFetchedError unless fetched?
-        [!!@data.match(/<p class="Warning">Sorry, you cannot view this cache listing until it has been published/),
-         !!@data.match(/<p class="Warning">This cache listing has not been reviewed yet/)].any?
+    def hidden_at=(time)
+      if time.kind_of?(Time)
+        @hidden_at = time
+      else
+        raise TypeError, "`hidden_at' must be an instance of Time"
       end
     end
 
-    # Returns an array of the cache’s logs.
-    #
-    # @return [Geocaching::LogsArray<Geocaching::Log>] Array of logs
-    def logs
-      @logs ||= begin
-        raise NotFetchedError unless fetched?
-
-        logs = LogsArray.new
-        tds = @doc.search("table.Table.LogsTable > tr > td")
-
-        if tds.size == 0
-          raise ParseError, "Could not extract logs from website"
-        end
-
-        tds.each do |td|
-          strongs = td.search("strong")
-          next unless strongs.size > 0
-
-          imgs    = strongs.first.search("img")
-          user_as = strongs.first.search("a[href^='/profile/']")
-          log_as  = td.search("small > a[href^='log.aspx']")
-
-          unless imgs.size == 1 and user_as.size == 1 and log_as.size == 1
-            raise ParseError, "Could not extract logs from website"
-          end
-
-          log_title = imgs.first["title"]
-          user_name = user_as.first.text.strip
-          user_guid = user_as.first["href"] =~ /guid=([a-f0-9-]{36})/ ? $1 : nil
-          log_guid  = log_as.first["href"] =~ /LUID=([a-f0-9-]{36})/ ? $1 : nil
-
-          # XXX Fix log title as Groundspeak is unable to escape their
-          # HTML code properly.
-          log_title = "Didn't find it" if log_title == "Didn"
-
-          unless log_title and user_name and user_guid and log_guid
-            raise ParseError, "Could not extract logs from website"
-          end
-
-          user = User.new(:guid => user_guid, :name => user_name)
-          log = Log.new \
-            :guid  => log_guid,
-            :title => log_title,
-            :cache => self,
-            :user  => user
-
-          logs << log
-        end
-
-        logs
+    def owner=(user)
+      if user.kind_of?(Geocaching::User)
+        @owner = user
+      else
+        raise TypeError, "`owner' must be an instance of Geocaching::User"
       end
     end
 
-    # Puts the cache on the user’s watchlist.  Obviously, you need to be logged
-    # in when calling this method.
-    #
-    # @return [void]
-    def watch
-      unless HTTP.loggedin?
-        raise LoginError
+    def type=(cache_type)
+      if cache_type.kind_of?(Geocaching::CacheType)
+        @type = cache_type
+      else
+        raise TypeError, "`type' must be an instance of Geocaching::CacheType"
       end
-
-      HTTP.get("/my/watchlist.aspx?w=#{id}")
     end
 
-    # Removes the cache from the user’s watchlist.  This method doesn’t check
-    # if the cache you want to remove from the watchlist actually is on your
-    # watchlist.
-    #
-    # @return [void]
-    def unwatch
-      unless HTTP.loggedin?
-        raise LoginError
+    def container_type=(container_type)
+      if container_type.kind_of?(Geocaching::ContainerType)
+        @container_type = container_type
+      else
+        raise TypeError, "`container_type' must be an instance of Geocaching::CacheType"
       end
-
-      HTTP.post("/my/watchlist.aspx?ds=1&id=#{id}&action=rem", {
-        "ctl00$ContentBody$btnYes" => "Yes"
-      })
     end
 
-    # Returns a hash representing this cache.
-    #
-    # @return [Hash] Hash representing this cache
     def to_hash
-      hash = {
-        :id         => id,
-        :code       => code,
-        :guid       => guid,
-        :name       => name,
-        :difficulty => difficulty,
-        :terrain    => terrain,
-        :latitude   => latitude,
-        :longitude  => longitude,
-        :size       => size,
-        :type       => type,
-        :location   => location,
-        :owner      => owner,
-        :owner_display_name => owner_display_name,
-        :logs       => logs,
-        :pmonly?    => pmonly?,
-        :archived?  => archived?,
-        :in_review? => in_review?,
-        :unpublished? => unpublished?
+      {
+        :code              => code,
+        :guid              => guid,
+        :name              => name,
+        :latitude          => latitude,
+        :longitude         => longitude,
+        :difficulty        => difficulty,
+        :terrain           => terrain,
+        :container_type    => container_type,
+        :type              => type,
+        :hidden_at         => hidden_at,
+        :placed_by         => placed_by,
+        :owner             => owner,
+        :country           => country,
+        :state             => state,
+        :is_available      => is_available,
+        :is_archived       => is_archived,
+        :is_premium        => is_premium,
+        :waypoints         => waypoints,
+        :short_description => short_description,
+        :long_description  => long_description,
+        :hint              => hint
       }
-
-      if [:event, :megaevent, :lfevent, :cito].include?(type.to_sym)
-        hash[:event_date] = event_date
-      else
-        hash[:hidden_at] = hidden_at
-      end
-
-      hash
     end
   end
 end