ym4r 0.0.1 → 0.1.2

data/lib/ym4r/google_maps/point.rb

@@ -0,0 +1,34 @@
+require 'ym4r/google_maps/mapping'
+
+module Ym4r
+  module GoogleMaps
+    class GPoint < Struct.new(:x,:y)
+      include MappingObject
+      def create
+        "new GPoint(#{x},#{y})"
+      end
+    end
+    class GBounds
+      include MappingObject
+      attr_accessor :points
+      
+      def initialize(points)
+        if !points.empty? and points[0].is_a?(Array)
+          @points = points.collect { |pt| GPoint.new(pt[0],pt[1]) }
+        else
+          @points = points
+        end
+      end
+      def create
+        "new GBounds([#{@points.map { |pt| pt.to_javascript}.join(",")}])"
+      end
+    end
+    class GSize < Struct.new(:width,:height)
+      include MappingObject
+      def create
+        "new GSize(#{width},#{height})"
+      end
+
+    end
+  end
+end

data/lib/ym4r/yahoo_maps.rb

@@ -0,0 +1,2 @@
+require 'ym4r/yahoo_maps/building_block'
+require 'ym4r/yahoo_maps/flash'

data/lib/ym4r/yahoo_maps/app_id.rb

@@ -0,0 +1,5 @@
+module Ym4r
+  module YahooMaps
+    APP_ID = "YahooMaps4Ruby"
+  end
+end

data/lib/ym4r/yahoo_maps/building_block.rb

@@ -0,0 +1,4 @@
+require 'ym4r/yahoo_maps/building_block/geocoding'
+require 'ym4r/yahoo_maps/building_block/map_image'
+require 'ym4r/yahoo_maps/building_block/traffic'
+require 'ym4r/yahoo_maps/building_block/local_search'

data/lib/ym4r/yahoo_maps/building_block/exception.rb

@@ -0,0 +1,21 @@
+module Ym4r
+  module YahooMaps
+    module BuildingBlock
+      #Raised if the rate limit per 24 hours per IP is reached
+      class RateLimitExceededException < StandardError
+      end
+      
+      #Raised if the Yahoo Maps building bloc service is unreachable
+      class ConnectionException < StandardError
+      end
+      
+      #Raised if the service returns an HTTP error (due to bad arguments passed to the service)
+      class BadRequestException < StandardError
+      end
+      
+      #Raised if all the data needed is not passed to the get method of the service
+      class MissingParameterException < StandardError
+      end
+    end
+  end
+end

data/lib/ym4r/yahoo_maps/building_block/geocoding.rb

@@ -0,0 +1,81 @@
+require 'ym4r/yahoo_maps/app_id'
+require 'ym4r/yahoo_maps/building_block/exception'
+require 'open-uri'
+require 'rexml/document'
+
+module Ym4r
+  module YahooMaps
+    module BuildingBlock
+      module Geocoding
+        #Sends a request to the Yahoo! Maps geocoding service and returns the result in an easy to use Ruby object, hiding the creation of the query string and the XML parsing of the answer.
+        def self.get(param)
+          unless param.has_key?(:street) or
+              param.has_key?(:city) or
+              param.has_key?(:state) or
+              param.has_key?(:zip) or
+              param.has_key?(:location)
+            raise MissingParameterException.new("Missing location data for the Yahoo! Maps Geocoding service")
+          end
+          
+          url = "http://api.local.yahoo.com/MapsService/V1/geocode?appid=#{Ym4r::YahooMaps::APP_ID}&"
+          url << "street=#{param[:street]}&" if param.has_key?(:street)
+          url << "city=#{param[:city]}&" if param.has_key?(:city)
+          url << "state=#{param[:state]}&" if param.has_key?(:state)
+          url << "zip=#{param[:zip]}&" if param.has_key?(:zip)
+          url << "location=#{param[:location]}&" if param.has_key?(:location)
+          url << "output=xml"
+          
+          begin
+            xml = open(URI.encode(url)).read
+          rescue OpenURI::HTTPError => error
+            raise BadRequestException.new(error.to_s)
+          rescue
+            raise ConnectionException.new("Unable to connect to Yahoo! Maps Geocoding service")
+          end
+          
+          doc = REXML::Document.new(xml) 
+          
+          if doc.root.name == "Error"
+            raise RateLimitExceededException.new("Rate limit exceeded for Yahoo! Maps Geocoding service")
+          else
+            results = []
+            doc.elements.each("//Result") do |result|
+              data = result.elements
+              results << Geocoding::Result.new(result.attributes['precision'],
+                                               result.attributes['warning'],
+                                               data['Latitude'].text.to_f,
+                                               data['Longitude'].text.to_f,
+                                               data['Address'].text,
+                                               data['City'].text,
+                                               data['State'].text,
+                                               data['Zip'].text,
+                                               data['Country'].text)
+            end
+            results
+          end
+        end
+        
+        #Contains a result match from the Yahoo! Maps geocoding service. 
+        class Result < Struct.new(:precision,:warning,:latitude,:longitude,:address,:city,:state,:zip,:country)
+          
+          #Convenience method for the lazy.
+          def latlon
+            [latitude,longitude]
+          end
+        
+          #Convenience method for the lazy.
+          def lonlat
+            [longitude,latitude]
+          end
+        
+          #Indicates if the location passed in the request could be exactly identified.
+          def exact_match?
+            warning.nil?
+          end
+          
+        end
+        
+      end #Geocoding
+    end #BuildingBlock
+  end
+end #Ym4r

data/lib/ym4r/yahoo_maps/building_block/local_search.rb

@@ -0,0 +1,156 @@
+require 'ym4r/yahoo_maps/app_id'
+require 'ym4r/yahoo_maps/building_block/exception'
+require 'open-uri'
+require 'rexml/document'
+
+module Ym4r
+  module YahooMaps
+    module BuildingBlock
+      module LocalSearch
+        #Send a request to the local search REST API V3. 
+        def self.get(param)
+          
+          unless param.has_key?(:street) or
+              param.has_key?(:city) or
+              param.has_key?(:state) or
+              param.has_key?(:zip) or
+              param.has_key?(:location) or
+              (param.has_key?(:longitude) and param.has_key?(:latitude))
+            raise MissingParameterException.new("Missing location data for the Yahoo! Maps Local Search service")
+          end
+          
+          unless param.has_key?(:query) or
+              param.has_key?(:listing_id)
+            raise MissingParameterException.new("Missing query data for the Yahoo! Maps Local Search service")
+          end
+          
+          url = "http://api.local.yahoo.com/LocalSearchService/V3/localSearch?appid=#{Ym4r::YahooMaps::APP_ID}&"
+          url << "query=#{param[:query]}&" if param.has_key?(:query)
+          url << "listing_id=#{param[:query]}&" if param.has_key?(:listing_id)
+          url << "results=#{param[:results]}&" if param.has_key?(:results)
+          url << "start=#{param[:start]}&" if param.has_key?(:start)
+          url << "sort=#{param[:sort]}&" if param.has_key?(:sort)
+          url << "radius=#{param[:radius]}&" if param.has_key?(:radius)
+          url << "street=#{param[:street]}&" if param.has_key?(:street)
+          url << "city=#{param[:city]}&" if param.has_key?(:city)
+          url << "state=#{param[:state]}&" if param.has_key?(:state)
+          url << "zip=#{param[:zip]}&" if param.has_key?(:zip)
+          url << "location=#{param[:location]}&" if param.has_key?(:location)
+          url << "latitude=#{param[:latitude]}&" if param.has_key?(:latitude)
+          url << "longitude=#{param[:longitude]}&" if param.has_key?(:longitude)
+          url << "category=#{param[:category]}&" if param.has_key?(:category)
+          url << "omit_category=#{param[:omit_category]}&" if param.has_key?(:omit_category)
+          url << "minimum_rating=#{param[:minimum_rating]}&" if param.has_key?(:minimum_rating)
+          url << "output=json"
+          
+          begin
+            json = open(URI.encode(url)).read
+          rescue OpenURI::HTTPError => error
+            raise BadRequestException.new(error.to_s)
+          rescue 
+            raise ConnectionException.new("Unable to connect to Yahoo! Maps  REST service")
+          end
+          
+          #see http://rubyforge.org/snippet/detail.php?type=snippet&id=29. Safe?
+          json_obj = eval(json.gsub(/(["'])\s*:\s*(['"0-9tfn\[{])/){"#{$1}=>#{$2}"})
+          
+          if json_obj.has_key?("Error")
+            raise RateLimitExceededException.new("Rate limit exceeded for Yahoo! Maps Traffic REST service")
+          else
+            json_result_set = json_obj['ResultSet']
+            
+            result_set = LocalSearch::ResultSet.new(json_result_set['ResultSetMapUrl'],
+                                                    json_result_set['totalResultsAvailable'].to_i,
+                                                    json_result_set['totalResultsReturned'].to_i,
+                                                    json_result_set['firstResultPosition'].to_i)
+            
+            unless json_result_set['Result'].nil?
+              json_results = [json_result_set['Result']].flatten #uniform processing in case there is only one result
+              
+              json_results.each do |json_result|
+              
+                #get the rating
+                json_rating = json_result['Rating']
+                rating = LocalSearch::Rating.new(json_rating['AverageRating'].to_f, #when NaN, converted to 0 but can be tested (since TotalRating is 0 in this case) with is_rated? on the rating object
+                                                 json_rating['TotalRatings'].to_i,
+                                                 json_rating['TotalReviews'].to_i,
+                                                 Time.at(json_rating['LastReviewDate'].to_i),
+                                                 json_rating['LastReviewIntro'])
+                
+                #get the categories
+                categories = []
+                unless json_result['Categories']['Category'].nil? #no category present in the result
+                  json_categories = [json_result['Categories']['Category']].flatten #uniform processing in case there is only one category
+                  json_categories.each do |json_category|
+                    categories << LocalSearch::Category.new(json_category['id'].to_i,
+                                                            json_category['content'])
+                  end
+                end
+                
+                result_set << LocalSearch::Result.new(json_result['id'].to_i,
+                                                      json_result['Title'],
+                                                      json_result['Address'],
+                                                      json_result['City'],
+                                                      json_result['State'],
+                                                      json_result['Phone'],
+                                                      json_result['Latitude'].to_f,
+                                                      json_result['Longitude'].to_f,
+                                                      rating,
+                                                      json_result['Distance'].to_f,
+                                                      json_result['Url'],
+                                                      json_result['ClickUrl'],
+                                                      json_result['MapUrl'],
+                                                      json_result['BusinessUrl'],
+                                                      json_result['BusinessClickUrl'],
+                                                      categories)
+                
+              end 
+            end #unless json_result_set['Result'].nil?
+            
+            result_set
+            
+          end
+        end
+        
+        #Contains a list of results from the Yahoo! Maps Local Search REST service V3
+        class ResultSet < Array
+          attr_accessor :map_url, :total_results_available, :total_results_returned, :first_result_position
+          
+          def initialize(map_url,total_results_available, total_results_returned, first_result_position)
+            super(0)
+            @map_url = map_url
+            @total_results_available = total_results_available
+            @total_results_returned = total_results_returned
+            @first_result_position = first_result_position
+          end
+          
+        end
+        
+        #Contains a result from the Yahoo! Maps Local Search REST service V3. 
+        class Result < Struct.new(:id,:title,:address,:city,:state,:phone,:latitude,:longitude,:rating,:distance,:url,:click_url,:map_url,:business_url,:business_click_url,:categories)
+        
+          #convenience method for the lazy
+          def lonlat
+            [longitude,latitude]
+          end
+          
+          #convenience method for the lazy
+          def latlon
+            [latitude,longitude]
+          end
+          
+        end
+
+        class Category < Struct.new(:id,:name)
+        end
+        
+        class Rating < Struct.new(:average_rating,:total_ratings,:total_reviews,:last_review_date,:last_review_intro)
+          def is_rated?
+            total_ratings != 0
+          end
+        end
+        
+      end #LocalSearch
+    end #BuildingBlock
+  end
+end #Ym4r

data/lib/ym4r/yahoo_maps/building_block/map_image.rb

@@ -0,0 +1,75 @@
+require 'ym4r/yahoo_maps/app_id'
+require 'ym4r/yahoo_maps/building_block/exception'
+require 'open-uri'
+require 'rexml/document'
+
+module Ym4r
+  module YahooMaps
+    module BuildingBlock
+      module MapImage
+        #Send a request to the Map image API. Gets back a url to an image. This image can be downloaded later.
+        def self.get(param)
+          unless param.has_key?(:street) or
+              param.has_key?(:city) or
+              param.has_key?(:state) or
+              param.has_key?(:zip) or
+              param.has_key?(:location) or
+              (param.has_key?(:longitude) and param.has_key?(:latitude))
+            raise MissingParameterException.new("Missing location data for the Yahoo! Maps Map Image service")
+          end
+          
+          url = "http://api.local.yahoo.com/MapsService/V1/mapImage?appid=#{Ym4r::YahooMaps::APP_ID}&"
+          url << "street=#{param[:street]}&" if param.has_key?(:street)
+          url << "city=#{param[:city]}&" if param.has_key?(:city)
+          url << "state=#{param[:state]}&" if param.has_key?(:state)
+          url << "zip=#{param[:zip]}&" if param.has_key?(:zip)
+          url << "location=#{param[:location]}&" if param.has_key?(:location)
+          url << "latitude=#{param[:latitude]}&" if param.has_key?(:latitude)
+          url << "longitude=#{param[:longitude]}&" if param.has_key?(:longitude)
+          url << "image_type=#{param[:image_type]}&" if param.has_key?(:image_type) #defaults to PNG
+          url << "image_height=#{param[:image_height]}&" if param.has_key?(:image_height) #defaults to 500
+          url << "image_width=#{param[:image_width]}&" if param.has_key?(:image_width) #defaults to 620
+          url << "zoom=#{param[:zoom]}&" if param.has_key?(:zoom) #defaults to 6
+          url << "radius=#{param[:radius]}&" if param.has_key?(:radius)
+          url << "output=xml"
+          
+          begin
+            xml = open(URI.encode(url)).read
+          rescue OpenURI::HTTPError => error
+            raise BadRequestException.new(error.to_s)
+          rescue
+            raise ConnectionException.new("Unable to connect to Yahoo! Maps Map Image service")
+          end
+          
+          doc = REXML::Document.new(xml) 
+          
+          if doc.root.name == "Error"
+            raise RateLimitExceededException.new("Rate limit exceeded for Yahoo! Maps Map Image service")
+          else
+            result = doc.root
+            MapImage::Result.new(result.attributes['warning'],
+                                 result.text)
+          end
+        end
+        
+        #Contains a result match from the Yahoo! Maps Map Image service. 
+        class Result < Struct.new(:warning,:url)
+          
+          #Downloads the image to +file+.
+          def download_to(file)
+            data = open(url).read
+            open(file,"wb") do |f|
+              f.write data
+            end
+          end
+          
+          #Indicates if the location passed in the request could be exactly identified.
+          def exact_match?
+            warning.nil?
+          end
+          
+        end
+      end #MapImage
+    end #BuildingBlock
+  end
+end #Ym4r

data/lib/ym4r/yahoo_maps/building_block/traffic.rb

@@ -0,0 +1,120 @@
+require 'ym4r/yahoo_maps/app_id'
+require 'ym4r/yahoo_maps/building_block/exception'
+require 'open-uri'
+require 'rexml/document'
+
+module Ym4r
+  module YahooMaps
+    module BuildingBlock
+      module Traffic
+        #Send a request to the traffic REST API. 
+        def self.get(param)
+          unless param.has_key?(:street) or
+              param.has_key?(:city) or
+              param.has_key?(:state) or
+              param.has_key?(:zip) or
+              param.has_key?(:location) or
+              (param.has_key?(:longitude) and param.has_key?(:latitude))
+            raise MissingParameterException.new("Missing location data for the Yahoo! Maps Traffic service")
+          end
+          
+          url = "http://api.local.yahoo.com/MapsService/V1/trafficData?appid=#{Ym4r::YahooMaps::APP_ID}&"
+          url << "street=#{param[:street]}&" if param.has_key?(:street)
+          url << "city=#{param[:city]}&" if param.has_key?(:city)
+          url << "state=#{param[:state]}&" if param.has_key?(:state)
+          url << "zip=#{param[:zip]}&" if param.has_key?(:zip)
+          url << "location=#{param[:location]}&" if param.has_key?(:location)
+          url << "latitude=#{param[:latitude]}&" if param.has_key?(:latitude)
+          url << "longitude=#{param[:longitude]}&" if param.has_key?(:longitude)
+          url << "image_type=#{param[:image_type]}&" if param.has_key?(:image_type) #defaults to PNG
+          url << "image_height=#{param[:image_height]}&" if param.has_key?(:image_height) #defaults to 500
+          url << "image_width=#{param[:image_width]}&" if param.has_key?(:image_width) #defaults to 620
+          url << "zoom=#{param[:zoom]}&" if param.has_key?(:zoom) #defaults to 6
+          url << "radius=#{param[:radius]}&" if param.has_key?(:radius)
+          url << "include_map=#{param[:include_map]?1:0}&" if param.has_key?(:include_map)
+          url << "severity=#{param[:severity]}&" if param.has_key?(:severity)
+          url << "output=xml"
+          
+          begin
+            xml = open(URI.encode(url)).read
+          rescue OpenURI::HTTPError => error
+            raise BadRequestException.new(error.to_s)
+          rescue
+            raise ConnectionException.new("Unable to connect to Yahoo! Maps Traffic REST service")
+          end
+          
+          doc = REXML::Document.new(xml) 
+          
+          if doc.root.name == "Error"
+            raise RateLimitExceededException.new("Rate limit exceeded for Yahoo! Maps Traffic REST service")
+          else
+            results = Traffic::ResultSet.new(Time.at(doc.root.elements['LastUpdateDate'].text.to_i),doc.root.elements['Warning'].nil? ? nil : doc.root.elements['Warning'].text)
+            
+            doc.root.elements.each('//Result') do |result|
+              data = result.elements
+              results << Traffic::Result.new(result.attributes['type'],
+                                             data['Title'].text,
+                                             data['Description'].text,
+                                             data['Latitude'].text.to_f,
+                                             data['Longitude'].text.to_f,
+                                             data['Direction'].text,
+                                             data['Severity'].text.to_i,
+                                             Time.at(data['ReportDate'].text.to_i),
+                                             Time.at(data['UpdateDate'].text.to_i),
+                                             Time.at(data['EndDate'].text.to_i),
+                                             data['ImageUrl'].nil? ? nil : data['ImageUrl'].text)
+            end
+            results
+            
+          end
+        end
+        
+        #Contains a list of results from the Yahoo! Maps Traffic REST API
+        class ResultSet < Array
+          attr_accessor :last_update_date,:warning
+          
+          def initialize(last_update_date,warning)
+            super(0)
+            @last_update_date = last_update_date
+            @warning = warning
+          end
+          
+          #Indicates if the location passed in the request could be exactly identified.
+          def exact_match?
+            warning.nil?
+          end
+        end
+        
+        #Contains a result from the Yahoo! Maps Traffic REST service. 
+        class Result < Struct.new(:type,:title,:description,:latitude,:longitude,:direction,:severity,:report_date,:update_date,:end_date,:image_url)
+          
+          #Downloads the image (if there is one) to +file+.
+          def download_to(file)
+            if has_image?
+              data = open(image_url).read
+              open(file,"wb") do |f|
+                f.write data
+              end
+            end
+          end
+          
+          def has_image?
+            ! image_url.nil?
+          end
+          
+          #Convenience method for the lazy.
+          def lonlat
+            [longitude,latitude]
+          end
+          
+          #Convenience method for the lazy.
+          def latlon
+            [latitude,longitude]
+          end
+          
+        end
+        
+      end #Traffic
+    end #BuildingBlock
+  end
+end #Ym4r