geocaching 0.6.1 → 0.7.0

data/lib/geocaching/cache_type.rb

@@ -1,94 +1,55 @@
 # encoding: utf-8
 
 module Geocaching
-  # The {CacheType} class represents a cache type.
-  #
-  # == Usage
-  #
-  #  if @cache.type == :traditional
-  #    puts "Cache is a Traditional Cache"
-  #  end
   class CacheType
-    # A mapping of cache types to their corresponding ID and name
-    # on geocaching.com.
-    TYPES = {
-      :traditional  => [2,    "Traditional Cache"],
-      :multi        => [3,    "Multi-cache"],
-      :mystery      => [8,    "Unknown Cache"],
-      :letterbox    => [5,    "Letterbox Hybrid"],
-      :wherigo      => [1858, "Wherigo Cache"],
-      :event        => [6,    "Event Cache"],
-      :megaevent    => [453,  "Mega-Event Cache"],
-      :cito         => [13,   "Cache In Trash Out Event"],
-      :earthcache   => [137,  "Earthcache"],
-      :lfevent      => [3653, "Lost and Found Event Cache"],
-      :locationless => [12,   "Locationless (Reverse) Cache"],
-      :webcam       => [11,   "Webcam Cache"],
-      :virtual      => [4,    "Virtual Cache"],
-      :ape          => [9,    "Project APE Cache"]
-    }
-
-    # Returns a {CacheType} object for the given cache type id, or
-    # nil if no appropriate cache id is found.
-    #
-    # @return [Geocaching::CacheType]
-    # @return [nil] If no appropriate cache type is found
-    def self.for_id(id)
-      if info = TYPES.to_a.select { |(k,v)| v[0] == id } and info.size == 1
-        new(info.first)
-      end
-    end
-
-    # Returns a {CacheType} object for the given cache type title, or
-    # nil if no appropriate cache type is found.
-    #
-    # @return [Geocaching::CacheType]
-    # @return [nil] If no appropriate cache type is found
-    def self.for_title(title)
-      if info = TYPES.to_a.select { |(k,v)| v[1] == title } and info.size == 1
-        new(info.first)
+    attr_reader :id
+
+    EARTHCACHE             =  1
+    EVENT                  =  2
+    GPS_ADVENTURES_EXHIBIT =  3
+    LETTERBOX              =  4
+    LOCATIONLESS           =  5
+    MULTI                  =  6
+    PROJECT_APE            =  7
+    TRADITIONAL            =  8
+    UNKNOWN                =  9
+    VIRTUAL                = 10
+    WEBCAM                 = 11
+    WHERIGO                = 12
+
+    MAPPING = [
+      [EARTHCACHE,             "Earthcache"                  ],
+      [EVENT,                  "Event Cache"                 ],
+      [GPS_ADVENTURES_EXHIBIT, "GPS Adventures Exhibit"      ],
+      [LETTERBOX,              "Letterbox Hybrid"            ],
+      [LOCATIONLESS,           "Locationless (Reverse) Cache"],
+      [MULTI,                  "Multi-cache"                 ],
+      [PROJECT_APE,            "Project APE Cache"           ],
+      [TRADITIONAL,            "Traditional Cache"           ],
+      [UNKNOWN,                "Unknown Cache"               ],
+      [VIRTUAL,                "Virtual Cache"               ],
+      [WEBCAM,                 "Webcam Cache"                ],
+      [WHERIGO,                "Wherigo Cache"               ]
+    ]
+
+    def self.from_name(name)
+      if type = MAPPING.find { |_, n| n == name }
+        new(type[0])
       end
     end
 
-    # Creates a new instance.  You should not need to create an instance
-    # of this class on your own.  Use {for_id} and {for_title}.
-    def initialize(info)
-      @info = info
+    def initialize(id)
+      @id = id
     end
 
-    # Returns the cache type’s ID.
-    #
-    # @return [Fixnum] Cache type ID
-    def id
-      @info[1][0]
-    end
-
-    # Returns the cache type’s name.
-    #
-    # @return [String] Cache type name
     def name
-      @info[1][1]
+      @name ||= MAPPING.find { |id, _| id == @id }[1]
     end
 
-    alias to_s name
-
-    # Returns the symbol that describes this cache type.  See the {TYPES}
-    # hash for a list of cache type symbols.
-    #
-    # @return [Symbol] Cache type symbol
-    def to_sym
-      @info[0]
-    end
+    alias :to_s :name
 
-    # Overloads the +==+ operator to compare by symbol.
-    #
-    #  if @cache.type == :multi
-    #    puts "It's a multi cache."
-    #  end
-    #
-    # @return [Boolean] Does object match with argument?
-    def ==(s)
-      to_sym == s
+    def ==(id)
+      @id == id
     end
   end
 end

data/lib/geocaching/container_type.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module Geocaching
+  class ContainerType
+    attr_reader :id
+
+    NOT_CHOSEN = 0
+    MICRO      = 1
+    SMALL      = 2
+    REGULAR    = 3
+    LARGE      = 4
+    VIRTUAL    = 5
+    OTHER      = 6
+
+    MAPPING = [
+      [NOT_CHOSEN, "Not chosen"],
+      [MICRO,      "Micro"     ],
+      [SMALL,      "Small"     ],
+      [REGULAR,    "Regular"   ],
+      [LARGE,      "Large"     ],
+      [VIRTUAL,    "Virtual"   ],
+      [OTHER,      "Other"     ]
+    ]
+
+    def self.from_name(name)
+      if type = MAPPING.find { |_, n| n == name }
+        new(type[0])
+      end
+    end
+
+    def initialize(id)
+      @id = id
+    end
+
+    def name
+      @name ||= MAPPING.find { |id, _| id == @id }[1]
+    end
+
+    alias :to_s :name
+
+    def ==(id)
+      @id = id
+    end
+  end
+end

data/lib/geocaching/errors.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+module Geocaching
+  class Error < Exception; end
+  class HTTPError < Error; end
+  class ParseError < Error; end
+end

data/lib/geocaching/log.rb

@@ -1,212 +1,81 @@
 # encoding: utf-8
 
+require "geocaching/parsers/log"
+
 module Geocaching
-  # The {Log} class represents a log on geocaching.com.
   class Log
-    # Creates a new instance and calls the {#fetch} method afterwards.
-    # +:guid+ must be specified as an attribute.
-    #
-    # @param [Hash] attributes Hash of attributes
-    # @return [Geocaching::Log]
-    # @raise [ArgumentError] Unknown attribute provided
-    # @raise [TypeError] Invalid attribute provided
-    def self.fetch(attributes)
-      log = new(attributes)
-      log.fetch
-      log
+    attr_accessor :guid
+    attr_accessor :message
+    attr_reader   :user
+    attr_reader   :logged_at
+    attr_reader   :created_at
+    attr_reader   :cache
+    attr_reader   :type
+
+    def self.from_xml(doc)
+      Parsers::Log.new(doc).parse
     end
 
-    # Creates a new instance.  The following attributes may be specified
-    # as parameters:
-    #
-    # * +:guid+ — The log’s Globally Unique Identifier
-    #
-    # @raise [ArgumentError] Trying to set an unknown attribute
     def initialize(attributes = {})
-      @data, @doc, @guid, @cache = nil, nil, nil, nil
-
       attributes.each do |key, value|
-        if [:guid, :title, :date, :cache, :user].include?(key)
-          if key == :cache and not value.kind_of?(Geocaching::Cache)
-            raise TypeError, "Attribute `cache' must be an instance of Geocaching::Cache"
-          end
-
-          if key == :date and not value.kind_of?(Time)
-            raise TypeError, "Attribute `type' must be an instance of Time"
-          end
-
-          if key == :user and not value.kind_of?(User)
-            raise TypeError, "Attribute `user' must be an instance of Geocaching::User"
-          end
-
-          instance_variable_set("@#{key}", value)
-        else
-          raise ArgumentError, "Trying to set unknown attribute `#{key}'"
-        end
-      end
-    end
-
-    # Fetches log information from geocaching.com.
-    #
-    # @return [void]
-    # @raise [ArgumentError] GUID is not given
-    def fetch
-      raise ArgumentError, "No GUID given" unless @guid
-      raise LoginError unless HTTP.loggedin?
-
-      resp, @data = HTTP.get("/seek/log.aspx?LUID=#{@guid}")
-      @doc = Nokogiri::HTML.parse(@data)
-    end
-
-    # Returns whether log information have successfully been fetched
-    # from geocaching.com.
-    #
-    # @return [Boolean] Have log information beed fetched?
-    def fetched?
-      @data and @doc
-    end
-
-    # Returns the log’s GUID.
-    #
-    # @return [String] GUID
-    def guid
-      @guid
-    end
-
-    # Returns the cache that belongs to this log.
-    #
-    # @return [Geocaching::Cache] Cache
-    def cache
-      @cache ||= begin
-        if guid = cache_guid
-          Cache.new(:guid => guid)
-        end
-      end
-    end
-
-    # Returns the log’s type.
-    #
-    # @return [Geocaching::LogType] Log type
-    def type
-      @type ||= LogType.for_title(title)
-    end
-
-    # Returns the the user that posted the log.
-    #
-    # @return [Geocaching::User] User
-    def user
-      @user ||= begin
-        raise NotFetchedError unless fetched?
-
-        elements = @doc.search("#ctl00_ContentBody_LogBookPanel1_lbLogText > a")
-
-        if elements.size > 0
-          User.new(:name => HTTP.unescape(elements.first.inner_html))
+        if respond_to?("#{key}=")
+          send("#{key}=", value)
         else
-          raise ParseError, "Could not extract username from website"
+          raise ArgumentError, "Unknown attribute `#{key}'"
         end
       end
     end
 
-    # Returns the date the log was written at.
-    #
-    # @return [Time] Log date
-    def date
-      @date ||= begin
-        raise NotFetchedError unless fetched?
-
-        elements = @doc.search("#ctl00_ContentBody_LogBookPanel1_LogDate")
-
-        if elements.size == 1
-          Time.parse(elements.first.content)
-        else
-          raise ParseError, "Could not extract date from website"
-        end
+    def logged_at=(time)
+      if time.kind_of?(Time)
+        @logged_at = time
+      else
+        raise TypeError, "`logged_at' must be an instance of Time"
       end
     end
 
-    # Returns the log’s raw message with all format codes.
-    #
-    # @return [String] Raw log message
-    def message
-      @message ||= begin
-        raise NotFetchedError unless fetched?
-
-        if meta[:description]
-          meta[:description].gsub(/\r\n/, "\n")
-        else
-          raise ParseError, "Could not extract message from website"
-        end
+    def created_at=(time)
+      if time.kind_of?(Time)
+        @created_at = time
+      else
+        raise TypeError, "`created_at' must be an instance of Time"
       end
     end
 
-    # Returns thehe short coord.info URL for the log.
-    #
-    # @return [String] coord.info URL
-    def short_url
-      @short_url ||= begin
-        raise NotFetchedError unless fetched?
-
-        meta[:url] || begin
-          raise ParseError, "Could not extract short URL from website"
-        end
+    def user=(user)
+      if user.kind_of?(Geocaching::User)
+        @user = user
+      else
+        raise TypeError, "`user' must be an instance of Geocaching::User"
       end
     end
 
-  private
-
-    # Returns the log’s title which is used internally to get the log type.
-    #
-    # @return [String] Log title
-    def title
-      @title ||= begin
-        raise NotFetchedError unless fetched?
-
-        imgs = @doc.search("#ctl00_ContentBody_LogBookPanel1_LogImage")
-
-        unless imgs.size == 1 and imgs.first["alt"]
-          raise ParseError, "Could not extract title from website"
-        end
-
-        imgs.first["alt"]
+    def cache=(cache)
+      if cache.kind_of?(Geocaching::Cache)
+        @cache = cache
+      else
+        raise TypeError, "`cache' must be an instance of Geocaching::Cache"
       end
     end
 
-    # Returns the UUID of the cache that belongs to this log.
-    #
-    # @return [String] Cache UUID
-    def cache_guid
-      if @cache.kind_of?(Geocaching::Cache) and @cache.guid
-        @cache.guid
+    def type=(log_type)
+      if log_type.kind_of?(Geocaching::LogType)
+        @type = log_type
       else
-        raise NotFetchedError unless fetched?
-
-        elements = @doc.search("#ctl00_ContentBody_LogBookPanel1_lbLogText > a")
-
-        if elements.size == 3 and elements[1]["href"]
-          elements[1]["href"] =~ /guid=([a-f0-9-]{36})/
-          $1
-        else
-          raise ParseError, "Could not extract cache GUID from website"
-        end
+        raise TypeError, "`type' must be an instance of Geocaching::LogType"
       end
     end
 
-    # Returns an array of information that are provided on the website
-    # in <meta> tags.
-    #
-    # @return [Hash] Log information
-    def meta
-      @meta ||= begin
-        elements = @doc.search("meta").select { |e| e["name"] =~ /^og:/ }.flatten
-        info = {}
-
-        elements.each do |element|
-          info[element["name"].gsub(/^og:/, "").to_sym] = element["content"]
-        end
-
-        info
-      end
+    def to_hash
+      {
+        :guid       => guid,
+        :type       => type,
+        :cache      => cache,
+        :user       => user,
+        :logged_at  => logged_at,
+        :created_at => created_at,
+        :message    => message
+      }
     end
   end
 end

data/lib/geocaching/log_type.rb

@@ -1,98 +1,68 @@
 # encoding: utf-8
 
 module Geocaching
-  # The {LogType} class represents a log type.
-  #
-  # == Usage
-  #
-  #  if @log.type == :archive
-  #    puts "#{@log.cache.code} has been archived"
-  #  end
   class LogType
-    # Mapping of log types to their corresponding icon and title
-    # on geocaching.com.
-    TYPES = {
-      :publish            => ["icon_greenlight",    "Publish Listing"],
-      :retract            => ["icon_redlight",      "Retract Listing"],
-      :dnf                => ["icon_sad",           "Didn't find it"],
-      :found              => ["icon_smile",         "Found it"],
-      :webcam_photo_taken => ["icon_camera",        "Webcam Photo Taken"],
-      :will_attend        => ["icon_rsvp",          "Will Attend"],
-      :announcement       => ["icon_announcement",  "Announcement"],
-      :attended           => ["icon_attended",      "Attended"],
-      :needs_maintenance  => ["icon_needsmaint",    "Needs Maintenance"],
-      :owner_maintenance  => ["icon_maint",         "Owner Maintenance"],
-      :disable            => ["icon_disabled",      "Temporarily Disable Listing"],
-      :enable             => ["icon_enabled",       "Enable Listing"],
-      :note               => ["icon_note",          "Write note"],
-      :needs_archived     => ["icon_remove",        "Needs Archived"],
-      :archive            => ["traffic_cone",       "Archive"],
-      :unarchive          => ["traffic_cone",       "Unarchive"],
-      :coords_update      => ["coord_update",       "Update Coordinates"],
-      :reviewer_note      => ["big_smile",          "Post Reviewer Note"]
-    }
+    attr_reader :id
 
-    # Returns a {LogType} object for the given log type icon, or nil if
-    # no appropriate log type is found.
-    #
-    # @return [Geocaching::LogType]
-    # @return [nil] If no appropriate log type is found
-    def self.for_icon(icon)
-      if info = TYPES.to_a.select { |(k,v)| v[0] == icon } and info.size == 1
-        new(info.first)
-      end
-    end
+    # Cache Log Types
+    FOUND                       = 0x001
+    DNF                         = 0x002
+    NOTE                        = 0x003
+    ARCHIVE                     = 0x004
+    UNARCHIVE                   = 0x005
+    NEEDS_ARCHIVED              = 0x006
+    ANNOUNCEMENT                = 0x007
+    WILL_ATTEND                 = 0x008
+    ATTENDED                    = 0x009
+    WEBCAM_PHOTO_TAKEN          = 0x00A
+    PUBLISH_LISTING             = 0x00B
+    RETRACT_LISTING             = 0x00C
+    TEMPORARILY_DISABLE_LISTING = 0x00D
+    ENABLE_LISTING              = 0x00E
+    UPDATE_COORDINATES          = 0x00F
+    POST_REVIEWER_NOTE          = 0x010
+    NEEDS_MAINTENANCE           = 0x011
+    OWNER_MAINTENANCE           = 0x012
 
-    # Returns a {LogType} object for the given log type title, or nil if
-    # no appropriate log type is found.
-    #
-    # @return [Geocaching::LogType]
-    # @return [nil] If no appropriate log type is found
-    def self.for_title(title)
-      if info = TYPES.to_a.select { |(k,v)| v[1] == title } and info.size == 1
-        new(info.first)
-      end
-    end
+    MAPPING = [
+      [FOUND,                       "Found it"                   ],
+      [DNF,                         "Didn't find it"             ],
+      [NOTE,                        "Write note"                 ],
+      [ARCHIVE,                     "Archive"                    ],
+      [UNARCHIVE,                   "Unarchive"                  ],
+      [NEEDS_ARCHIVED,              "Needs Archived"             ],
+      [ANNOUNCEMENT,                "Announcement"               ],
+      [WILL_ATTEND,                 "Will Attend"                ],
+      [ATTENDED,                    "Attended"                   ],
+      [WEBCAM_PHOTO_TAKEN,          "Webcam Photo Taken"         ],
+      [PUBLISH_LISTING,             "Publish Listing"            ],
+      [RETRACT_LISTING,             "Retract Listing"            ],
+      [TEMPORARILY_DISABLE_LISTING, "Temporarily Disable Listing"],
+      [ENABLE_LISTING,              "Enable Listing"             ],
+      [UPDATE_COORDINATES,          "Update Coordinates"         ],
+      [POST_REVIEWER_NOTE,          "Post Reviewer Note"         ],
+      [NEEDS_MAINTENANCE,           "Needs Maintenance"          ],
+      [OWNER_MAINTENANCE,           "Owner Maintenance"          ]
+    ]
 
-    # Creates a new instance.  You should not need to create an instance
-    # of this class on your own.  Use {for_icon} and {for_title}.
-    def initialize(info)
-      @info = info
+    def self.from_name(name)
+      if type = MAPPING.find { |_, n| n == name }
+        new(type[0])
+      end
     end
 
-    # Returns the log type’s icon.
-    #
-    # @return [String] Icon
-    def icon
-      @info[1][0]
+    def initialize(id)
+      @id = id
     end
 
-    # Returns the log type’s description.
-    #
-    # @return [String] Description
-    def description
-      @info[1][1]
+    def name
+      @name ||= MAPPING.find { |id, _| id == @id }[1]
     end
 
-    alias to_s description
-
-    # Returns the symbol representaton of the log type.  See the {TYPES}
-    # hash for a list of log type symbols.
-    #
-    # @return [Symbol] Log type symbol
-    def to_sym
-      @info[0]
-    end
+    alias :to_s :name
 
-    # Overloads the +==+ operator to compare by symbol.
-    #
-    #  if @log.type == :dnf
-    #    puts "Someone could not find the cache"
-    #  end
-    #
-    # @return [Boolean] Does object match with argument?
-    def ==(s)
-      to_sym == s
+    def ==(id)
+      @id == id
     end
   end
 end