steveh-geokit 1.6.0 → 1.6.1

data/Gemfile.lock

@@ -1,16 +1,19 @@
 PATH
   remote: .
   specs:
-    geokit (1.5.0)
+    steveh-geokit (1.6.0)
+      activesupport (~> 3)
 
 GEM
   remote: http://rubygems.org/
   specs:
+    activesupport (3.0.4)
     mocha (0.9.12)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  geokit!
-  mocha
+  activesupport (~> 3)
+  mocha (>= 0.9)
+  steveh-geokit!

data/geokit.gemspec

@@ -18,5 +18,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_development_dependency("mocha", [">= 0"])
+  s.add_runtime_dependency("activesupport", ["~> 3"])
+
+  s.add_development_dependency("mocha", [">= 0.9"])
 end

data/lib/geokit.rb

@@ -28,11 +28,19 @@ require 'rexml/document'
 require 'yaml'
 require 'timeout'
 require 'logger'
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/object/conversions'
+require 'openssl'
+require 'base64'
+require 'json'
 
 require 'geokit/too_many_queries_error'
 require 'geokit/inflector'
 require 'geokit/geocoders'
 require 'geokit/mappable'
+require 'geokit/lat_lng'
+require 'geokit/geo_loc'
+require 'geokit/bounds'
 require 'geokit/geocoders/geocode_error'
 require 'geokit/geocoders/geocoder'
 
@@ -40,6 +48,7 @@ require 'geokit/geocoders/ca_geocoder'
 require 'geokit/geocoders/geo_plugin_geocoder'
 require 'geokit/geocoders/geonames_geocoder'
 require 'geokit/geocoders/google_geocoder'
+require 'geokit/geocoders/google_premier_geocoder'
 require 'geokit/geocoders/ip_geocoder'
 require 'geokit/geocoders/multi_geocoder'
 require 'geokit/geocoders/us_geocoder'

data/lib/geokit/bounds.rb

@@ -0,0 +1,95 @@
+module Geokit
+  # Bounds represents a rectangular bounds, defined by the SW and NE corners
+  class Bounds
+    # sw and ne are LatLng objects
+    attr_accessor :sw, :ne
+
+    # provide sw and ne to instantiate a new Bounds instance
+    def initialize(sw,ne)
+      raise ArgumentError if !(sw.is_a?(Geokit::LatLng) && ne.is_a?(Geokit::LatLng))
+      @sw,@ne=sw,ne
+    end
+
+    #returns the a single point which is the center of the rectangular bounds
+    def center
+      @sw.midpoint_to(@ne)
+    end
+
+    # a simple string representation:sw,ne
+    def to_s
+      "#{@sw.to_s},#{@ne.to_s}"
+    end
+
+    # a two-element array of two-element arrays: sw,ne
+    def to_a
+      [@sw.to_a, @ne.to_a]
+    end
+
+    # Returns true if the bounds contain the passed point.
+    # allows for bounds which cross the meridian
+    def contains?(point)
+      point=Geokit::LatLng.normalize(point)
+      res = point.lat > @sw.lat && point.lat < @ne.lat
+      if crosses_meridian?
+        res &= point.lng < @ne.lng || point.lng > @sw.lng
+      else
+        res &= point.lng < @ne.lng && point.lng > @sw.lng
+      end
+      res
+    end
+
+    # returns true if the bounds crosses the international dateline
+    def crosses_meridian?
+      @sw.lng > @ne.lng
+    end
+
+    # Returns true if the candidate object is logically equal.  Logical equivalence
+    # is true if the lat and lng attributes are the same for both objects.
+    def ==(other)
+      other.is_a?(Bounds) ? self.sw == other.sw && self.ne == other.ne : false
+    end
+
+    # Equivalent to Google Maps API's .toSpan() method on GLatLng's.
+    #
+    # Returns a LatLng object, whose coordinates represent the size of a rectangle
+    # defined by these bounds.
+    def to_span
+      lat_span = (@ne.lat - @sw.lat).abs
+      lng_span = (crosses_meridian? ? 360 + @ne.lng - @sw.lng : @ne.lng - @sw.lng).abs
+      Geokit::LatLng.new(lat_span, lng_span)
+    end
+
+    class <<self
+
+      # returns an instance of bounds which completely encompases the given circle
+      def from_point_and_radius(point,radius,options={})
+        point=LatLng.normalize(point)
+        p0=point.endpoint(0,radius,options)
+        p90=point.endpoint(90,radius,options)
+        p180=point.endpoint(180,radius,options)
+        p270=point.endpoint(270,radius,options)
+        sw=Geokit::LatLng.new(p180.lat,p270.lng)
+        ne=Geokit::LatLng.new(p0.lat,p90.lng)
+        Geokit::Bounds.new(sw,ne)
+      end
+
+      # Takes two main combinations of arguments to create a bounds:
+      # point,point   (this is the only one which takes two arguments
+      # [point,point]
+      # . . . where a point is anything LatLng#normalize can handle (which is quite a lot)
+      #
+      # NOTE: everything combination is assumed to pass points in the order sw, ne
+      def normalize (thing,other=nil)
+        # maybe this will be simple -- an actual bounds object is passed, and we can all go home
+        return thing if thing.is_a? Bounds
+
+        # no? OK, if there's no "other," the thing better be a two-element array
+        thing,other=thing if !other && thing.is_a?(Array) && thing.size==2
+
+        # Now that we're set with a thing and another thing, let LatLng do the heavy lifting.
+        # Exceptions may be thrown
+        Bounds.new(Geokit::LatLng.normalize(thing),Geokit::LatLng.normalize(other))
+      end
+    end
+  end
+end

data/lib/geokit/geo_loc.rb

@@ -0,0 +1,115 @@
+module Geokit
+  # This class encapsulates the result of a geocoding call.
+  # It's primary purpose is to homogenize the results of multiple
+  # geocoding providers. It also provides some additional functionality, such as
+  # the "full address" method for geocoders that do not provide a
+  # full address in their results (for example, Yahoo), and the "is_us" method.
+  #
+  # Some geocoders can return multple results. Geoloc can capture multiple results through
+  # its "all" method.
+  #
+  # For the geocoder setting the results, it would look something like this:
+  #     geo=GeoLoc.new(first_result)
+  #     geo.all.push(second_result)
+  #     geo.all.push(third_result)
+  #
+  # Then, for the user of the result:
+  #
+  #     puts geo.full_address     # just like usual
+  #     puts geo.all.size  => 3   # there's three results total
+  #     puts geo.all.first        # all is just an array or additional geolocs,
+  #                                 so do what you want with it
+  class GeoLoc < LatLng
+
+    # Location attributes.  Full address is a concatenation of all values.  For example:
+    # 100 Spear St, San Francisco, CA, 94101, US
+    attr_accessor :street_address, :city, :state, :zip, :country_code, :country, :full_address, :all, :district, :province
+    # Attributes set upon return from geocoding.  Success will be true for successful
+    # geocode lookups.  The provider will be set to the name of the providing geocoder.
+    # Finally, precision is an indicator of the accuracy of the geocoding.
+    attr_accessor :success, :provider, :precision, :suggested_bounds
+    # Street number and street name are extracted from the street address attribute.
+    attr_reader :street_number, :street_name
+    # accuracy is set for Yahoo and Google geocoders, it is a numeric value of the
+    # precision. see http://code.google.com/apis/maps/documentation/geocoding/#GeocodingAccuracy
+    attr_accessor :accuracy
+
+    # Constructor expects a hash of symbols to correspond with attributes.
+    def initialize(h={})
+      @all = [self]
+
+      @street_address=h[:street_address]
+      @city=h[:city]
+      @state=h[:state]
+      @zip=h[:zip]
+      @country_code=h[:country_code]
+      @province = h[:province]
+      @success=false
+      @precision='unknown'
+      @full_address=nil
+      super(h[:lat],h[:lng])
+    end
+
+    # Returns true if geocoded to the United States.
+    def is_us?
+      country_code == 'US'
+    end
+
+    def success?
+      success == true
+    end
+
+    # full_address is provided by google but not by yahoo. It is intended that the google
+    # geocoding method will provide the full address, whereas for yahoo it will be derived
+    # from the parts of the address we do have.
+    def full_address
+      @full_address ? @full_address : to_geocodeable_s
+    end
+
+    # Extracts the street number from the street address if the street address
+    # has a value.
+    def street_number
+      street_address[/(\d*)/] if street_address
+    end
+
+    # Returns the street name portion of the street address.
+    def street_name
+       street_address[street_number.length, street_address.length].strip if street_address
+    end
+
+    # gives you all the important fields as key-value pairs
+    def hash
+      res={}
+      [:success,:lat,:lng,:country_code,:city,:state,:zip,:street_address,:province,:district,:provider,:full_address,:is_us?,:ll,:precision].each { |s| res[s] = self.send(s.to_s) }
+      res
+    end
+    alias to_hash hash
+
+    # Sets the city after capitalizing each word within the city name.
+    def city=(city)
+      @city = Geokit::Inflector::titleize(city) if city
+    end
+
+    # Sets the street address after capitalizing each word within the street address.
+    def street_address=(address)
+      @street_address = Geokit::Inflector::titleize(address) if address
+    end
+
+    # Returns a comma-delimited string consisting of the street address, city, state,
+    # zip, and country code.  Only includes those attributes that are non-blank.
+    def to_geocodeable_s
+      a=[street_address, district, city, province, state, zip, country_code].compact
+      a.delete_if { |e| !e || e == '' }
+      a.join(', ')
+    end
+
+    def to_yaml_properties
+      (instance_variables - ['@all']).sort
+    end
+
+    # Returns a string representation of the instance.
+    def to_s
+      "Provider: #{provider}\nStreet: #{street_address}\nCity: #{city}\nState: #{state}\nZip: #{zip}\nLatitude: #{lat}\nLongitude: #{lng}\nCountry: #{country_code}\nSuccess: #{success}"
+    end
+  end
+end

data/lib/geokit/geocoders.rb

@@ -26,6 +26,8 @@ module Geokit
     @@request_timeout = nil
     @@yahoo = 'REPLACE_WITH_YOUR_YAHOO_KEY'
     @@google = 'REPLACE_WITH_YOUR_GOOGLE_KEY'
+    @@google_client = 'REPLACE_WITH_YOUR_GOOGLE_CLIENT'
+    @@google_channel = 'REPLACE_WITH_YOUR_GOOGLE_CHANNEL'
     @@geocoder_us = false
     @@geocoder_ca = false
     @@geonames = false

data/lib/geokit/geocoders/google_geocoder.rb

@@ -4,135 +4,142 @@ module Geokit
     # contain a Google API key.  Conforms to the interface set by the Geocoder class.
     class GoogleGeocoder < Geocoder
 
+      ENDPOINT = "http://maps.google.com/maps/geo"
+
       private
 
-      # Template method which does the reverse-geocode lookup.
-      def self.do_reverse_geocode(latlng)
-        latlng=LatLng.normalize(latlng)
-        res = self.call_geocoder_service("http://maps.google.com/maps/geo?ll=#{Geokit::Inflector::url_escape(latlng.ll)}&output=xml&key=#{Geokit::Geocoders::google}&oe=utf-8")
-        #        res = Net::HTTP.get_response(URI.parse("http://maps.google.com/maps/geo?ll=#{Geokit::Inflector::url_escape(address_str)}&output=xml&key=#{Geokit::Geocoders::google}&oe=utf-8"))
-        return GeoLoc.new unless (res.is_a?(Net::HTTPSuccess) || res.is_a?(Net::HTTPOK))
-        xml = res.body
-        logger.debug "Google reverse-geocoding. LL: #{latlng}. Result: #{xml}"
-        return self.xml2GeoLoc(xml)
-      end
+        # Template method which does the reverse-geocode lookup.
+        def self.do_reverse_geocode(latlng)
+          latlng = LatLng.normalize(latlng)
+          params = { :ll => latlng.ll, :output => "xml", :key => Geokit::Geocoders::google, :oe => "utf-8" }
+          url = "#{ENDPOINT}?" + params.to_query
+          res = self.call_geocoder_service(url)
+          return GeoLoc.new unless (res.is_a?(Net::HTTPSuccess) || res.is_a?(Net::HTTPOK))
+          xml = res.body
+          logger.debug "Google reverse-geocoding. LL: #{latlng}. Result: #{xml}"
+          return self.xml2GeoLoc(xml)
+        end
 
-      # Template method which does the geocode lookup.
-      #
-      # Supports viewport/country code biasing
-      #
-      # ==== OPTIONS
-      # * :bias - This option makes the Google Geocoder return results biased to a particular
-      #           country or viewport. Country code biasing is achieved by passing the ccTLD
-      #           ('uk' for .co.uk, for example) as a :bias value. For a list of ccTLD's,
-      #           look here: http://en.wikipedia.org/wiki/CcTLD. By default, the geocoder
-      #           will be biased to results within the US (ccTLD .com).
-      #
-      #           If you'd like the Google Geocoder to prefer results within a given viewport,
-      #           you can pass a Geokit::Bounds object as the :bias value.
-      #
-      # ==== EXAMPLES
-      # # By default, the geocoder will return Syracuse, NY
-      # Geokit::Geocoders::GoogleGeocoder.geocode('Syracuse').country_code # => 'US'
-      # # With country code biasing, it returns Syracuse in Sicily, Italy
-      # Geokit::Geocoders::GoogleGeocoder.geocode('Syracuse', :bias => :it).country_code # => 'IT'
-      #
-      # # By default, the geocoder will return Winnetka, IL
-      # Geokit::Geocoders::GoogleGeocoder.geocode('Winnetka').state # => 'IL'
-      # # When biased to an bounding box around California, it will now return the Winnetka neighbourhood, CA
-      # bounds = Geokit::Bounds.normalize([34.074081, -118.694401], [34.321129, -118.399487])
-      # Geokit::Geocoders::GoogleGeocoder.geocode('Winnetka', :bias => bounds).state # => 'CA'
-      def self.do_geocode(address, options = {})
-        bias_str = options[:bias] ? construct_bias_string_from_options(options[:bias]) : ''
-        address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
-        res = self.call_geocoder_service("http://maps.google.com/maps/geo?q=#{Geokit::Inflector::url_escape(address_str)}&output=xml#{bias_str}&key=#{Geokit::Geocoders::google}&oe=utf-8")
-        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
-        xml = res.body
-        logger.debug "Google geocoding. Address: #{address}. Result: #{xml}"
-        return self.xml2GeoLoc(xml, address)
-      end
+        # Template method which does the geocode lookup.
+        #
+        # Supports viewport/country code biasing
+        #
+        # ==== OPTIONS
+        # * :bias - This option makes the Google Geocoder return results biased to a particular
+        #           country or viewport. Country code biasing is achieved by passing the ccTLD
+        #           ('uk' for .co.uk, for example) as a :bias value. For a list of ccTLD's,
+        #           look here: http://en.wikipedia.org/wiki/CcTLD. By default, the geocoder
+        #           will be biased to results within the US (ccTLD .com).
+        #
+        #           If you'd like the Google Geocoder to prefer results within a given viewport,
+        #           you can pass a Geokit::Bounds object as the :bias value.
+        #
+        # ==== EXAMPLES
+        # # By default, the geocoder will return Syracuse, NY
+        # Geokit::Geocoders::GoogleGeocoder.geocode('Syracuse').country_code # => 'US'
+        # # With country code biasing, it returns Syracuse in Sicily, Italy
+        # Geokit::Geocoders::GoogleGeocoder.geocode('Syracuse', :bias => :it).country_code # => 'IT'
+        #
+        # # By default, the geocoder will return Winnetka, IL
+        # Geokit::Geocoders::GoogleGeocoder.geocode('Winnetka').state # => 'IL'
+        # # When biased to an bounding box around California, it will now return the Winnetka neighbourhood, CA
+        # bounds = Geokit::Bounds.normalize([34.074081, -118.694401], [34.321129, -118.399487])
+        # Geokit::Geocoders::GoogleGeocoder.geocode('Winnetka', :bias => bounds).state # => 'CA'
+        def self.do_geocode(address, options = {})
+          address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
+          params = { :q => address_str, :output => "xml", :key => Geokit::Geocoders::google, :oe => "utf-8" }.merge(bias_options(options[:bias]))
+          url = "#{ENDPOINT}?" + params.to_query
+          res = self.call_geocoder_service(url)
+          return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
+          xml = res.body
+          logger.debug "Google geocoding. Address: #{address}. Result: #{xml}"
+          return self.xml2GeoLoc(xml, address)
+        end
 
-      def self.construct_bias_string_from_options(bias)
-        if bias.is_a?(String) or bias.is_a?(Symbol)
-          # country code biasing
-          "&gl=#{bias.to_s.downcase}"
-        elsif bias.is_a?(Bounds)
-          # viewport biasing
-          "&ll=#{bias.center.ll}&spn=#{bias.to_span.ll}"
+        def self.bias_options(bias)
+          if bias.is_a?(String) or bias.is_a?(Symbol)
+            # country code biasing
+            { :gl => bias.to_s.downcase }
+          elsif bias.is_a?(Bounds)
+            # viewport biasing
+            { :ll => bias.center.ll, :spn => bias.to_span.ll }
+          else
+            {}
+          end
         end
-      end
 
-      def self.xml2GeoLoc(xml, address="")
-        doc=REXML::Document.new(xml)
+        def self.xml2GeoLoc(xml, address="")
+          doc=REXML::Document.new(xml)
 
-        if doc.elements['//kml/Response/Status/code'].text == '200'
-          geoloc = nil
-          # Google can return multiple results as //Placemark elements.
-          # iterate through each and extract each placemark as a geoloc
-          doc.each_element('//Placemark') do |e|
-            extracted_geoloc = extract_placemark(e) # g is now an instance of GeoLoc
-            if geoloc.nil?
-              # first time through, geoloc is still nil, so we make it the geoloc we just extracted
-              geoloc = extracted_geoloc
-            else
-              # second (and subsequent) iterations, we push additional
-              # geolocs onto "geoloc.all"
-              geoloc.all.push(extracted_geoloc)
+          if doc.elements['//kml/Response/Status/code'].text == '200'
+            geoloc = nil
+            # Google can return multiple results as //Placemark elements.
+            # iterate through each and extract each placemark as a geoloc
+            doc.each_element('//Placemark') do |e|
+              extracted_geoloc = extract_placemark(e) # g is now an instance of GeoLoc
+              if geoloc.nil?
+                # first time through, geoloc is still nil, so we make it the geoloc we just extracted
+                geoloc = extracted_geoloc
+              else
+                # second (and subsequent) iterations, we push additional
+                # geolocs onto "geoloc.all"
+                geoloc.all.push(extracted_geoloc)
+              end
             end
+            return geoloc
+          elsif doc.elements['//kml/Response/Status/code'].text == '620'
+             raise Geokit::TooManyQueriesError
+          else
+            logger.info "Google was unable to geocode address: "+address
+            return GeoLoc.new
           end
-          return geoloc
-        elsif doc.elements['//kml/Response/Status/code'].text == '620'
-           raise Geokit::TooManyQueriesError
-        else
-          logger.info "Google was unable to geocode address: "+address
+
+        rescue Geokit::TooManyQueriesError
+          # re-raise because of other rescue
+          raise Geokit::TooManyQueriesError, "Google returned a 620 status, too many queries. 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."
+        rescue
+          logger.error "Caught an error during Google geocoding call: "+$!
           return GeoLoc.new
         end
 
-      rescue Geokit::TooManyQueriesError
-        # re-raise because of other rescue
-        raise Geokit::TooManyQueriesError, "Google returned a 620 status, too many queries. 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."
-      rescue
-        logger.error "Caught an error during Google geocoding call: "+$!
-        return GeoLoc.new
-      end
+        # extracts a single geoloc from a //placemark element in the google results xml
+        def self.extract_placemark(doc)
+          res = GeoLoc.new
+          coordinates=doc.elements['.//coordinates'].text.to_s.split(',')
+
+          #basics
+          res.lat=coordinates[1]
+          res.lng=coordinates[0]
+          res.country_code=doc.elements['.//CountryNameCode'].text if doc.elements['.//CountryNameCode']
+          res.provider='google'
 
-      # extracts a single geoloc from a //placemark element in the google results xml
-      def self.extract_placemark(doc)
-        res = GeoLoc.new
-        coordinates=doc.elements['.//coordinates'].text.to_s.split(',')
+          #extended -- false if not not available
+          res.city = doc.elements['.//LocalityName'].text if doc.elements['.//LocalityName']
+          res.state = doc.elements['.//AdministrativeAreaName'].text if doc.elements['.//AdministrativeAreaName']
+          res.province = doc.elements['.//SubAdministrativeAreaName'].text if doc.elements['.//SubAdministrativeAreaName']
+          res.full_address = doc.elements['.//address'].text if doc.elements['.//address'] # google provides it
+          res.zip = doc.elements['.//PostalCodeNumber'].text if doc.elements['.//PostalCodeNumber']
+          res.street_address = doc.elements['.//ThoroughfareName'].text if doc.elements['.//ThoroughfareName']
+          res.country = doc.elements['.//CountryName'].text if doc.elements['.//CountryName']
+          res.district = doc.elements['.//DependentLocalityName'].text if doc.elements['.//DependentLocalityName']
+          # Translate accuracy into Yahoo-style token address, street, zip, zip+4, city, state, country
+          # For Google, 1=low accuracy, 8=high accuracy
+          address_details=doc.elements['.//*[local-name() = "AddressDetails"]']
+          res.accuracy = address_details ? address_details.attributes['Accuracy'].to_i : 0
+          res.precision=%w{unknown country state state city zip zip+4 street address building}[res.accuracy]
 
-        #basics
-        res.lat=coordinates[1]
-        res.lng=coordinates[0]
-        res.country_code=doc.elements['.//CountryNameCode'].text if doc.elements['.//CountryNameCode']
-        res.provider='google'
+          # google returns a set of suggested boundaries for the geocoded result
+          if suggested_bounds = doc.elements['//LatLonBox']
+            res.suggested_bounds = Bounds.normalize(
+                                    [suggested_bounds.attributes['south'], suggested_bounds.attributes['west']],
+                                    [suggested_bounds.attributes['north'], suggested_bounds.attributes['east']])
+          end
 
-        #extended -- false if not not available
-        res.city = doc.elements['.//LocalityName'].text if doc.elements['.//LocalityName']
-        res.state = doc.elements['.//AdministrativeAreaName'].text if doc.elements['.//AdministrativeAreaName']
-        res.province = doc.elements['.//SubAdministrativeAreaName'].text if doc.elements['.//SubAdministrativeAreaName']
-        res.full_address = doc.elements['.//address'].text if doc.elements['.//address'] # google provides it
-        res.zip = doc.elements['.//PostalCodeNumber'].text if doc.elements['.//PostalCodeNumber']
-        res.street_address = doc.elements['.//ThoroughfareName'].text if doc.elements['.//ThoroughfareName']
-        res.country = doc.elements['.//CountryName'].text if doc.elements['.//CountryName']
-        res.district = doc.elements['.//DependentLocalityName'].text if doc.elements['.//DependentLocalityName']
-        # Translate accuracy into Yahoo-style token address, street, zip, zip+4, city, state, country
-        # For Google, 1=low accuracy, 8=high accuracy
-        address_details=doc.elements['.//*[local-name() = "AddressDetails"]']
-        res.accuracy = address_details ? address_details.attributes['Accuracy'].to_i : 0
-        res.precision=%w{unknown country state state city zip zip+4 street address building}[res.accuracy]
+          res.success=true
 
-        # google returns a set of suggested boundaries for the geocoded result
-        if suggested_bounds = doc.elements['//LatLonBox']
-          res.suggested_bounds = Bounds.normalize(
-                                  [suggested_bounds.attributes['south'], suggested_bounds.attributes['west']],
-                                  [suggested_bounds.attributes['north'], suggested_bounds.attributes['east']])
+          return res
         end
 
-        res.success=true
-
-        return res
-      end
     end
   end
 end