google_geocoding 0.1.5 → 0.2.0

data/VERSION

@@ -1 +1 @@
-0.1.5
+0.2.0

data/google_geocoding.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{google_geocoding}
-  s.version = "0.1.5"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Rodrigo Kochenburger"]
-  s.date = %q{2010-03-04}
+  s.date = %q{2010-03-30}
   s.description = %q{GoogleGeocoding is a small library for performing geocoding using the Google's HTTP geocoding API}
   s.email = %q{divoxx@gmail.com}
   s.extra_rdoc_files = [
@@ -25,21 +25,29 @@ Gem::Specification.new do |s|
      "VERSION",
      "google_geocoding.gemspec",
      "lib/google_geocoding.rb",
+     "lib/google_geocoding/address_component.rb",
      "lib/google_geocoding/errors.rb",
      "lib/google_geocoding/geocoder.rb",
-     "lib/google_geocoding/placemark.rb",
+     "lib/google_geocoding/request.rb",
      "lib/google_geocoding/response.rb",
-     "spec/google_geocoding_spec.rb",
+     "lib/google_geocoding/result.rb",
+     "spec/classes/request_spec.rb",
+     "spec/classes/response_spec.rb",
+     "spec/classes/result_spec.rb",
+     "spec/integration_spec.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb"
   ]
   s.homepage = %q{http://github.com/divoxx/google_geocoding}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.5}
+  s.rubygems_version = %q{1.3.6}
   s.summary = %q{Google's geocoding library}
   s.test_files = [
-    "spec/google_geocoding_spec.rb",
+    "spec/classes/request_spec.rb",
+     "spec/classes/response_spec.rb",
+     "spec/classes/result_spec.rb",
+     "spec/integration_spec.rb",
      "spec/spec_helper.rb"
   ]
 

data/lib/google_geocoding/address_component.rb

@@ -0,0 +1,25 @@
+module GoogleGeocoding
+  class AddressComponent
+    REQUIRED_ATTRIBUTES = [:long_name, :short_name, :types].freeze
+    attr_reader *REQUIRED_ATTRIBUTES
+    
+    def initialize(params)
+      process_args(params)
+    end
+    
+  private
+    def process_args(args)
+      error = Errors::InvalidParametersError.new(self)
+      
+      REQUIRED_ATTRIBUTES.each do |req_attr|
+        error.add(req_attr, :required) unless args.include?(req_attr)
+      end
+      
+      raise error unless error.empty?
+      
+      @types      = Array(args[:types]).map { |type| type.to_sym }.freeze
+      @long_name  = args[:long_name].freeze
+      @short_name = args[:short_name].freeze
+    end    
+  end
+end

data/lib/google_geocoding/errors.rb

@@ -1,75 +1,44 @@
 module GoogleGeocoding
   module Errors
-    # Base error for the geocoding service, all error should inherit from this one.
-    class BaseError < StandardError; end
-    
-    # Http error, will be raised when the server returns with a status code outside the 200...300 range.
-    class HttpError < BaseError
-      def initialize(address, response)
-        @address  = address
-        @response = response
-        super "Could not geocode '#{@address}'. Server responded with #{@response.status}"
+    # Error representing that the parameters provided to the request are invalid.
+    class InvalidParametersError < BaseError
+      def initialize(request)
+        @request  = request
+        @messages = Hash.new { |h,k| h[k] = [] }
       end
-    end
-          
-    # Services error means the service was reached but returned a unsuccessful response.
-    class ServiceError < BaseError; end
-    
-    # 500 G_GEO_SERVER_ERROR
-    class ServerError < ServiceError
-      def initialize
-        super("A geocoding or directions request could not be successfully processed, yet the exact reason for the failure is unknown.")
-      end
-    end
-    
-    # 601 G_GEO_MISSING_QUERY
-    class MissingQueryError < ServiceError
-      def initialize
-        super("An empty address was specified")
-      end
-    end
 
-    # 602 G_GEO_UNKNOWN_ADDRESS
-    class UnknownAddressError < ServiceError
-      def initialize
-        super("No corresponding geographic location could be found for the specified address, possibly because the address is relatively new, or because it may be incorrect.")
+      # Add a error message for the given param.
+      def add(param, identifier)
+        @messages[param] << identifier
       end
-    end
-    
-    # 603 G_GEO_UNAVAILABLE_ADDRESS
-    class UnavailableAddressError < ServiceError
-      def initialize
-        super("The geocode for the given address or the route for the given directions query cannot be returned due to legal or contractual reasons.")
+
+      # Returns the messages for the given param
+      def on(param)
+        @messages[param]
       end
-    end
-    
-    # 610 G_GEO_BAD_KEY
-    class BadKeyError < ServiceError
-      def initialize
-        super("The given key is either invalid or does not match the domain for which it was given.")
+
+      # Returns a descriptive message of the error.
+      def message
+        message = "Some of the request parameters are invalid:"      
+        @messages.each { |param, identifiers|  message << "\n  * #{param}: #{identifiers.join(', ')}" }
+        message
       end
-    end
-    
-    # 620 G_GEO_TOO_MANY_QUERIES
-    class TooManyQueriesError < ServiceError
-      def initialize
-        super("The given key has gone over the requests limit in the 24 hour period or has submitted too many requests in too short a period of time. If you're sending multiple requests in parallel or in a tight loop, use a timer or pause in your code to make sure you don't send the requests too quickly.")
+
+      # Alias to_s to messages for easy terminal output
+      alias_method :to_s, :message
+
+      # Returns true/false for whether there are an error on any params
+      def empty?
+        @messages.empty?
       end
     end
     
-    # Extend ServiceError to include factory method based on status codes.
-    class ServiceError
-      ERRORS_MAPPING = {
-        500 => ServerError,
-        601 => MissingQueryError,
-        602 => UnknownAddressError,
-        603 => UnknownAddressError,
-        610 => BadKeyError,
-        620 => TooManyQueriesError
-      }
-      
-      def self.build(status)
-        ERRORS_MAPPING[status].new
+    # Http error, will be raised when the server returns with a status code outside the 200...300 range.
+    class HttpError < BaseError
+      def initialize(address, response)
+        @address  = address
+        @response = response
+        super "Could not geocode '#{@address}'. Server responded with #{@response.status}"
       end
     end
   end

data/lib/google_geocoding/geocoder.rb

@@ -10,7 +10,7 @@ module GoogleGeocoding
       @options = options
       @sess = Patron::Session.new
       @sess.timeout = options[:timeout] || 10
-      @sess.base_url = "http://maps.google.com/maps/geo"
+      @sess.base_url = "http://maps.google.com/maps/api/geocode"
       @sess.headers['User-Agent'] = options[:user_agent]
     end
 
@@ -19,12 +19,11 @@ module GoogleGeocoding
     # @param [String, #to_s]
     # @return [Response]
     def query(address)
-      params = "?q=#{URI.encode(address.to_s)}"
-      params << "&key=#{@options[:api_key]}" if @options[:api_key]
-      resp = @sess.get(params)
+      request  = Request.new(:address => address, :sensor => false)
+      response = @sess.get("/json?#{request.query_string}")
   
-      if (200...300).include?(resp.status)
-        Response.new(resp.body)
+      if (200...300).include?(response.status)
+        Response.new(response.body)
       else
         raise Errors::HttpError.new(address, resp)
       end

data/lib/google_geocoding/request.rb

@@ -0,0 +1,47 @@
+module GoogleGeocoding
+  # Encapsulation of the request information to be sent to the API endpoing.
+  class Request
+    # Creates a new request.
+    #
+    # @param [Hash] params hash of the parameters for the request. Valid parameters are:
+    #   - address (required) - The address that you want to geocode.
+    #   - *OR* latlng (required) - The textual latitude/longitude value for which you wish to obtain the closest, human-readable address.
+    #   - bounds (optional) - The bounding box of the viewport within which to bias geocode results more prominently.
+    #   - region (optional) - The region code, specified as a ccTLD ("top-level domain") two-character value.
+    #   - language (optional) - The language in which to return results. See the supported list of domain languages.
+    #   - sensor (required) - Indicates whether or not the geocoding request comes from a device with a location sensor. This value must be either true or false.
+    #
+    # @raise InvalidRequestParametersError
+    def initialize(params = {})
+      @params = params.dup
+      check_params!
+    end
+    
+    # Return the request query string.
+    # @return [String]
+    def query_string
+      @params.map { |param, value| "#{CGI.escape(param.to_s)}=#{CGI.escape(value.to_s)}" }.join("&")
+    end
+
+  private
+    def check_params!
+      error = Errors::InvalidParametersError.new(self)
+      
+      if @params[:address].nil?
+        error.add(:address, :required)
+      end
+      
+      if @params[:required] && @params[:latlng].nil?
+        error.add(:latlng, :required)
+      end
+      
+      if @params[:sensor].nil?
+        error.add(:sensor, :required)
+      elsif ![true, false].include?(@params[:sensor])
+        error.add(:sensor, :boolean)
+      end
+      
+      raise error unless error.empty?
+    end
+  end
+end

data/lib/google_geocoding/response.rb

@@ -3,71 +3,44 @@ module GoogleGeocoding
     # Creates a new response object from the given response body, expects to be a JSON string.
     #
     # @param [String]
-    def initialize(resp_body)
-      @data = JSON.parse(resp_body)
+    def initialize(payload, result_class = nil)
+      @data         = JSON.parse(payload)
+      @result_class = result_class || GoogleGeocoding.const_get(:Result)
     end
 
     # Return the status code included in the server response.
     #
-    # @return [Integer] 
-    # @see http://code.google.com/apis/maps/documentation/geocoding/index.html#StatusCodes
-    def status_code
-      Integer(@data["Status"]["code"])
+    # @return [Symbol]
+    # @see http://code.google.com/apis/maps/documentation/geocoding/#StatusCodes
+    def status
+      @status ||= @data["status"].downcase.to_sym
     end
 
     # Return whether response successfully resolved the geolocation
     def success?
-      status_code == 200
+      status == :ok
     end
 
     # Return whether response failed to resolved the geolocation
     def failure?
       !success?
     end
-
-    # Return the placemarks included in the response.
-    #
-    # @return [Array<Placemark>]
-    def placemarks
-      if failure?
-        raise Errors::ServiceError.build(status_code)
-      else
-        placemarks = []
-
-        @data["Placemark"].each do |placemark_data|
-          details               = placemark_data["AddressDetails"]
-          coordinates           = placemark_data["Point"]["coordinates"][0..1].reverse
-          accurracy             = Integer(details["Accuracy"])
-          placemark             = Placemark.new
-          placemark.accurracy   = accurracy
-          placemark.coordinates = coordinates
-
-          if country = details["Country"]
-            placemark.country_name = country["CountryName"],
-            placemark.country_code = country["CountryNameCode"]
-
-            if admarea = country["AdministrativeArea"]
-              placemark.region = admarea["AdministrativeAreaName"]
-              subadmarea       = admarea["SubAdministrativeArea"]                
-              locality         = subadmarea ? subadmarea["Locality"] : admarea["Locality"]
-
-              if locality
-                placemark.city = locality["LocalityName"]
-
-                if postal_code = locality["PostalCode"]
-                  placemark.postal_code = postal_code["PostalCodeNumber"]
-                end
-
-                if thoroughfare = locality["Thoroughfare"]
-                  placemark.street = thoroughfare["ThoroughfareName"]
-                end
-              end
-            end
-          end
-
-          placemarks << placemark
+    
+    # Return the types of the result
+    def results
+      @result ||= @data["results"].map do |result_data|
+        result = @result_class.new(
+          :types       => result_data["types"],
+          :address     => result_data["formatted_address"],
+          :coordinates => result_data["geometry"]["location"].values_at("lat", "lng"),
+          :precision   => result_data["geometry"]["location_type"]
+        )
+        
+        result_data["address_components"].each do |addr_comp_data|
+          result << AddressComponent.new(:short_name => addr_comp_data["short_name"], :long_name => addr_comp_data["long_name"], :types => addr_comp_data["types"])
         end
-        placemarks
+        
+        result
       end
     end
   end

data/lib/google_geocoding/result.rb

@@ -0,0 +1,36 @@
+module GoogleGeocoding
+  # Model that represents a placemark returned by the geocoding service.
+  class Result
+    REQUIRED_ATTRIBUTES = [:types, :address, :coordinates, :precision].freeze
+    attr_reader :components, *REQUIRED_ATTRIBUTES
+    
+    def initialize(args = {})
+      process_args(args)
+      @components = []
+    end
+    
+    def <<(component)
+      @components << component
+    end
+    
+    def each(&block)
+      @component.each(&block)
+    end
+    
+  private
+    def process_args(args)
+      error = Errors::InvalidParametersError.new(self)
+      
+      REQUIRED_ATTRIBUTES.each do |req_attr|
+        error.add(req_attr, :required) unless args.include?(req_attr)
+      end
+      
+      raise error unless error.empty?
+      
+      @types       = Array(args[:types]).map { |type| type.to_sym }.freeze
+      @address     = args[:address].freeze
+      @coordinates = args[:coordinates].freeze
+      @precision   = args[:precision].downcase.to_sym
+    end
+  end
+end

data/lib/google_geocoding.rb

@@ -1,6 +1,23 @@
+begin
+  require 'rubygems'
+rescue LoadError
+  # Ignore
+end
+
+# Dependencies
+require 'cgi'
 require 'json'
 require 'patron'
+
+module GoogleGeocoding
+  # Base class for all errors
+  class BaseError < StandardError; end
+end
+
+# Require google_geocoding parts
 require 'google_geocoding/errors'
-require 'google_geocoding/placemark'
+require 'google_geocoding/request'
+require 'google_geocoding/address_component'
+require 'google_geocoding/result'
 require 'google_geocoding/response'
 require 'google_geocoding/geocoder'

data/spec/classes/request_spec.rb

@@ -0,0 +1,26 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Request do
+  describe "request creation" do
+    it "should create a request with valid params" do
+      lambda { Request.new(:address => "2 Townsend St, San Francisco, CA", :sensor => false) }.should_not raise_error(Errors::InvalidParametersError)
+    end
+  
+    it "should raise InvalidRequestParametersError when address is missing" do
+      lambda { Request.new }.should raise_error(Errors::InvalidParametersError) do |error|
+        error.on_param(:address).should include(:required)
+        error.on_param(:sensor).should include(:required)
+      end
+    end
+  end
+  
+  describe "request usage" do  
+    before :each do
+      @request = Request.new(:address => "2 Townsend St, San Francisco, CA", :sensor => false)
+    end
+    
+    it "should return the query string" do
+      @request.query_string.should == "address=2+Townsend+St%2C+San+Francisco%2C+CA&sensor=false"
+    end
+  end
+end

data/spec/classes/response_spec.rb

@@ -0,0 +1,80 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Response do
+  before :each do
+    @result_inst  = mock(:result_instance, :<< => nil)
+    @result_class = mock(:result_class, :new => @result_inst)
+    @response     = Response.new(DATA, @result_class)
+  end
+  
+  it "should provide status" do
+    @response.status.should == :ok
+  end
+  
+  it "should provide whether it is a successful request" do
+    @response.should be_success
+  end
+  
+  it "should provide whether it is a failure request" do
+    @response.should_not be_failure
+  end
+  
+  it "should provide the results" do
+    args = {:types => ["street_address"], :address => "1600 Amphitheatre Pkwy, Mountain View, CA 94043, USA", :coordinates => [37.4219720, -122.0841430], :precision => "ROOFTOP"}
+    @result_class.should_receive(:new).once.with(args).and_return(@result_inst)
+    @response.results.should be_instance_of(Array)
+    @response.results.each { |item| item.should be(@result_inst) }
+  end
+  
+  DATA = <<-EOF
+{
+  "status": "OK",
+  "results": [ {
+    "types": [ "street_address" ],
+    "formatted_address": "1600 Amphitheatre Pkwy, Mountain View, CA 94043, USA",
+    "address_components": [ {
+      "long_name": "1600",
+      "short_name": "1600",
+      "types": [ "street_number" ]
+    }, {
+      "long_name": "Amphitheatre Pkwy",
+      "short_name": "Amphitheatre Pkwy",
+      "types": [ "route" ]
+    }, {
+      "long_name": "Mountain View",
+      "short_name": "Mountain View",
+      "types": [ "locality", "political" ]
+    }, {
+      "long_name": "California",
+      "short_name": "CA",
+      "types": [ "administrative_area_level_1", "political" ]
+    }, {
+      "long_name": "United States",
+      "short_name": "US",
+      "types": [ "country", "political" ]
+    }, {
+      "long_name": "94043",
+      "short_name": "94043",
+      "types": [ "postal_code" ]
+    } ],
+    "geometry": {
+      "location": {
+        "lat": 37.4219720,
+        "lng": -122.0841430
+      },
+      "location_type": "ROOFTOP",
+      "viewport": {
+        "southwest": {
+          "lat": 37.4188244,
+          "lng": -122.0872906
+        },
+        "northeast": {
+          "lat": 37.4251196,
+          "lng": -122.0809954
+        }
+      }
+    }
+  } ]
+}
+  EOF
+end

data/spec/classes/result_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Result do
+  describe "result creation" do
+    it "should create object and set properties" do
+      result = Result.new(
+        :types       => ["street_address"], 
+        :address     => "1600 Amphitheatre Pkwy, Mountain View, CA 94043, USA",
+        :coordinates => [37.4219720, -122.0841430],
+        :precision   => "ROOFTOP"
+      )
+      
+      result.types.should == [:street_address]
+      result.address.should == "1600 Amphitheatre Pkwy, Mountain View, CA 94043, USA"
+      result.coordinates.should == [37.4219720, -122.0841430]
+      result.precision.should == :rooftop
+    end
+    
+    %w(types address coordinates precision).each do |missing_attr|
+      it "should raise an error when #{missing_attr} is missing" do
+        attrs = {
+          :types       => ["street_address"], 
+          :address     => "1600 Amphitheatre Pkwy, Mountain View, CA 94043, USA",
+          :coordinates => [37.4219720, -122.0841430],
+          :precision   => "ROOFTOP"
+        }
+        attrs.delete(missing_attr.to_sym)
+        lambda { Result.new(attrs) }.should raise_error(Errors::InvalidParametersError)
+      end
+    end
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe "Full-stack geocoding (Integration test)" do
+  before :each do
+    @geocoder = GoogleGeocoding::Geocoder.new
+  end
+  
+  it "should return successful response with valida address" do
+    pending
+    response = @geocoder.query("2 Townsend St, San Francisco, CA")
+    response.status.should == :ok
+    response.should be_success
+  end  
+end

data/spec/spec_helper.rb

@@ -4,6 +4,7 @@ require 'google_geocoding'
 require 'spec'
 require 'spec/autorun'
 
+include GoogleGeocoding
+
 Spec::Runner.configure do |config|
-  
 end

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: google_geocoding
 version: !ruby/object:Gem::Version 
-  version: 0.1.5
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Rodrigo Kochenburger
@@ -9,49 +14,65 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-04 00:00:00 -08:00
+date: 2010-03-30 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: json
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 0
         version: 1.2.0
-    version: 
+  type: :runtime
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: patron
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 4
+        - 5
         version: 0.4.5
-    version: 
+  type: :runtime
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: rspec
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
         version: 1.2.9
-    version: 
+  type: :development
+  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: yard
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 5
+        - 3
         version: 0.5.3
-    version: 
+  type: :development
+  version_requirements: *id004
 description: GoogleGeocoding is a small library for performing geocoding using the Google's HTTP geocoding API
 email: divoxx@gmail.com
 executables: []
@@ -70,11 +91,16 @@ files:
 - VERSION
 - google_geocoding.gemspec
 - lib/google_geocoding.rb
+- lib/google_geocoding/address_component.rb
 - lib/google_geocoding/errors.rb
 - lib/google_geocoding/geocoder.rb
-- lib/google_geocoding/placemark.rb
+- lib/google_geocoding/request.rb
 - lib/google_geocoding/response.rb
-- spec/google_geocoding_spec.rb
+- lib/google_geocoding/result.rb
+- spec/classes/request_spec.rb
+- spec/classes/response_spec.rb
+- spec/classes/result_spec.rb
+- spec/integration_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 has_rdoc: true
@@ -90,21 +116,26 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Google's geocoding library
 test_files: 
-- spec/google_geocoding_spec.rb
+- spec/classes/request_spec.rb
+- spec/classes/response_spec.rb
+- spec/classes/result_spec.rb
+- spec/integration_spec.rb
 - spec/spec_helper.rb

data/lib/google_geocoding/placemark.rb

@@ -1,30 +0,0 @@
-module GoogleGeocoding
-  # Model that represents a placemark returned by the geocoding service.
-  class Placemark
-    # The level of accurracy for the placemark
-    # @see http://code.google.com/apis/maps/documentation/geocoding/index.html#GeocodingAccuracy
-    attr_accessor :accurracy
-    
-    # The country name
-    attr_accessor :country_name
-    
-    # The country ISO code
-    # @see http://www.iso.org/iso/country_codes/iso_3166_code_lists/english_country_names_and_code_elements.htm
-    attr_accessor :country_code
-    
-    # The region/province/state
-    attr_accessor :region
-    
-    # The city name
-    attr_accessor :city
-    
-    # The postal/zip code
-    attr_accessor :postal_code
-    
-    # The street address, including the number
-    attr_accessor :street
-    
-    # An array with two positions: latitude and longitude
-    attr_accessor :coordinates
-  end
-end

data/spec/google_geocoding_spec.rb

@@ -1,7 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "GoogleGeocoding" do
-  it "fails" do
-    fail "hey buddy, you should probably rename this file and start specing for real"
-  end
-end