geo_pack 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/README.md

@@ -0,0 +1,79 @@
+#geo_pack#
+
+Geo related services.
+
+##Usage##
+
+First create an instance passing the configuration file path to the constructor:
+
+    geo_pack = GeoPack.new("config.yml")
+
+The configuration file contains this structure:
+
+    urbanmapping:
+      neighborhoods_apikey: jwncnt4vgs8xarc7pvap2ra7
+      secret: RRGxwfEn
+    zillow:
+      zwsid: X1-ZW3mlz1cqh8sej_1y8f9
+
+Now you can transform an address into a normalized address with its coordinates, neighborhood with its coordinates/bounding box, city and state like this:
+
+    geo_pack.get_location("2114 bigelow Avenue , seattle")
+    =>
+    {
+      :state => { :name => "WA"},
+      :city => { :name => "Seattle"},
+      :neighborhood => { :name=>"Queen Anne", :geom=>[[47.617989, -122.378464], [47.656792, -122.34182]]},
+      :address => { :name => "2114 Bigelow Ave N, Seattle, WA 98109, USA", :geom => [47.637936, -122.34813]}
+    }
+
+The address passed to get_location is strong enough to support weakly specified addresses. For example we can search just by zip code:
+
+    geo_pack.get_location("90210")
+    => 
+    {
+      :state=>{:name=>"CA"},
+      :city=>{:name=>"Beverly Hills"},
+      :neighborhood=>{:geom=>[[34.088879, -118.43866], [34.129559, -118.373741]], :name=>"Beverly Crest"},
+      :address=>{:geom=>[34.1030032, -118.4104684], :name=>"Beverly Hills, CA 90210, USA"}
+    }
+
+If the address could not be found an empty hash will be returned:
+
+    geo_pack.get_location("supercalifragilisticexpialidocious address")
+    =>
+    {}
+
+The neighborhood search, which uses an extra stack of api services, can be excluded if you don't need it and want faster results:
+
+    geo_pack.get_location("90210", :exclude => :neighborhood)
+    =>
+    {
+      :state=>{:name=>"CA"},
+      :city=>{:name=>"Beverly Hills"},
+      :address=>{:geom=>[34.1030032, -118.4104684], :name=>"Beverly Hills, CA 90210, USA"}
+    }
+
+Zillow lookups are also supported:
+
+    geo_pack.get_property_details("2114 Bigelow, seattle")
+    =>
+    {
+      :error=>false,
+      :data=> {
+        :year_built=>1920,
+        :housing_type=>"house",
+        :square_footage=>"3470"
+       },
+      :message=>"Request successfully processed"
+    }
+
+In case of error you'll get:
+
+    geo_pack.get_property_details("Somewhere")
+    =>
+    {
+      :error=>true,
+      :data=>{},
+      :message=>"Error: no exact match found for input address"
+    }

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "geo_pack"
+    gem.summary = %Q{Geo related services"}
+    gem.description = %Q{Geo related services"}
+    gem.homepage = "http://github.com/efficiency20/geo_pack"
+    gem.authors = ["Efficiency 2.0"]
+    gem.add_dependency "geokit", "= 1.5.0"
+    gem.add_dependency "geoplanet", "= 0.2.3"
+    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "geo_pack #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/geo_pack.rb

@@ -0,0 +1,73 @@
+require 'geokit'
+require 'geoplanet'
+require 'geo_pack/urban_mapping'
+require 'geo_pack/geo_names'
+require 'geo_pack/zillower'
+
+class GeoPack
+  Geokit::Geocoders::provider_order = [:google, :us, :yahoo, :geonames]
+  GeoPlanet.appid = 'aaaaaaaaaaaaaaaaaaaanobodyatyahoochecksthisaaaaaaaaaaaaaaaaaaaaa'
+
+  def initialize(config_file_path)
+    config = YAML.load_file(config_file_path)
+    @urban_mapping = UrbanMapping.new(config["urbanmapping"]["neighborhoods_apikey"], config["urbanmapping"]["secret"])
+    @geo_names = GeoNames.new
+    @zillower = Zillower.new(config["zillow"]["zwsid"])
+  end
+
+  def get_location(address, options = {})
+    location = {}
+    location.merge!(get_address_city_and_state(address, options))
+    return location if options[:exclude] == :neighborhood || location.empty?
+    location.merge!(get_neighborhood(location[:address][:geom]))
+    location
+  end
+
+  def get_property_details(address)
+    geokit_result = GeoKit::Geocoders::MultiGeocoder.geocode(address)
+    @zillower.lookup_address(:address => geokit_result.street_address, :citystatezip => "#{geokit_result.city}, #{geokit_result.state}, #{geokit_result.zip}")
+  end
+
+private
+  def get_address_city_and_state(address, options)
+    location = {}
+    geokit_result = GeoKit::Geocoders::MultiGeocoder.geocode(address)
+    if geokit_result.success?
+      location[:address] = { :name => geokit_result.full_address, :geom => [geokit_result.lat, geokit_result.lng]}
+      location[:city] = { :name => geokit_result.city}
+      location[:state] = { :name => geokit_result.state}
+    end
+    location
+  end
+
+  def get_neighborhood(geom)
+    location = {}
+    lat, lng = geom
+    urban_mapping_result = @urban_mapping.query(:method => "getNeighborhoodsByLatLng", :lat => lat, :lng => lng)
+
+    unless urban_mapping_result.empty?
+      geom_or_bounding_box = get_bounding_box(urban_mapping_result) || geom
+      location[:neighborhood] = {:name => urban_mapping_result.first["name"], :geom => geom_or_bounding_box}
+    else
+      geo_names_result = @geo_names.query(:method => 'findNearbyPlaceName', :lat => lat, :lng => lng)
+      unless geo_names_result.empty?
+        geom_or_bounding_box = get_bounding_box(geo_names_result) || geom
+        location[:neighborhood] = {:name => geo_names_result.first["name"], :geom => geom_or_bounding_box}
+      end
+    end
+
+    location
+  end
+
+  def get_bounding_box(api_result)
+    name = api_result.first["name"]
+    city = api_result.first["city"]
+    state = api_result.first["state"]
+
+    if geo_planet_response = GeoPlanet::Place.search("#{name}, #{city}, #{state}, US")
+      geo_planet_response.first.bounding_box
+    else
+      nil
+    end
+  end
+end

data/lib/geo_pack/geo_names.rb

@@ -0,0 +1,116 @@
+#geonames rest api
+
+require 'rubygems'
+require 'httparty'
+require 'digest/md5'
+
+
+#$ curl 'http://ws.geonames.org/findNearbyPlaceNameJSON?lat=40.871992&lng=-124.087883&style=full'
+#{"geonames":[{"adminCode2":"023","countryName":"United States","adminCode1":"CA","fclName":"city, village,...","elevation":7,"countryCode":"US","lng":-124.0828396,"adminName2":"Humboldt County","adminName3":"","fcodeName":"populated place","distance":"0.7419","adminName4":"","timezone":{"dstOffset":-7,"gmtOffset":-8,"timeZoneId":"America/Los_Angeles"},"fcl":"P","name":"Arcata","fcode":"PPL","geonameId":5558953,"lat":40.8665166,"population":17199,"adminName1":"California"}]}
+#geoname = um.query_geonames(:method => 'findNearbyPlaceName',:lat => 40.871992, :lng => -124.087883, :style => 'full' )
+
+
+class GeoPack
+  class GeoNames
+    include HTTParty
+    format :json
+
+    GEONAMES_API = {
+      'findNearbyPlaceName' => [:lat, :lng],
+      'postalCodeSearch' => [:postalcode]
+    }
+
+    def method_missing(method, *args)
+      if GEONAMES_API.has_key?( method )
+        query(method, *args)
+      else
+        super
+      end
+    end
+
+    def self.query(options= {})
+      geonames = self.new(options[:apikey])
+      return geonames.query(options)
+    end
+
+
+    def query(options={})
+      check_requirements(options)
+      options.merge!({:style => 'full'}) unless options.has_key? :style
+      options = munge_key_names(options)
+      method = options.delete(:method)
+      results = munge_results( GeoNames.get("http://ws.geonames.org/" + method + "JSON", :query => options) )
+
+      if results.kind_of?(Hash) && results.has_key?('status')
+        #throw exception here because there was an error
+        return[]
+      else
+        return results
+      end
+    end
+
+    #so we can use prettier options than geonames provides
+    def munge_key_names(options={})
+      options_mapping = {
+        'latitude' => 'lat',
+        'longitude' => 'lng',
+        'long' => 'lng',
+        'zip' => 'postalcode',
+        'zipcode' => 'postalcode',
+        'zip_code' => 'postalcode',
+        'postalCode' => 'postalcode'}
+
+
+        options.map do |key,value|
+          if options_mapping.has_key? key.to_s
+            options[options_mapping[key.to_s]] = options.delete key
+          end
+        end
+
+        options[:countryBias] = 'US' if options[:method] == 'postalCodeSearch'
+
+        return options
+    end
+
+    def munge_results(results)
+      results = results["geonames"] if results.kind_of?(Hash) && results.has_key?("geonames")
+      results = results["postalCodes"] if results.kind_of?(Hash) && results.has_key?("postalCodes")
+      return [] if results.nil?
+
+      return munge_single_result(results) if results.kind_of?(Hash)
+
+      results_array = []
+      results.each {|result| results_array<<munge_single_result(result)}
+
+      return results_array
+    end
+
+    def munge_single_result(results)
+      mapping = {
+        'latitude' => 'lat',
+        'longitude' => 'lng',
+        'long' => 'lng',
+        'zip' => 'postalcode',
+        'zipcode' => 'postalcode',
+        'neighborhoodId' => 'neighborhood_id',
+        'adminCode1' => 'state',
+        'name' => 'city',
+        'geonameId' => 'id',
+        'placeName' => 'name'}
+
+        results.map do |key,value|
+          if mapping.has_key? key.to_s
+            results[mapping[key]] = results[ key ]
+          end
+        end
+
+        return results
+    end
+
+    def check_requirements(options)
+      #raise( 'apikey required for geonames' ) if @apikey.nil?
+      raise( 'method required for geonames' ) if options[:method].nil?
+      raise( "method #{options[:method]} geonames" ) unless GEONAMES_API.has_key?( options[:method] )
+    end
+  end
+end

data/lib/geo_pack/rillow.rb

@@ -0,0 +1,261 @@
+#!/usr/bin/ruby
+require 'net/http'
+require 'uri'
+require 'xmlsimple'
+require 'cgi'
+require 'geo_pack/rillow_helper'
+
+# This api is created by Leo Chan on 10/29/2007.
+# There is no license requirement.  Use it or copy any part of the code that you want to use.
+# Use it at your own risk.  I am not liable for anything.  Just want to share what I wrote.  Hopefully you will find it useful.
+# Rillow is a simple ruby wrapper to zillow webservice api: http://www.zillow.com/howto/api/APIOverview.htm
+# It does the web service call and gets the result back for you.  You don't have to know about the url request, url encoding or 
+# parsing the result.  The result object is in hash/array format.  So no need to parsse xml.
+# You will need to register with zillow to get the Zillow Web Service Identifier first.
+# You will need to pass the Zillow Web Service Identifier to the constructor.
+# This wrapper depends on xmlsimple. 
+#
+# Example:
+# rillow = Rillow.new('your-zillow-service identifier')
+# result = rillow.get_search_results(:address => '2114 Bigelow Ave', :citystatezip => 'Seattle WA')
+# result.to_hash
+# result.find_attribute 'valudationRange'
+class GeoPack
+  class Rillow
+    attr_accessor :webservice_url, :zwsid
+
+    VALID_METHODS = {
+      :get_search_results => 'GetSearchResults',
+      :get_zestimate => 'GetZestimate',
+      :get_chart => 'GetChart',
+      :get_region_chart => 'GetRegionChart',
+      :get_demographics => 'GetDemographics',
+      :get_comps => "GetComps",
+      :get_region_children => 'GetRegionChildren',
+      :get_ratesummary => 'GetRateSummary',
+      :get_monthly_payments => 'GetMonthlyPayments',
+      :get_deep_search_results => 'GetDeepSearchResults',
+      :get_property_details => 'GetDeepSearchResults',
+      :get_deep_comps => 'GetDeepComps',
+      :get_region_postings => 'GetRegionPostings',
+      :get_updated_property_details => 'GetUpdatedPropertyDetails'
+    }
+
+
+    # rillow = Rillow.new('your-zillow-service identifier')
+    def initialize(my_zwsid, my_webservice_url= 'http://www.zillow.com/webservice/')
+      @zwsid= my_zwsid
+
+      @webservice_url = my_webservice_url
+    end
+
+    def method_missing(method, *args)
+      super(method, args) unless VALID_METHODS.has_key? method
+      fetch_from_zillow(VALID_METHODS[method], args)
+    end
+
+    #The get_search_results finds a property for a specified address. 
+    #The content returned contains the address for the property or properties as well as the Zillow Property ID (ZPID) and current Zestimate. 
+    #It also includes the date the Zestimate was computed, a valuation range and the Zestimate ranking for the property within its ZIP code. 
+    #If no exact address match for a property is found, a list of closely matching properties is returned. 
+    #See: http://www.zillow.com/howto/api/GetSearchResults.htm
+    # parameter:
+    # address  street address
+    # citystatezip city&state or zip code
+    #Example: 
+    # rillow = Rillow.new('your-zillow-service identifier')
+    # result = rillow.get_search_results(:address => '2114 Bigelow Ave', :citystatezip => 'Seattle, WA')
+    # result.to_hash
+
+    #For a specified Zillow property identifier (zpid), the get_zestimate returns:
+    #1.  The most recent property Zestimate
+    #2.  The date the Zestimate was computed
+    #3.  The valuation range
+    #4.  The Zestimate ranking within the property's ZIP code.
+    #5.  The full property address and geographic location (latitude/longitude) and a set of identifiers that uniquely represent the region (ZIP code, city, county & state) in which the property exists.
+    #The GetZestimate API will only surface properties for which a Zestimate exists. 
+    #If a request is made for a property that has no Zestimate, an error code is returned. 
+    #See: http://www.zillow.com/howto/api/GetZestimate.htm
+    #parameter:
+    # zpid zillow property id
+    #Example: 
+    # rillow = Rillow.new('your-zillow-service identifier')
+    # result = rillow.get_zestimate(:zpid => '48749425')
+    # result.to_hash
+
+
+    #The get_chart api generates a URL for an image file that displays historical Zestimates for a specific property. 
+    #The API accepts as input the Zillow Property ID as well as a chart type: either percentage or dollar value change. 
+    #Optionally, the API accepts width and height parameters that constrain the size of the image. 
+    #The historical data can be for the past 1 year, 5 years or 10 years.
+    #See:  http://www.zillow.com/howto/api/GetChart.htm
+    #parameters:
+    #require: 
+    # zpid: The Zillow Property ID for the property; the parameter type is an integer 
+    # unit_type: A string value that specifies whether to show the percent change, parameter value of "percent," 
+    # or dollar change, parameter value of "dollar"
+    #options: 
+    # :width =>  width of the generated graph. The value must be between 200 and 600, inclusive
+    # :height=>  height of the generated graph. The value must be between 100 and 300, inclusive. 
+    # :chart_duration => The duration of past data that needs to be shown in the chart. Valid values are "1year", 
+    # "5years" and "10years". If unspecified, the value defaults to "1year"
+    #Example: 
+    # rillow = Rillow.new('your-zillow-service identifier')
+    # result = rillow.get_chart(:zpid => '48749425',:unit_type => 'percent',:width=>300, :height=>150, :chart_duration=>'5years')
+    # result.to_hash
+
+    #The get_region_chart generates a URL for an image file that displays the historical Zestimates for a specific geographic region. 
+    #The API accepts as input the name of the region as well as a chart type: either percentage or dollar value change. #
+    #Optionally, the API accepts width and height parameters that constrain the size of the image. 
+    #The historical data can be for the past 1 year, 5 years or 10 years.
+    #see: http://www.zillow.com/howto/api/GetRegionChart.htm
+    #parameters:
+    #require: 
+    # unit_type: A string value that specifies whether to show the percent change, parameter value of "percent," 
+    # or dollar change, parameter value of "dollar"
+    #options: 
+    # :city=> name of the city
+    # :state=> The two-letter abbreviation for a state
+    # :zip=> The 5-digit ZIP code
+    # :width=>  width of the generated graph. The value must be between 200 and 600, inclusive
+    # :height=>  height of the generated graph. The value must be between 100 and 300, inclusive. 
+    # :chart_duration => The duration of past data that needs to be shown in the chart. Valid values are "1year", 
+    # "5years" and "10years". If unspecified, the value defaults to "1year"
+    #Example: 
+    # rillow = Rillow.new('your-zillow-service identifier')
+    # result = rillow.get_region_chart(:unit_type =>'percent',:city=>'seattle',:state=>'WA',:width=>300, :height=>150, :chart_duration=>'5years')
+    # result.to_hash
+
+    #For a specified region, the GetDemographics API returns a set of demographic data which includes:
+    # * A URL linking to the corresponding demographics page at Zillow.com
+    # * Census Information (i.e. total population, median household income, recent homeowners, etc)
+    # * Age Distributions
+    # * Who Lives Here (if available for the region)
+    # * What's Unique About the People (if available for the region)
+    # A region can be specified either through its respective Region ID or by providing one to three parameters: 
+    # state, city, neighborhood. The neighborhood parameter can be omitted if demographic data on a city is desired. 
+    # The state and city parameter are always required.
+    # see: http://www.zillow.com/howto/api/GetDemographics.htm
+    # parameters:
+    # :rid => region id
+    # :city=> name of the city
+    # :state=> The two-letter abbreviation for a state
+    # :neighborhood=> The neighborhood of the region to retrieve data
+    #Example: 
+    # rillow = Rillow.new('your-zillow-service identifier')
+    # result = rillow.get_demographics(:city=>'seattle',:state=>'WA',:neighborhood=>'Ballard')
+    # result.to_hash
+
+    # For a specified region, the get_region_children API returns a list of subregions with the following information:
+    # * Subregion Type
+    # * Region IDs
+    # * Region Names
+    # * Latitudes and Longitudes
+    #A region can be specified at various levels of the region hierarchy. 
+    #An optional childtype parameter can also be specified to return subregions of a specific type.
+    #Allowable region types include: 
+    #country, state, county, and city. Country and county are optional parameters unless they are the region to be specified.
+    #Possible childtype parameters include: state, county, city, zipcode, and neighborhood. 
+    #Any childtype parameter can be specified as long as the childtype parameter is a subregion type 
+    #(i.e.. you cannot retrieve the subregion counties of a city). 
+    #The only exception is that only subregion state can be specified for a country (otherwise it returns too many results).
+    #
+    #Childtype parameter is optional and defaults to types dependent on the specified region type: 
+    #country defaults to return subregions of type state, state -> county, county -> city, city -> zipcode.
+    #see: http://www.zillow.com/howto/api/GetRegionChildren.htm
+    #parameters:
+    # :city=> name of the city. The city of the region to retrieve subregions from.
+    # :state=> The two-letter abbreviation for a state. The state of the region to retrieve subregions from.
+    # :country=> The country of the region to retrieve subregions from.
+    # :rid=> The regionId of the region to retrieve subregions from.
+    # :childtype=> The type of subregions to retrieve (available types: state, county, city, zipcode, and neighborhood)
+    # Example:
+    # rillow = Rillow.new('your-zillow-service identifier')
+    # result = rillow.get_region_children(:city=>'seattle',:state=>'WA',:country=>'united states',:childtype=>'neighborhood')
+    # result.to_hash
+
+    #The get_comps returns a list of comparable recent sales for a specified property. 
+    #The result set returned contains the address, Zillow property identifier, and Zestimate for the comparable properties and 
+    #the principal property for which the comparables are being retrieved.
+    #see: http://www.zillow.com/howto/api/GetComps.htm
+    #parameters:
+    #zpid The Zillow Property ID for the property for which to obtain information; the parameter type is an integer
+    #count The number of comparable recent sales to obtain
+    # Examples:
+    # rillow = Rillow.new('your-zillow-service identifier')
+    # result = rillow.get_comps('48749425',5)
+    # result.to_hash
+
+    #The get_deep_search_results finds a property for a specified address 
+    #(or, if no exact match for a property is found, a list of closely matching properties is returned). 
+    #The result set returned contains the full address(s), zpid and Zestimate data that is provided by the get_search_results API. 
+    #Moreover, this API call also gives rich property data like lot size, year built, bath/beds, last sale details etc.
+    #see: http://www.zillow.com/howto/api/GetDeepSearchResults.htm
+    # parameter:
+    # address  street address
+    # citystatezip city&state or zip code
+    #Example: 
+    # rillow = Rillow.new('your-zillow-service identifier')
+    # result = rillow.get_deep_search_results('2114 Bigelow Ave','Seattle, WA')
+    # result.to_hash
+
+    #The get_deep_comps api returns a list of comparable recent sales for a specified property. 
+    #The result set returned contains the address, Zillow property identifier, 
+    #and Zestimate for the comparable properties and the principal property for which the comparables are being retrieved. 
+    #This API call also returns rich property data for the comparables.
+    #see: http://www.zillow.com/howto/api/GetDeepComps.htm
+    #parameters:
+    #zpid The Zillow Property ID for the property for which to obtain information; the parameter type is an integer
+    #count The number of comparable recent sales to obtain
+    # Examples:
+    # rillow = Rillow.new('your-zillow-service identifier')
+    # result = rillow.get_deep_comps('48749425',5)
+    # result.to_hash
+
+    # Get monthly mortgage payments.
+    # price is required.
+    # optional parameters:
+    # :down => down payment, as an integer, representing the percent.  If ommitted, 20% is assumed.
+    # :dollarsdown => down payment in dollars
+    # :zip => location of property, used to calculate tax and insurance estimate, if known.
+    # see: http://www.zillow.com/howto/api/GetMonthlyPayments.htm
+    # Example: 
+    # rillow = Rillow.new('your-zillow-service identifier')
+    # result = rillow.get_monthlypayments(350000, {:down => 15, :zip => '33432'})
+    # result.to_hash
+
+    # Get current mortgage rates.
+    # No params.
+    # see: http://www.zillow.com/howto/api/GetRateSummary.htm
+    # Example: 
+    # rillow = Rillow.new('your-zillow-service identifier')
+    # result = rillow.get_ratesummary
+    # result.to_hash
+
+    private
+    def fetch_from_zillow(method,options) 
+      options = options[0] if options.kind_of? Array
+      options.merge!({'zws-id', zwsid})
+      fetch_result [webservice_url, method, '.htm?', to_arguments(options)].join
+    end
+
+    def to_arguments(options)
+      options.map {|k,v| "#{clean_param_key(k)}=#{CGI.escape(v.to_s)}" }.join("&")
+    end
+
+    def clean_param_key(param_key)
+      return 'chartDuration' if param_key == :chart_duration
+      param_key.to_s.gsub('_','-')
+    end
+
+    def fetch_result(url_s)
+      url = URI.parse(url_s)
+      res = Net::HTTP.get_response(url)
+      doc = XmlSimple.xml_in res.body
+      class<<doc
+        include RillowHelper
+      end
+      return doc
+    end
+  end
+end

data/lib/geo_pack/rillow_helper.rb

@@ -0,0 +1,34 @@
+class GeoPack
+  module RillowHelper
+    # The find_attribute helper method is to provide a easy eay to  find a attribute within the hash and array
+    # Examples: 
+    # rillow = Rillow.new ('your-zillow-service identifier')
+    # result = rillow.get_search_results('2114 Bigelow Ave','Seattle, WA')
+    # valuationRange = result.find_attribute 'valuationRange'
+    def find_attribute(key,obj=nil)
+      if obj==nil then 
+        obj=self
+      end
+      if obj.is_a? Hash then
+        obj.each { |k,v|
+          if k==key then
+            return v
+          else
+            result = find_attribute(key,v)
+            if result != nil then
+              return result
+            end
+          end
+        }
+      elsif obj.is_a? Array then
+        obj.each {|o| 
+          result  = find_attribute(key,o)
+          if result !=  nil then
+            return result       
+          end 
+        }
+      end
+      return nil
+    end
+  end
+end

data/lib/geo_pack/urban_mapping.rb

@@ -0,0 +1,88 @@
+#urbanmapping rest api
+
+require 'rubygems'
+require 'httparty'
+require 'digest/md5'
+
+class GeoPack
+  class UrbanMapping
+    include HTTParty
+    format :json
+
+    URBAN_MAPPING_API = {
+      'getNeighborhoodsByLatLng' => [:lat, :lng],
+      'getNearestNeighborhood'   => [:lat, :lng],
+      'getNeighborhoodsByExtent' => [:swlat, :swlng, :nelat, :nelng],
+      'getNeighborhoodsByAddress'=> [:street, :city, :state, :country],
+      'getNeighborhoodsByCityStateCountry' => [:city, :state, :country],
+      'getNeighborhoodsByPostalCode' => [:postalcode],
+      'getNeighborhoodsByName' => [:name],
+      'getNeighborhoodDetail' => [:neighborhoodId],
+      'getNeighborhoodRelationships' => [:neighborhoodId]
+    }
+
+    def initialize(apikey, secret)
+      @apikey = apikey
+      @secret = secret
+    end
+
+    def method_missing(method, *args)
+      if URBAN_MAPPING_API.has_key?( method )
+        query(method, *args)
+      else
+        super
+      end
+    end
+
+    def self.query(options= {})
+      um = self.new(options[:apikey])
+      return um.query(options)
+    end
+
+
+    def query(options={})
+      check_requirements(options)
+
+      method = options.delete(:method)
+      options.merge!({:apikey => @apikey})
+      options.merge!({:sig => generate_sig})
+
+      UrbanMapping.get("http://api1.urbanmapping.com/neighborhoods/rest/" + method, :query => options)
+    end
+
+    #so we can use prettier options than urbanmapping provides
+    def munge_key_names(options={})
+      options_mapping = {
+        :latitude => :lat,
+        :longitude => :lng,
+        :long => :lng,
+        :zip => :postalcode,
+        :zipcode => :postalcode,
+        :neighborhood_id => :neighborhoodId}
+
+        options.map do |key,value|
+          if options_mapping.has_key? key
+            options[options_mapping[key]] = options.delete key
+          end
+        end
+
+        return options
+    end
+
+    def check_requirements(options)
+      raise( 'apikey required for urbanmapping' ) if @apikey.nil?
+      raise( 'method required for urbanmapping' ) if options[:method].nil?
+      raise( "method #{options[:method]} urbanmapping" ) unless URBAN_MAPPING_API.has_key?( options[:method] )
+      #missing_params = []
+      #URBAN_MAPPING_API[options[:method]].each {|param| missing_params<<param unless options.has_key?(param) }
+      #raise( "#{options[:method]} requires #{missing_params.join(", ")} parameters" ) unless missing_params.empty?
+    end
+
+    def generate_sig
+      md5_input_string = @apikey + @secret + Time.now.to_i.to_s
+      d = Digest::MD5.new
+
+      return d.hexdigest(md5_input_string)
+    end
+  end
+end

data/lib/geo_pack/zillower.rb

@@ -0,0 +1,111 @@
+require 'geo_pack/rillow'
+
+class GeoPack
+  class Zillower
+    def initialize(zwsid)
+      @zwsid = zwsid
+    end
+
+    def lookup_address(options)
+      rillow = Rillow.new(@zwsid)
+      @base_result    = rillow.get_property_details options
+      @message        = @base_result['message'].first['text'].first
+      zpid            = @base_result.find_attribute('zpid')
+      @updated_result = rillow.get_updated_property_details({:zpid => zpid}) if zpid
+      result = {
+        :message => @message,
+        :error => failure?,
+        :data => {}
+      }
+
+      unless result[:error]
+        {
+          :rooms => get_zillow_rooms,
+          :year_built => get_zillow_year,
+          :housing_type => get_zillow_housing_type,
+          :square_footage => get_zillow_square_footage
+        }.inject(result[:data]){|h, (k,v)| h[k] = v if v; h }
+      end
+
+      result
+    end
+
+  protected
+    def failure?
+      !!(@message =~ /error/i)
+    end
+
+    def get_zillow_rooms
+      rooms = @updated_result.find_attribute('numRooms') || @base_result.find_attribute('numRooms')
+      rooms.first if rooms.kind_of? Array
+    end
+
+    def get_zillow_square_footage
+      finishedSqFt = @updated_result.find_attribute('finishedSqFt') || @base_result.find_attribute('finishedSqFt')
+      finishedSqFt.first if finishedSqFt.kind_of? Array 
+    end
+
+    def get_zillow_year
+      year_built = @updated_result.find_attribute('yearBuilt') || @base_result.find_attribute('yearBuilt')
+      year_built = year_built.first if year_built.kind_of? Array
+
+      #remember to remove this once the methods from the block comment below is moved to the client
+      map_year_to_range(year_built)
+    end
+
+    ####################
+    # This should be moved to the geo_pack client
+    def home_year_built
+      [
+        ['before 1940',  1920],
+        ['1940 to 1949',  1945],
+        ['1950 to 1959',  1955],
+        ['1960 to 1969',  1965],
+        ['1970 to 1979',  1975],
+        ['1980 to 1984',  1982],
+        ['1985 to 1989',  1987],
+        ['1990 to 1994',  1992],
+        ['1995 to 1999',  1997],
+        ['2000 or newer', 2002]
+      ]
+    end
+
+    def map_year_to_range(year_built)
+      option_year_built = nil
+      if year_built
+        home_year_built.each do |option, value|
+          option.match(/^(\d{4}) (to|or) (\d*)/)
+          end_date = $3.to_i == 0 ? 2100 : $3.to_i
+          if ($1.to_i..end_date).include? year_built.to_i
+            option_year_built = value
+          end
+        end
+        if option_year_built.nil?
+          option_year_built = year_built
+        end
+      end
+      option_year_built
+    end
+    ##################################
+
+    def get_zillow_housing_type
+      unit_type = @updated_result.find_attribute('useCode') || @base_result.find_attribute('useCode')
+      case unit_type.first
+      when 'Single family' : 'house'
+      when 'SingleFamily' : 'house'
+      when 'Unknown' : nil
+      when 'Duplex' : 'small_apartment'
+      when 'Triplex' : 'small_apartment'
+      when 'Quadruplex' : 'small_apartment'
+      when 'Condominium' : nil
+      when 'Cooperative' : nil
+      when 'Mobile' : 'mobile'
+      when 'MultiFamily2To4' : 'small_apartment'
+      when 'MultiFamily5Plus' : 'large_apartment'
+      when 'Timeshare' : nil
+      when 'Miscellaneous' : nil
+      when 'VacantResidentialLand' : nil
+      end if unit_type.kind_of? Array
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'geo_pack'
+
+class Test::Unit::TestCase
+end

data/test/test_config.yml

@@ -0,0 +1,5 @@
+urbanmapping:
+  neighborhoods_apikey: jwncnvgs8xarct47pvap2ra7
+  secret: RRwfEnGx
+zillow:
+  zwsid: X1-ZWz1cqh83mlsej_1y8f9

data/test/test_geo_pack.rb

@@ -0,0 +1,59 @@
+require 'helper'
+
+#This is not stubbed on purpose, this are integration tests. We want it to break when any api is updated
+class TestGeoPack < Test::Unit::TestCase
+  context "GeoPack" do
+    setup do
+      @geo_pack = GeoPack.new("#{File.dirname(__FILE__)}/test_config.yml")
+    end
+
+    should "get a complete location from a user provided address" do
+      location = @geo_pack.get_location("2114 bigelow Avenue , seattle")
+      assert_equal({
+        :state => { :name => "WA"},
+        :city => { :name => "Seattle"},
+        :neighborhood => { :name=>"Queen Anne", :geom=>[[47.617989, -122.378464], [47.656792, -122.34182]]},
+        :address => { :name => "2114 Bigelow Ave N, Seattle, WA 98109, USA", :geom => [47.637936, -122.34813]}
+      }, location)
+    end
+
+    should "get an empty location from an invalid address" do
+      location = @geo_pack.get_location("Foruncotolundo")
+      assert_equal({}, location)
+    end
+
+    should "be possible to exclude neighborhood search" do
+      location = @geo_pack.get_location("2114 bigelow Avenue , seattle", :exclude => :neighborhood)
+      assert_equal({
+        :state => { :name => "WA"},
+        :city => { :name => "Seattle"},
+        :address => { :name => "2114 Bigelow Ave N, Seattle, WA 98109, USA", :geom => [47.637936, -122.34813]}
+      }, location)
+    end
+
+    should "fallback to geo_names when urbanmapping fails finding a neighborhood" do
+      location = @geo_pack.get_location("Aetna Road and Cottage Creek Road")
+      assert_equal({
+        :state=>{:name=>"KS"},
+        :city=>{:name=>"Lake City"},
+        :neighborhood=> {:name=>"Aetna", :geom=>[[37.064449, -98.975754], [37.08263, -98.952972]]},
+        :address=> {:name=>"Aetna Rd & Cottage Creek Rd, Lake City, KS 67071, USA", :geom=>[37.0858864, -98.964822]}
+      }, location)
+    end
+
+    should "return zillow data from existent address" do
+      zillow_response = @geo_pack.get_property_details("2114 Bigelow, seattle,  wA")
+      assert_equal({
+        :housing_type => "house",
+        :square_footage => "3470",
+        :year_built => 1920
+      }, zillow_response[:data])
+      assert !zillow_response[:error]
+    end
+
+    should "return zillow error from a non existent address" do
+      zillow_response = @geo_pack.get_property_details("asfsafdadsf ")
+      assert zillow_response[:error]
+    end
+  end
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification 
+name: geo_pack
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Efficiency 2.0
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-28 00:00:00 -02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: geokit
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 5
+        - 0
+        version: 1.5.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: geoplanet
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 2
+        - 3
+        version: 0.2.3
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: Geo related services"
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- .document
+- .gitignore
+- README.md
+- Rakefile
+- VERSION
+- lib/geo_pack.rb
+- lib/geo_pack/geo_names.rb
+- lib/geo_pack/rillow.rb
+- lib/geo_pack/rillow_helper.rb
+- lib/geo_pack/urban_mapping.rb
+- lib/geo_pack/zillower.rb
+- test/helper.rb
+- test/test_config.yml
+- test/test_geo_pack.rb
+has_rdoc: true
+homepage: http://github.com/efficiency20/geo_pack
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Geo related services"
+test_files: 
+- test/helper.rb
+- test/test_geo_pack.rb