yelpster 1.1.1

data/lib/yelpster/v1/review/request/location.rb

@@ -0,0 +1,65 @@
+require 'yelpster/v1/review/request/base'
+
+class Yelp
+  module V1
+	  module Review
+  		module Request
+  		  # Describes a request to search for business reviews near a specific
+  		  # address/location.  You do not need to specify all of the address
+  		  # attributes -- some subset of the core +address+, +city+,
+  		  # +neighborhood+, +state+ and +zipcode+ will suffice.
+  		  #
+  		  class Location < Yelp::V1::Review::Request::Base
+    			# the street address of the location sought
+    			attr_reader :address
+
+    			# the city of the location sought
+    			attr_reader :city
+
+    			# the neighborhood of the location sought
+    			attr_reader :neighborhood
+			
+    			# radius to use while searching around specified geo-point.
+    			# default value is 1, maximum value is 25.
+    			attr_reader :radius
+
+    			# the state of the location sought
+    			attr_reader :state
+
+    			# the zipcode of the location sought
+    			attr_reader :zipcode
+
+    			def initialize (params)
+    			  # we explicitly initialize the location fields since we reference
+    			  # them later when building a full location string and we want
+    			  # to know they were initialized properly (and avoid warnings)
+    			  super({
+    				:address => nil,
+    				:city => nil,
+    				:neighborhood => nil,
+    				:state => nil,
+    				:zipcode => nil
+    				}.merge(params))
+    			end
+
+    			def to_yelp_params
+    			  super.merge(:location => build_location_string,
+    						  :radius => radius)
+    			end
+			
+    			protected
+			
+    			  # Returns the Yelp-compatible concatenated string with the various
+    			  # possible bits of an address-oriented location.
+    			  #
+    			  def build_location_string
+    				# per the Yelp documentation, the location string is to be built
+    				# as some combination of "address, neighborhood, city, state, or
+    				# zip".
+    				[ @address, @neighborhood, @city, @state, @zipcode ].compact.join(" ")
+    			  end
+    		end
+      end
+    end
+  end
+end

data/lib/yelpster/v2/business/request/id.rb

@@ -0,0 +1,19 @@
+require 'yelpster/v2/request'
+
+class Yelp
+	module V2
+		module Business
+			module Request
+				class Id < Yelp::V2::Request
+          # the alphanumeric id of the business to search for as provided by yelp, 
+          # eg: 'pjb2WMwa0AfK3L-dWimO8w'
+  				attr_reader :yelp_business_id
+				
+  				def base_url
+  				  'http://api.yelp.com/v2/business/'+yelp_business_id
+  				end
+				end
+			end
+		end
+	end
+end

data/lib/yelpster/v2/request.rb

@@ -0,0 +1,56 @@
+require 'yelpster/record'
+require 'oauth'
+
+class Yelp
+  module V2
+	  class Request < Yelp::Record
+		# specifies whether the response content should be transmitted
+		# over the wire compressed, defaulting to true.
+		attr_reader :compress_response
+
+		# one of the Yelp::ResponseFormat format specifiers detailing the
+		# desired format of the search results, defaulting to
+		# Yelp::ResponseFormat::JSON_TO_RUBY.
+		attr_reader :response_format
+
+		# the Yelp consumer_key, consumer_secret, token, token_secret to be passed with the request for
+		# authentication purposes. See http://www.yelp.com/developers/getting_started/api_access
+		# to get your own.
+		attr_reader :consumer_key
+		attr_reader :consumer_secret
+		attr_reader :token
+		attr_reader :token_secret
+
+		alias :compress_response? :compress_response
+
+		def initialize (params)
+		  default_params = {
+			:compress_response => true,
+			:response_format => Yelp::ResponseFormat::JSON_TO_RUBY
+			}
+		  super(default_params.merge(params))
+		end
+
+		def to_yelp_params
+		  params = {}
+		  
+		  # if they specified anything other than a json variant, we
+		  # need to tell yelp what we're looking for
+		  case @response_format
+		  when Yelp::ResponseFormat::PICKLE 
+			params[:output] = 'pickle'
+		  when Yelp::ResponseFormat::PHP 
+			params[:output] = 'php'
+		  end
+
+		  params
+		end
+		
+		def pull_results (url, http_params)
+		  consumer = OAuth::Consumer.new(consumer_key, consumer_secret, {:site => "http://api.yelp.com"})
+		  access_token = OAuth::AccessToken.new(consumer, token, token_secret)
+		  access_token.get(url).body
+		end
+	  end
+   end
+end

data/lib/yelpster/v2/search/request/base.rb

@@ -0,0 +1,68 @@
+require 'yelpster/v2/request'
+
+class Yelp
+  module V2
+	  module Search
+  		module Request
+  		  class Base < Yelp::V2::Request
+    			#------------------------General Search Params -----------------
+    			# string representing the name of business or search term being
+          #requested.
+    			attr_reader :term
+
+          # integer representing number of business results to return
+    			attr_reader :limit
+			
+    			# integer representing number of results to skip (for pagination)
+    			attr_reader :offset
+			
+    			# integer for specifying how to sort results
+    			# Sort Mode:  
+    			#     0 = Best matched (default)
+    			#     1 = Distance
+    			#     2 = Highest rated
+    			# see www.yelp.com/developers/documentation/v2/search_api for more info
+    			attr_reader :sort
+			
+    			# string specifying which business category to search in
+    			# see www.yelp.com/developers/documentation/category_list for list of 
+    			# categories
+    			attr_reader :category_filter
+			
+    			# integer specifying the search radius in meters
+     			attr_reader :radius_filter
+			
+    			# boolean representing if business has claimed location
+    			# not implemented by yelp as of 13-8-2011
+    			attr_reader :claimed_filter
+    			#---------------------------------------------------------------
+
+    			#--------------------------- Locale Params ---------------------
+    			# string representing default country to use while parsing location field
+    			attr_reader :cc
+			
+    			# string representing which language of reviews to return 
+    			attr_reader :lang
+    			#---------------------------------------------------------------
+			
+    			def base_url
+    			  'http://api.yelp.com/v2/search'
+    			end
+
+    			def to_yelp_params
+    				super.merge(:term 	=> term,
+    							:limit 	=> limit,
+    							:offset => offset,
+    							:sort 	=> sort,
+    							:category_filter => category_filter,
+    							:radius_filter 	=> radius_filter,
+    							:claimed_filter => claimed_filter,
+
+    							:cc 	=> cc,
+    							:lang 	=> lang)
+    			end
+    		end
+      end
+    end
+  end
+end

data/lib/yelpster/v2/search/request/bounding_box.rb

@@ -0,0 +1,30 @@
+require 'yelpster/v2/search/request/base'
+
+class Yelp
+  module V2
+	  module Search
+  		module Request
+  		  # Describes a request to search for businesses
+  		  # within a geo-point-specific bounding box 
+  		  #
+  		  class BoundingBox < Yelp::V2::Search::Request::Base
+    			# REQUIRED - double, bottom right latitude of bounding box (SOUTH-WEST LAT)
+    			attr_reader :sw_latitude
+		
+    			# REQUIRED - double, bottom right longitude of bounding box (SOUTH-WEST LONG)
+    			attr_reader :sw_longitude
+			
+    			# REQUIRED - double, top left latitude of bounding box (NORTH-EAST LAT)
+    			attr_reader :ne_latitude
+			
+    			# REQUIRED - double, top left longitude of bounding box (NORTH-EAST LONG)
+    			attr_reader :ne_longitude
+
+    			def to_yelp_params
+    			  super.merge(:bounds => "#{sw_latitude},#{sw_longitude}|#{ne_latitude},#{ne_longitude}")
+    			end
+    		end
+      end
+    end
+  end
+end

data/lib/yelpster/v2/search/request/geo_point.rb

@@ -0,0 +1,54 @@
+require 'yelpster/v2/search/request/base'
+
+class Yelp
+  module V2
+	  module Search
+  		module Request
+  		  # Describes a request to search for the name of a neighborhood at a
+  		  # specific geo-point location.
+  		  #
+  		  class GeoPoint < Yelp::V2::Search::Request::Base
+    			# REQUIRED - double, latitude of geo-point to search
+    			attr_reader :latitude
+
+    			# REQUIRED - double, longitude of geo-point to search
+    			attr_reader :longitude
+			
+    			# OPTIONAL - double, accuracy of latitude and longitude of geo-point to search
+    			attr_reader :accuracy
+			
+    			# OPTIONAL - double, altitude of geo-point to search
+    			attr_reader :altitude
+			
+    			# OPTIONAL - double, accuracy of altitude geo-point to search
+    			attr_reader :altitude_accuracy
+
+    			def initialize(params)
+    				# we explicitly initialize the location fields since we reference
+    				# them later when building a full location string and we want
+    				# to know they were initialized properly (and avoid warnings)
+    				# 50 and -100 default values are provided as they lie within yelp API's geo-location range
+    				super({
+    				:latitude	=> 50.0,
+    				:longitude	=> -100.0,
+    				:accuracy	=> nil,
+    				:altitude	=> nil,
+    				:altitude_accuracy => nil
+    				}.merge(params))
+    			end
+			
+    			def to_yelp_params
+    			  super.merge(:ll => build_geo_loc_string)
+    			end
+			
+    			# Returns the Yelp-compatible concatenated string with the various
+    			# possible bits of an address-oriented location.
+    			#
+    			def build_geo_loc_string
+    				[ @latitude, @longitude, @accuracy, @altitude, @altitude_accuracy ].compact.join(",")
+    			end
+    		end
+      end
+    end
+  end
+end

data/lib/yelpster/v2/search/request/location.rb

@@ -0,0 +1,76 @@
+require 'yelpster/v2/search/request/base'
+
+class Yelp
+  module V2
+	  module Search
+    		module Request
+    		  # Describes a request to search for a businesses by a 
+    		  # address/location.  You do not need to specify all of the address
+    		  # attributes -- some subset of the core 
+    		  # 			address, neighborhood, city, state or zip, optional country
+    		  #
+    		  class Location < Yelp::V2::Search::Request::Base
+    		    # NOTE: At least one of address, neighborhood, city, state, 
+    		    # zipcode or country must be specified
+
+      			# string representing the street address of the location sought
+      			attr_reader :address
+			
+      			# string representing the neighborhood of the location sought
+      			attr_reader :neighborhood
+
+      			# string representing the city of the location sought
+      			attr_reader :city
+
+      			# string representing the state of the location sought
+      			attr_reader :state
+
+      			# string representing the zipcode of the location sought
+      			attr_reader :zipcode
+			
+      			# string representing the country of the location sought
+      			attr_reader :country
+			
+      			# additional attributes that can be specified = latitude + longitude
+      			attr_reader :latitude
+      			attr_reader :longitude
+
+      			def initialize (params)
+      			  # we explicitly initialize the location fields since we reference
+      			  # them later when building a full location string and we want
+      			  # to know they were initialized properly (and avoid warnings)
+      			  super({ :address 		  => nil,
+        				      :neighborhood => nil,
+        				      :city 			  => nil,
+        				      :state 			  => nil,
+        				      :zipcode 		  => nil,
+        				      :country 		  => nil,
+        				      :latitude 	  => nil,
+        				      :longitude 	  => nil
+        			}.merge(params))
+      			end
+
+      			def to_yelp_params
+      			  super.merge(:location => build_location_string,
+      						        :cll		  => build_geo_location_string)
+      			end
+			
+      		protected
+
+      			# Returns the Yelp-compatible concatenated string with the various
+      			# possible bits of an address-oriented location.
+      			#
+      			def build_location_string
+      				# per the Yelp documentation, the location string is to be built
+      				# as some combination of "address, neighborhood, city, state, or zip, country".
+      				[ @address, @neighborhood, @city, @state, @zipcode, @country ].compact.join(" ")
+      			end
+			
+      			def build_geo_location_string
+      				[ @latitude, @longitude ].collect{|var| var || 0}.join(",")
+      			end
+    		end
+      end
+    end
+  end
+end

data/lib/yelpster.rb

@@ -0,0 +1,24 @@
+require 'yelpster/client'
+require 'yelpster/record'
+require 'yelpster/response_format'
+#-----------------V1---------------------------
+require 'yelpster/v1/request'
+require 'yelpster/v1/neighborhood/request/base'
+require 'yelpster/v1/neighborhood/request/geo_point'
+require 'yelpster/v1/neighborhood/request/location'
+require 'yelpster/v1/phone/request/number'
+require 'yelpster/v1/review/request/base'
+require 'yelpster/v1/review/request/bounding_box'
+require 'yelpster/v1/review/request/geo_point'
+require 'yelpster/v1/review/request/location'
+#----------------V2----------------------------
+require 'yelpster/v2/request'
+require 'yelpster/v2/business/request/id'
+require 'yelpster/v2/search/request/base'
+require 'yelpster/v2/search/request/geo_point'
+require 'yelpster/v2/search/request/bounding_box'
+require 'yelpster/v2/search/request/location'
+
+class Yelp
+  VERSION = '1.1.1'
+end

data/test/test_business_retrieve.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'test/unit'
+require 'yelpster'
+
+require File.dirname(__FILE__) + '/yelp_helper'
+
+class TestBusinessRetrieve < Test::Unit::TestCase
+  include YelpHelper
+
+  def setup
+    create_client YelpHelper::API_V2
+  end
+  
+  CHOCOLATE_SF_ID = 'chocolate-san-francisco'
+  
+  def test_id_retrieval
+    request = Yelp::V2::Business::Request::Id.new(
+                :yelp_business_id => "pjb2WMwa0AfK3L-dWimO8w",
+                :consumer_key => @consumer_key,
+                :consumer_secret => @consumer_secret,
+                :token => @token,
+                :token_secret => @token_secret)
+    response = @client.search(request)
+    validate_json_to_ruby_business(response)
+    assert_equal response['id'], CHOCOLATE_SF_ID
+  end
+end

data/test/test_business_search.rb

@@ -0,0 +1,73 @@
+require 'rubygems'
+require 'test/unit'
+require 'yelpster'
+require File.dirname(__FILE__) + '/yelp_helper'
+
+class TestBusinessSearch < Test::Unit::TestCase
+  include YelpHelper
+  
+  def setup
+    create_client YelpHelper::API_V2
+  end
+  
+  BUSINESS_LAT = 37.782303
+  BUSINESS_LON = -122.484101
+  BUSINESS_LOCATION = {
+    "cross_streets"=>"24th Ave & 25th Ave",
+    "city"=>"San Francisco", 
+    "display_address"=>["2308 Clement St", "(b/t 24th Ave & 25th Ave)", "Outer Richmond", "San Francisco, CA 94121"], 
+    "geo_accuracy"=>8,
+    "neighborhoods"=>["Outer Richmond"], 
+    "postal_code"=>"94121", 
+    "country_code"=>"US", 
+    "address"=>["2308 Clement St"], 
+    "coordinate"=>{"latitude"=>37.782303, "longitude"=>-122.484101},
+    "state_code"=>"CA"
+    }
+
+  def test_bounding_box_search
+    request = Yelp::V2::Search::Request::BoundingBox.new(
+                :sw_latitude => 37.9,
+                :sw_longitude => -122.5,
+                :ne_latitude => 37.788022,
+                :ne_longitude => -122.399797,
+#                :radius => 1,
+#                :business_count => 3,
+                :term => 'yelp',
+                :consumer_key => @consumer_key,
+                :consumer_secret => @consumer_secret,
+                :token => @token,
+                :token_secret => @token_secret)
+    response = @client.search(request)
+    validate_json_to_ruby_response(response)
+  end
+  
+  def test_geo_point_search
+    request = Yelp::V2::Search::Request::GeoPoint.new(:latitude => BUSINESS_LAT,
+                                                      :longitude => BUSINESS_LON,
+                                                      :consumer_key => @consumer_key,
+                                                      :consumer_secret => @consumer_secret,
+                                                      :token => @token,
+                                                      :token_secret => @token_secret)
+    response = @client.search(request)
+    validate_json_to_ruby_response(response)
+    assert_equal response['businesses'].first["location"], BUSINESS_LOCATION
+  end
+  
+  BUSINESS_ADDRESS = '2308 Clement St'
+  
+  def test_location_search
+    request = Yelp::V2::Search::Request::Location.new(:address => BUSINESS_ADDRESS,
+                                                      :city => 'San Francisco',
+                                                      :state => 'CA',
+                                                      :zipcode => 94121,
+                                                      :consumer_key => @consumer_key,
+                                                      :consumer_secret => @consumer_secret,
+                                                      :token => @token,
+                                                      :token_secret => @token_secret)
+    response = @client.search(request)
+    validate_json_to_ruby_response(response)
+    assert_equal response['businesses'].first['location'], BUSINESS_LOCATION
+  end
+end
+  

data/test/test_client.rb

@@ -0,0 +1,11 @@
+require 'test/unit'
+require 'yelpster'
+
+class TestClient < Test::Unit::TestCase
+  def test_validation
+    # make sure we can do basic client instantiation
+    assert_nothing_raised do
+      @client = Yelp::Client.new
+    end
+  end
+end

data/test/test_neighborhood_search.rb

@@ -0,0 +1,46 @@
+require 'rubygems'
+require 'test/unit'
+require 'yelpster'
+require File.dirname(__FILE__) + '/yelp_helper'
+
+class TestNeighborhoodSearch < Test::Unit::TestCase
+  include YelpHelper
+
+  def setup
+    create_client YelpHelper::API_V1
+  end
+
+  GORDO_LAT = 37.782093
+  GORDO_LON = -122.483230
+  GORDO_NEIGHBORHOOD = {
+    "city" => "San Francisco",
+    "name" => "Outer Richmond",
+    "country_code" => "US",
+    "country" => "USA",
+    "borough" => "",
+    "url" => "http://www.yelp.com/search?find_loc=Outer+Richmond%2C+San+Francisco%2C+CA%2C+USA", 
+    "state" => "CA",
+    "state_code" => "CA" }
+
+  def test_geo_point_search
+    request = Yelp::V1::Neighborhood::Request::GeoPoint.new(:latitude => GORDO_LAT,
+                                                        :longitude => GORDO_LON,
+                                                        :yws_id => @yws_id)
+    response = @client.search(request)
+    validate_json_to_ruby_response(response)
+    assert_equal response['neighborhoods'].first, GORDO_NEIGHBORHOOD
+  end
+
+  GORDO_ADDRESS = '2252 Clement Street'
+
+  def test_location_search
+    request = Yelp::V1::Neighborhood::Request::Location.new(:address => GORDO_ADDRESS,
+                                                        :city => 'San Francisco',
+                                                        :state => 'CA',
+                                                        :zipcode => 94121,
+                                                        :yws_id => @yws_id)
+    response = @client.search(request)
+    validate_json_to_ruby_response(response)
+    assert_equal response['neighborhoods'].first, GORDO_NEIGHBORHOOD
+  end
+end

data/test/test_phone_search.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'test/unit'
+require 'yelpster'
+require File.dirname(__FILE__) + '/yelp_helper'
+
+class TestPhoneSearch < Test::Unit::TestCase
+  include YelpHelper
+
+  def setup
+    create_client YelpHelper::API_V1
+  end
+
+  GORDO_PHONE_NUMBER = '4155666011'
+
+  def test_phone_search
+    request = Yelp::V1::Phone::Request::Number.new(:phone_number => GORDO_PHONE_NUMBER, :yws_id => @yws_id)
+    response = @client.search(request)
+    validate_json_to_ruby_response(response)
+  end
+end