ym4r 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2006 Guilhem Vellut <guilhem.vellut+ym4r@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 

data/README

@@ -0,0 +1,60 @@
+=YM4R
+The goal of YM4R is to ease the use of all the Yahoo! Maps API's (including the Geocoding, Map Image, Traffic and Local Search API's) from Ruby and Rails.
+
+===Operations
+At this time, only the Building Block API's (Geocoding, Map Image, Traffic and Local Search) are supported. You have to pass to the +get+ method of the module a hash whose keys are a rubyfied version of the request parameters. You get back a ruby object, with accessors that let you get the returned data in a easy way. You get an exception if not all the parameters have been passed, if the connection to the service could not be made or if the parameters you have passed are of the incorrect value.
+
+To know what parameters to pass to the +get+ methods and what results you should expect, you should consult the documentation for the building block API's on YahoooOooOoooOoo!'s website : http://developer.yahoo.com/maps/index.html#mapsBuildingBlocks . 
+
+Here are some examples and notes about using the different Building Block API's.
+====Geocoding
+Here is an example of request:
+	require 'ym4r'
+	include Ym4r::BuildingBlock
+	results = Geocoding::get(:street => "1 Infinite Loop",
+                             	  :city => "Cupertino",
+                                  :state => "CA",
+                                  :zip => "95014")
++results+ is an array of Geocoding::Result objects. The API can return up to 50 results for one request. Read the documentation page of the Geocoding::Result class to know how to access the data.
+
+====Map Image
+Here is an example of request:
+	require 'ym4r'
+	include Ym4r::BuildingBlock
+	result = MapImage::get(:street => "1 Infinite Loop",
+                               :city => "Cupertino",
+                               :state => "CA",
+                               :zip => "95014",
+                               :image_type => "png")
++result+ is a MapImage::Result object contains the URL for the requested image. You can download this image to a file by calling +download_to+ and passing a path.
+
+====Traffic
+Here is an example of request:
+	require 'ym4r'
+	include Ym4r::BuildingBlock
+	results = Traffic::get(:street => "1 Infinite Loop",
+                               :city => "Cupertino",
+                               :state => "CA",
+                               :zip => "95014",
+                               :include_map => true)
++results+ is a Traffic::ResultSet object (subclass of +Array+), containing Traffic::Result objects, each containing information about one traffic incident.
+
+====Local Search 
+Here is an example of request:
+	require 'ym4r'
+	include Ym4r::BuildingBlock
+	results = LocalSearch::get(:street => "1 Infinite Loop",
+                                   :city => "Cupertino",
+                                   :state => "CA",
+                                   :zip => "95014",
+                                   :query => "chinese")
++results+ is a LocalSearch::ResultSet object (subclass of +Array+), containing LocalSearch::Result objects, each containing information about one hit on the Yahoo! local search.
+
+===Disclaimer
+This software is not endorsed in any way by Yahoo!.
+
+===License
+YM4R is released under the MIT license.
+
+===Support
+Any questions, enhancement proposals, bug notifications or corrections can be sent to mailto:guilhem.vellut+ym4r@gmail.com.

data/lib/ym4r.rb

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

data/lib/ym4r/app_id.rb

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

data/lib/ym4r/building_block/geocoding.rb

@@ -0,0 +1,81 @@
+require 'ym4r/app_id'
+require 'ym4r/exception'
+require 'open-uri'
+require 'rexml/document'
+
+module Ym4r
+  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 Ym4r::MissingParameterException.new("Missing location data for the Yahoo! Maps Geocoding service")
+        end
+        
+        url = "http://api.local.yahoo.com/MapsService/V1/geocode?appid=#{Ym4r::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 Ym4r::BadRequestException.new(error.to_s)
+        rescue
+          raise Ym4r::ConnectionException.new("Unable to connect to Yahoo! Maps Geocoding service")
+        end
+        
+        doc = REXML::Document.new(xml) 
+        
+        if doc.root.name == "Error"
+          raise Ym4r::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 #Ym4r

data/lib/ym4r/building_block/local_search.rb

@@ -0,0 +1,156 @@
+require 'ym4r/app_id'
+require 'ym4r/exception'
+require 'open-uri'
+require 'rexml/document'
+
+module Ym4r
+  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 Ym4r::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 Ym4r::MissingParameterException.new("Missing query data for the Yahoo! Maps Local Search service")
+        end
+
+        url = "http://api.local.yahoo.com/LocalSearchService/V3/localSearch?appid=#{Ym4r::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 Ym4r::BadRequestException.new(error.to_s)
+        rescue 
+          raise Ym4r::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 Ym4r::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 #Ym4r

data/lib/ym4r/building_block/map_image.rb

@@ -0,0 +1,76 @@
+require 'ym4r/app_id'
+require 'ym4r/exception'
+require 'open-uri'
+require 'rexml/document'
+
+module Ym4r
+  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 Ym4r::MissingParameterException.new("Missing location data for the Yahoo! Maps Map Image service")
+        end
+        
+        url = "http://api.local.yahoo.com/MapsService/V1/mapImage?appid=#{Ym4r::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 Ym4r::BadRequestException.new(error.to_s)
+        rescue
+          raise Ym4r::ConnectionException.new("Unable to connect to Yahoo! Maps Map Image service")
+        end
+        
+        doc = REXML::Document.new(xml) 
+        
+        if doc.root.name == "Error"
+          raise Ym4r::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 #Ym4r

data/lib/ym4r/building_block/traffic.rb

@@ -0,0 +1,120 @@
+require 'ym4r/app_id'
+require 'ym4r/exception'
+require 'open-uri'
+require 'rexml/document'
+
+module Ym4r
+  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 Ym4r::MissingParameterException.new("Missing location data for the Yahoo! Maps Traffic service")
+        end
+
+        url = "http://api.local.yahoo.com/MapsService/V1/trafficData?appid=#{Ym4r::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 Ym4r::BadRequestException.new(error.to_s)
+        rescue
+          raise Ym4r::ConnectionException.new("Unable to connect to Yahoo! Maps Traffic REST service")
+        end
+        
+        doc = REXML::Document.new(xml) 
+        
+        if doc.root.name == "Error"
+          raise Ym4r::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 #Ym4r

data/lib/ym4r/exception.rb

@@ -0,0 +1,18 @@
+module Ym4r
+  #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

data/rakefile.rb

@@ -0,0 +1,49 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+task :default => :test
+
+desc "Run the tests"
+Rake::TestTask::new do |t|
+    t.test_files = FileList['test/test*.rb']
+    t.verbose = true
+end
+
+desc "Generate the documentation"
+Rake::RDocTask::new do |rdoc|
+  rdoc.rdoc_dir = 'ym4r-doc/'
+  rdoc.title    = "Yahoo Maps for Ruby Documentation"
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+spec = Gem::Specification::new do |s|
+  s.platform = Gem::Platform::RUBY
+
+  s.name = 'ym4r'
+  s.version = "0.0.1"
+  s.summary = "Using the Yahoo Maps API from Ruby"
+  s.description = <<EOF
+EOF
+  s.author = 'Guilhem Vellut'
+  s.email = 'guilhem.vellut+ym4r@gmail.com'
+  s.homepage = "http://thepochisuperstarmegashow.com"
+  
+  s.requirements << 'none'
+  s.require_path = 'lib'
+  s.files = FileList["lib/**/*.rb", "test/**/*.rb", "README","MIT-LICENSE","rakefile.rb"]
+  s.test_files = FileList['test/test*.rb']
+
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README"]
+  s.rdoc_options.concat ['--main',  'README']
+end
+
+desc "Package the library as a gem"
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end

data/test/test_geocoding.rb

@@ -0,0 +1,37 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'ym4r'
+require 'test/unit'
+
+include Ym4r::BuildingBlock
+
+class TestGeocoding< Test::Unit::TestCase
+
+  def test_apple
+    results1 = Geocoding::get(:street => "1 Infinite Loop",
+                             :city => "Cupertino",
+                             :state => "CA",
+                             :zip => "95014")
+    assert_equal(1,results1.length)
+    result1 = results1[0]
+    assert(result1.exact_match?)
+    assert_equal("address",result1.precision)
+
+    results2 = Geocoding::get(:location => "1 Infinite Loop Cupertino CA 95014")
+    assert_equal(1,results2.length)
+    result2 = results2[0]
+    assert(result2.exact_match?)
+    
+    assert_equal(result1.latitude,result2.latitude)
+    assert_equal(result1.longitude,result2.longitude)
+  end
+
+  def test_garbage_location
+    assert_raise(Ym4r::BadRequestException) {Geocoding::get(:location => "AZEAEAEAEAEAE")}
+  end
+
+  def test_no_location
+    assert_raise(Ym4r::MissingParameterException) {Geocoding::get(:hello => "world")}
+  end
+  
+end

data/test/test_local_search.rb

@@ -0,0 +1,62 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'ym4r'
+require 'test/unit'
+
+include Ym4r::BuildingBlock
+
+class TestLocalSearch< Test::Unit::TestCase
+
+  def test_apple
+    results = LocalSearch::get(:street => "1 Infinite Loop",
+                              :city => "Cupertino",
+                              :state => "CA",
+                              :zip => "95014",
+                              :query => "chinese")
+    
+    assert(! results.nil?)
+    
+    results.each do |result|
+      assert(!result.id.nil?)
+      assert(!result.title.nil?)
+      assert(!result.address.nil?)
+      assert(!result.city.nil?)
+      assert(!result.state.nil?)
+      assert(!result.phone.nil?)
+      assert(!result.latitude.nil?)
+      assert(!result.longitude.nil?)
+      assert(!result.rating.nil?)
+      assert(result.rating.is_a?(LocalSearch::Rating))
+      assert(!result.url.nil?)
+      assert(!result.click_url.nil?)
+      assert(!result.map_url.nil?)
+      assert(!result.business_url.nil?)
+      assert(!result.business_click_url.nil?)
+      assert(!result.categories.nil?)
+      assert(result.categories.is_a?(Array))
+
+    end
+  
+  end
+
+  def test_no_query
+    assert_raise(Ym4r::MissingParameterException) do
+      LocalSearch::get(:street => "1 Infinite Loop",
+                       :city => "Cupertino",
+                       :state => "CA",
+                       :zip => "95014")
+    end
+  end
+
+  def test_random_query
+    results = LocalSearch::get(:street => "1 Infinite Loop",
+                               :city => "Cupertino",
+                               :state => "CA",
+                               :zip => "95014",
+                               :query => "AZEAEAEZAEAEAE")
+    assert(!results.nil?)
+    
+    assert_equal(0,results.length)
+    
+  end
+end

data/test/test_map_image.rb

@@ -0,0 +1,37 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'ym4r'
+require 'test/unit'
+
+include Ym4r::BuildingBlock
+
+class TestMapImage< Test::Unit::TestCase
+
+  def test_apple
+    result = MapImage::get(:street => "1 Infinite Loop",
+                            :city => "Cupertino",
+                            :state => "CA",
+                            :zip => "95014",
+                            :image_type => "png")
+    assert(result.exact_match?)
+    apple_image = "apple.png"
+    result.download_to(apple_image)
+    assert(File.exist?(apple_image))
+    File.delete(apple_image)
+  end
+
+  def test_no_location
+    assert_raise(Ym4r::MissingParameterException) {MapImage::get(:image_type => "gif")}
+  end
+
+  def test_bad_parameter
+    assert_raise(Ym4r::BadRequestException) do
+      MapImage::get(:street => "1 Infinite Loop",
+                   :city => "Cupertino",
+                   :state => "CA",
+                   :zip => "95014",
+                   :image_type => "jpg") #jpg is not a valid image type
+    end
+  end
+  
+end

data/test/test_traffic.rb

@@ -0,0 +1,33 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'ym4r'
+require 'test/unit'
+
+include Ym4r::BuildingBlock
+
+class TestTraffic< Test::Unit::TestCase
+
+  def test_apple
+    results = Traffic::get(:street => "1 Infinite Loop",
+                          :city => "Cupertino",
+                          :state => "CA",
+                          :zip => "95014",
+                          :include_map => true)
+    
+    #since it changes according to time, difficult to test..
+    assert(! results.nil?)
+    assert(results.exact_match?)
+    
+    if(!results.empty?)
+      result = results[0]
+      apple_traffic_image = "apple_traffic.png"
+      result.download_to(apple_traffic_image)
+      assert(File.exist?(apple_traffic_image))
+      File.delete(apple_traffic_image)
+    end
+    
+
+  end
+
+  
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: ym4r
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2006-05-25 00:00:00 +05:00
+summary: Using the Yahoo Maps API from Ruby
+require_paths: 
+- lib
+email: guilhem.vellut+ym4r@gmail.com
+homepage: http://thepochisuperstarmegashow.com
+rubyforge_project: 
+description: ""
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Guilhem Vellut
+files: 
+- lib/ym4r.rb
+- lib/ym4r/app_id.rb
+- lib/ym4r/exception.rb
+- lib/ym4r/building_block/geocoding.rb
+- lib/ym4r/building_block/local_search.rb
+- lib/ym4r/building_block/map_image.rb
+- lib/ym4r/building_block/traffic.rb
+- test/test_geocoding.rb
+- test/test_local_search.rb
+- test/test_map_image.rb
+- test/test_traffic.rb
+- README
+- MIT-LICENSE
+- rakefile.rb
+test_files: 
+- test/test_geocoding.rb
+- test/test_local_search.rb
+- test/test_map_image.rb
+- test/test_traffic.rb
+rdoc_options: 
+- --main
+- README
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: []
+
+requirements: 
+- none
+dependencies: []
+