steflewandowski-geoapi 0.2.1

data/LICENSE

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

data/README

@@ -0,0 +1,156 @@
+= OVERVIEW
+
+  Unfortunately I've decided to 'fail fast' and am giving up on developing this gem:
+  The API isn't yet reliable enough to be able to develop with it - I'm consistently seeing the following:
+  
+  * 504 bad gateway
+  * Connections that remain open
+  * Every other request giving a response, others just time out
+  * Search for user-entities doesn't appear to function (the reason for the app I am working on)
+  
+  Sorry - if anyone wants to pick up where I left off, feel free.
+
+
+
+== Code examples:
+
+  === Setting the API KEY
+  
+  There are three methods for setting the apikey variable which must be sent with all requests. They are:
+  
+  Defining it. Easiest: sets the API Key for use globally. Use this method unless you need multiple API Keys:
+  
+  GEOAPI_KEY = "<my-apikey>"
+  
+  For Rails, put this in environment.rb
+  
+  Using an Environment variable in your shell.
+  
+  ENV["GEOAPI_KEY"] = <my-apikey>
+  
+  Using a 'Client' so you can use more than one API Key per application:
+  
+  @client = GeoAPI::Client.new("<my-apikey>")
+  @entity = GeoAPI::Entity.find_by_id('12345', :client=>@client)
+  
+  @other_client = GeoAPI::Client.new("<my-other-apikey>")
+  @other_entity = GeoAPI::Entity.find_by_id('abcde', :client=>@other_client)
+  
+  You can also send :apikey=>"<my-apikey>" in options for Entity methods:
+  
+  @entity = GeoAPI::Entity.find_by_id('12345', :apikey=>"<my-apikey>")
+  
+  === Creating new Entities
+  
+  @entity = Entity.create_at_lat_lng(:id=>"moseley",:name=>"Moseley", :lat=>52.446506, :lng=>1.888213)
+  
+  Creates a new Entity object at the given latitude/longitude point.
+
+  Other ways of creating entities are not yet supported, but there are Polygon and Multipoint models which need building.
+  
+  == Finding Entities
+  
+  Entity.search(options)
+  Performs and Entity search on the API. Takes a hash of options as documented on GeoAPI.com
+  
+  Entity.find(options)
+  Finds a specific entity - you must pass :guid or :id
+  
+  == Standard CRUD methods
+  
+  Entity.create_at_lat_lng(:id=>"moseley",:name=>"Moseley", :lat=>52.446506, :lng=>1.888213)
+  The easiest way to create a new User Entity - requires an ID and a name.
+  
+  Entity.find_by_id("moseley")
+  Gets an entity and returns the result.
+  
+  Entity.find_by_guid("user-abc123-moseley")
+  An ID is useful for your application, but its actual GUID can also be used to retrieve it.
+  
+  Entity.delete({:id=>"moseley"}) and
+  @entity.delete
+  Destroys an entity, either via guid or id.
+  
+  @entity.update
+  
+  == Eager loading and caching
+  
+  This gem does _not_ eager load all results of a search, nor does it cache them, In order to use an item retrieved from a request, you must first load it. Eg.:
+  
+  @entities = Entity.find(options)
+  
+  @entities.each do |e|
+    e.load
+    puts "#{e.name} is at #{e.lat},#{e.lng}"
+  end
+  
+  === Automatically generated accessor functions for all Views and UserViews
+  
+  @entity.twitter_view
+  @entity.twitter_view_entries
+  
+  @entity.flickr_view
+  @entity.flickr_view_entries 
+  @entity.<my_application>_view_entries
+  
+
+= NOTE
+
+This is still actively being developed and is very alpha.  You can currently conduct a simple search and an MQL query.  The results are returned as ruby hash.
+
+== TODO
+
+- Allow updates to views.
+
+
+= GeoAPI
+
+A Ruby wrapper for the GeoAPI.com APIs.  This gem was almost entirely inspired by the various geoplanet gems.
+
+== Usage
+
+=== Reverse Geocoding:
+
+  require 'geoapi'
+  GeoAPI.apikey = [Your App ID Here]
+  
+  # Location
+  latitude = -27.000
+  longitude = -131.000
+  
+  # Non Required Options
+  optional_parameters = {:radius => '500m', :type => 'POI', "include-parents" => true, :limit => 5, :pretty => true}
+  
+  # Simple Search
+  result = GeoAPI::Query.simple_search(latitude, longitude, optional_parameters)
+
+  # MQL Query
+  q = {:lat => 37.75629, :lon => -122.4213, :radius => "1km", :entity => [{:type => "business", :guid => nil}]}
+  results = GeoAPI::Query.query(q)
+  
+
+
+== REQUIREMENTS:
+
+To use this library, you must have a valid GeoAPI.com API Key. 
+You can get one at http://api.geoapi.com
+
+Additionally, geoapi has the following gem dependencies:
+
+* rest-client >= 0.9
+* json >= 1.1.3
+
+Please note that if you have ActiveSupport::JSON defined (either by
+manually having loaded it or when you use geoapi within a Rails
+application) the json dependency will be ignored and geoapi uses
+ActiveSupport::JSON instead.
+
+== INSTALL:
+
+This gem is hosted on Gemcutter. To install gemcutter:
+  gem install gemcutter
+  gem tumble
+  
+To install geoapi after gemcutter:
+  gem install geoapi
+  

data/geoapi.gemspec

@@ -0,0 +1,36 @@
+Gem::Specification.new do |s|
+  s.name     = "steflewandowski-geoapi"
+  s.version  = "0.2.1"
+  s.date     = "2009-11-10"
+  s.summary  = "A Ruby wrapper for the GeoAPI.com API."
+  s.email    = "stef@stef.io"
+  s.homepage = "http://github.com/steflewandowski/GeoAPI/"
+  s.description = "A Ruby wrapper for the GeoAPI.com API based on the work of Chris Bruce. See http://api.geoapi.com for more information about the API."
+  s.authors  = ["Stef Lewandowski","Chris Bruce"]
+  
+  s.files    = [
+		"README",
+		"LICENSE",
+		"geoapi.gemspec", 
+		"lib/geoapi.rb",
+		"lib/geoapi/geo_object.rb",
+		"lib/geoapi/geometry.rb",
+		"lib/geoapi/query.rb",
+		"lib/geoapi/entity.rb",
+		"lib/geoapi/entry.rb",
+		"lib/geoapi/view.rb",
+		"lib/geoapi/user_view.rb",
+		"lib/geoapi/version.rb",
+    "lib/geoapi/client",
+    "lib/geoapi/neighborhood"
+	]
+  
+  s.add_dependency("rest-client",   [">= 0.9"])
+  s.add_dependency("crack")
+  s.add_dependency("httparty")
+  s.add_dependency("uuidtools")
+
+  
+  s.has_rdoc = false
+  s.rdoc_options = ["--main", "README.rdoc"]
+end

data/lib/geoapi/client.rb

@@ -0,0 +1,32 @@
+module GeoAPI
+  class Client
+
+    # To connect to GeoAPI, either:
+    #
+    # Add export GEOAPI_KEY=<your-api-key> in your .bashrc file
+    # 
+    # @client = GeoAPI::Client.new
+    #
+    # OR
+    #
+    # @client = GeoAPI::Client.new('<your-api-key>')  
+    #
+    # OR set GEOAPI_KEY='<your-api-key>' before including GeoAPI
+    #
+    # @client = GeoAPI::Client.new
+    
+    def initialize(api_key=nil)
+      @api_key = api_key || ENV['GEOAPI_KEY'] || GeoAPI::GEOAPI_KEY
+    end
+    
+    def api_key
+      @api_key
+    end
+    
+    def self.id_from_guid(guid,apikey)
+      id = guid.sub('user-','')
+      id = id.sub("#{apikey}-",'')
+    end
+  
+  end
+end

data/lib/geoapi/entity.rb

@@ -0,0 +1,308 @@
+module GeoAPI
+  class Entity < GeoAPI::GeoObject
+    
+    attr_accessor  :guid, :id, :name, :entity_type, :geom, :url, :views, :userviews, :raw_json, :errors, :shorturl, :raw_json
+        
+
+    alias_method :geometry, :geom
+
+    def latitude
+      @latitude ||= geometry.latitude unless geometry.blank?
+    end
+    
+    def longitude
+      @longitude ||= geometry.longitude unless geometry.blank?
+    end
+    
+    alias_method :lat, :latitude 
+    alias_method :lon, :longitude
+    alias_method :lng, :longitude
+    
+    # Class methods
+    
+    
+    def self.create(params)
+      puts "GEOAPI::Entity.create #{params.to_json}"
+      #required: name, geom
+      #optional: pass id and it will create a new guid for you as user-<apikey>-<id>
+      
+      raise ArgumentError, "A name is required (pass :name in parameters)" unless params.has_key?(:name)
+      raise ArgumentError, "A geometry is required (pass :geom in parameters)" unless params.has_key?(:geom)
+      
+      api_key = self.api_key_from_parameters(params)
+      
+      raise ArgumentError, "An API Key is required" if api_key.blank?
+      
+      id = params[:id] || UUIDTools::UUID.timestamp_create().to_s
+      
+      post_url = "/e" 
+      post_url = "/e/user-#{api_key}-#{id}?apikey=#{api_key}" unless id.blank?
+      post_url = "/e/#{params[:guid]}?apikey=#{api_key}" unless params[:guid].blank?
+
+      puts post_url
+      
+      params.delete(:id) if params.has_key?(:id)
+      params.delete(:guid) if params.has_key?(:guid)
+      
+      begin
+        results = Entity.post(post_url, {:body=> params.to_json}) 
+      rescue
+        raise BadRequest, "There was a problem communicating with the API"
+      end
+      
+      raise BadRequest, results['error'] unless results['error'].blank?
+      
+      #todo the result does not contain the guid, so merge it back in. Possible point of failure here?
+      
+      guid = results['query']['params']['guid']
+      Entity.new(results['result'].merge({'guid'=>guid, 'id'=>GeoAPI::Client.id_from_guid(guid,api_key)}))
+    end
+    
+    def self.destroy(params)
+      
+      puts "GEOAPI::Entity.destroy #{params.to_json}"
+      
+      raise ArgumentError, "An id or guid is required (pass :id or :guid in parameters)"  unless params.has_key?(:id) || params.has_key?(:guid)      
+      
+      raise ArgumentError, "An API Key is required" if api_key.blank?
+      
+      begin
+        unless params[:guid].blank?
+          delete("/e/#{params[:guid]}?apikey=#{api_key}") 
+        else
+          delete("/e/user-#{api_key}-#{params[:id]}?apikey=#{api_key}") unless params[:id].blank?
+        end
+      
+      rescue
+        raise BadRequest, "There was a problem communicating with the API"
+      end
+    end
+    
+    def self.create_at_lat_lng(*args)
+      
+      params = args.extract_options!
+      params = params == {} ? nil : params
+      
+      puts "GEOAPI::Entity.create_at_lat_lng #{params.to_json}"
+      
+      raise ArgumentError, ":lat must be sent as a parameter" unless params.has_key?(:lat)
+      raise ArgumentError, ":lng must be sent as a parameter" unless params.has_key?(:lng)
+      puts "test API key #{api_key}"
+      raise ArgumentError, "An API Key is required" if api_key.blank?
+      
+      p = GeoAPI::Point.new(:lat => params[:lat],:lng => params[:lng])
+      
+      params.delete(:lat)
+      params.delete(:lng)
+
+      self.create(params.merge({:geom=>p}))
+    end
+    
+    def self.find(*args)
+      
+      puts "GEOAPI::Entity.find #{args.to_s}"
+      
+      raise ArgumentError, "First argument must be symbol (:all or :get)" unless args.first.kind_of?(Symbol)
+      
+      params = args.extract_options!
+      params = params == {} ? nil : params
+      
+      api_key = self.api_key_from_parameters(params)
+      
+      raise ArgumentError, "An API Key is required" if api_key.blank?
+      
+      case args.first
+        
+        when :all
+          results = []
+        else
+          results = nil
+          
+          raise ArgumentError, "Arguments should include a :guid or :id" if params[:guid].blank? && params[:id].blank?
+        
+          params[:guid] = "user-#{api_key}-#{the_id}" unless params[:id].blank?
+        
+          response = get("/e/#{params[:guid]}?apikey=#{api_key}")
+          
+          begin
+            
+          rescue
+            raise BadRequest, "There was a problem communicating with the API"
+          end
+        
+          results = Entity.new(response['result'].merge({'guid'=>params[:guid]})) unless response['result'].blank? #the api doesn't return a guid in json?!
+      end
+            
+      results
+      
+    end
+    
+    def self.find_by_id(the_id, options={})
+      puts "GEOAPI::Entity.find_by_id #{the_id}"
+      
+      api_key = self.api_key_from_parameters(options)
+      
+      raise ArgumentError, "An API Key is required" if api_key.blank?
+      
+      self.find(:get, :guid=>"user-#{api_key}-#{the_id}")
+    end
+    
+    def self.find_by_guid(the_guid, options={})
+      puts "GEOAPI::Entity.find_by_guid #{the_guid}"
+      
+      api_key = self.api_key_from_parameters(options)
+      
+      raise ArgumentError, "An API Key is required" if api_key.blank?
+      
+      self.find(:get, :guid=>the_guid)
+    end
+    
+    
+    # Instance methods
+    def initialize(attrs)
+      super attrs
+      self.setup(attrs) unless attrs.blank?
+    end
+    
+    def setup(attrs)
+      puts "Setup Entity with attributes: #{attrs.to_json}"
+      api_key = @api_key
+      api_key ||= self.api_key_from_parameters(params)
+      
+      self.guid = attrs['guid'] if attrs.has_key?('guid')
+      self.guid = "user-#{@api_key}-#{attrs['id']}" if attrs.has_key?('id')
+      puts "GEOAPI::Entity.setup #{self.guid}"
+      self.id = attrs['id'] if attrs.has_key?('id')
+      self.id = GeoAPI::Client.id_from_guid(self.guid,api_key) if self.id.blank?
+      self.errors = attrs['error']
+      self.name = attrs['name']
+      self.name ||= attrs['meta']['name'] unless attrs['meta'].blank?
+      self.entity_type = attrs['type']
+      self.shorturl = attrs['shorturl']
+            
+      self.geom = GeoAPI::Geometry.from_hash(attrs['geom']) unless attrs['geom'].blank?
+      self.geom ||= GeoAPI::Geometry.from_hash(attrs['meta']['geom']) unless attrs['meta'].blank?
+      
+      
+      self.views = []
+      unless attrs['views'].blank?
+        if attrs['views'].size > 0
+          attrs['views'].each do |view|
+            self.views << GeoAPI::View.new({'name'=>view, 'guid'=>self.guid})
+            
+            # Dynamically create methods like twitter_view
+            
+             (class <<self; self; end).send :define_method, :"#{view}_view" do
+                find_view("#{view}")
+              end
+
+              (class <<self; self; end).send :define_method, :"#{view}_view_entries" do
+                find_view_entries("#{view}")
+              end
+          end   
+        end
+      end
+      
+      self.userviews = []
+      unless attrs['userviews'].blank?
+        if attrs['userviews'].size > 0
+          attrs['userviews'].each do |view|
+            self.userviews << GeoAPI::UserView.new({'name'=>view, 'guid'=>self.guid})
+            
+            # Dynamically create methods like myapp_userview
+            class << self
+              define_method "#{view}_userview" do
+                find_view("#{view}")
+              end
+            
+              define_method :"#{view}_entries" do
+                #todo needs caching here
+                find_view("#{view}").entries
+              end
+            end
+            
+          end
+        end
+      end
+      
+      self
+    
+    end
+      
+    def type #type is a reserved word
+      self.entity_type 
+    end
+    
+    def update
+      puts "GEOAPI::Entity.update #{self.guid}"
+      
+      raise ArgumentError, "An API Key is required" if api_key.blank?
+      
+      self.setup(post("/e/#{guid}?apikey=#{api_key}", {:body=>self.to_json}))
+    end
+    
+    def load
+      puts "GEOAPI::Entity.load #{self.guid}"
+      
+      raise ArgumentError, "An API Key is required" if api_key.blank?
+      
+      raise ArgumentError, "Properties should include a .guid or .id" if self.guid.blank? && self.id.blank?
+      
+      the_guid = self.guid
+      the_guid ||= "user-#{api_key}-#{self.id}"
+      
+      begin
+        response = self.class.get("/e/#{the_guid}?apikey=#{api_key}")
+      rescue
+        raise BadRequest, "There was a problem communicating with the API"
+      end
+            
+      self.setup(response['result'].merge({'guid'=>self.guid })) 
+      
+      self
+    end
+    
+    def delete
+      puts "GEOAPI::Entity.delete #{self.guid}"
+      
+      raise ArgumentError, "An API Key is required" if api_key.blank?
+      
+      raise ArgumentError, "Object has no :guid" if self.guid.blank?
+      begin
+        Entity.destroy(:guid=>self.guid)
+      rescue
+        raise BadRequest, "There was a problem communicating with the API"
+      end
+      
+    end
+    
+    def destroy
+      self.delete
+    end
+    
+    def save
+      update
+    end
+    
+    def to_s
+      self.name
+    end
+    
+    def to_json options=nil
+      {:name=>name, :guid=>guid, :type=>entity_type, :geom=>geom, :views=>views, :userviews=>userviews, :shorturl=>shorturl}.to_json
+    end
+    
+    # Common facility methods
+    
+    def find_view view_name
+      views.each do |view|
+        return view if view.name == view_name
+      end
+    end
+    
+    def find_view_entries view_name
+      find_view(view_name).load.entries
+    end
+    
+  end
+end

data/lib/geoapi/entry.rb

@@ -0,0 +1,12 @@
+module GeoAPI
+  class Entry < GeoAPI::GeoObject
+    
+    attr_accessor :properties
+    
+    def initialize attrs
+      super(attrs)
+      self.properties = attrs['properties']
+      
+    end
+  end
+end

data/lib/geoapi/geo_object.rb

@@ -0,0 +1,126 @@
+module GeoAPI
+  class GeoObject
+    
+    include HTTParty
+    
+    format :json
+    
+    class << self
+      attr_accessor :api_key
+    end
+    
+    #default_params Proc.new { :apikey => api_key} } 
+    
+    base_uri GeoAPI::API_URL
+    
+    # Allow users to set the API key explicitly, or gain it from other sources. 
+    # Makes for more readable code, and allows multiple keys to be used in the one application.
+    
+    def initialize(attrs)
+      #raise ArgumentError, "A :client must be passed to when creating a GeoObject, unless unless ENV['GEOAPI_KEY'] or is set"
+      
+      @api_key = self.class.api_key_from_parameters(attrs)
+      
+    end
+    
+    def self.api_key 
+      @api_key ||= GeoAPI::GEOAPI_KEY
+      @api_key ||= ENV["GEOAPI_KEY"]
+      puts "API KEY: #{@api_key}"
+      @api_key
+    end
+    
+    def self.api_key_from_parameters(attrs)
+      unless attrs.blank?
+        the_api_key = attrs[:client].api_key if attrs.has_key?(:client)
+        the_api_key ||= attrs[:apikey] if attrs.has_key?(:apikey)
+        the_api_key ||= attrs[:api_key] if attrs.has_key?(:api_key)
+        the_api_key ||= attrs[:api_key] if attrs.has_key?(:api_key)
+      end
+      the_api_key ||= self.api_key
+      puts "API Key from parameters: #{the_api_key}"
+      @api_key = the_api_key
+      the_api_key
+    end
+    
+    def self.post path, options={}
+      puts "Post: #{path} : #{options.to_s}"
+      timeout = options[:timeout] || 5
+      options.delete(:timeout)
+      retryable( :tries => 2 ) do
+        Timeout::timeout(timeout) do |t|
+          super path, options
+        end
+      end
+    end
+    
+    def self.get path, options={}
+      puts "Get: #{path} : #{options.to_s}"
+      timeout = options[:timeout] || 5
+      options.delete(:timeout)
+      puts options.to_s
+      puts "Timeout #{timeout}"
+      retryable( :tries => 2 ) do
+        Timeout::timeout(timeout) do |t|
+          super path, options
+        end
+      end
+    end
+    
+    def self.delete path, options={}
+      puts "Delete: #{path} : #{options.to_s}"
+      timeout = options[:timeout] || 5
+      options.delete(:timeout)
+      retryable( :tries => 2 ) do
+        Timeout::timeout(timeout) do |t|
+          super path, options
+        end
+      end
+    end
+    
+    def self.search(conditions, options={})
+      puts "GEOAPI::Entity.search #{conditions.to_s}"
+      
+      raise ArgumentError, ":lat and :lng are required for search" unless conditions.has_key?(:lat) && conditions.has_key?(:lng)
+      
+      api_key = self.api_key_from_parameters(options)
+      
+      raise ArgumentError, "An API Key is required" if api_key.blank?
+      
+      # Accepts all conditions from the API and passes them through - http://docs.geoapi.com/Simple-Search
+      
+      conditions.merge!({:lat=>conditions[:lat],:lon=>conditions[:lng],:apikey=>api_key})
+      conditions.delete(:lng)
+      
+      response = get("/search", {:timeout=>60, :query=>conditions})
+      
+      begin
+        
+      rescue
+        raise BadRequest, "There was a problem communicating with the API"
+      end
+      
+      results = []
+      unless response['result'].blank?
+        response['result'].each do |result|
+          results << self.new(result)
+        end
+        results.reverse!
+      end
+    end
+    
+    def self.find params
+      # Find a given object by location passed as :lat, :lng
+      raise ArgumentError, ":lat must be sent as a parameter" unless params.has_key?(:lat)
+      raise ArgumentError, ":lng must be sent as a parameter" unless params.has_key?(:lng)
+      
+      self.search({:lat=>params[:lat], :lng=>params[:lng],:type=>self.entity_type})
+    end
+    
+    def self.entity_type
+      "user-entity"
+    end
+    
+  end
+  
+end

data/lib/geoapi/geometry.rb

@@ -0,0 +1,138 @@
+module GeoAPI
+  class Geometry
+    
+    class << self
+      attr_accessor :coords, :geometry_type
+    end
+  
+    
+    # Class methods
+    
+    def self.new_from_class_name class_name
+      geom = case class_name.downcase.gsub('_','')
+        
+        when "point" then GeoAPI::Point.new
+        
+        when "polygon" then GeoAPI::Polygon.new
+        
+        when "multipoint" then GeoAPI::Polygon.new
+          
+      end
+    
+    end
+    
+    def self.from_json json
+      unless json.blank?
+        attrs = Crack::JSON.parse(json)
+      
+        geom = Geometry.new_from_class_name json['type']
+      
+        unless geom.blank?
+        
+          geom.geometry_type = attrs['type']
+      
+          geom.coords = attrs['coordinates']
+        
+          geom
+        
+        end
+      end
+    end
+    
+    def self.from_hash hash
+      
+      unless hash.blank?
+        geom = Geometry.new_from_class_name hash['type']
+      
+        unless geom.blank?
+        
+          geom.geometry_type = hash['type']
+      
+          geom.coords = hash['coordinates']
+          
+          puts "Got geometry: #{geom}"
+          
+          geom
+      
+        end
+      end
+    end
+    
+    
+    # Instance methods
+    
+    def coordinates
+      coords
+    end
+    
+    def type
+      geometry_type
+    end
+    
+    def to_json options=nil
+      {:type=>self.geometry_type, :coordinates=>self.coords}.to_json
+    end
+    
+    def initialize attrs
+      @geometry_type = self.class.name.split('::').last
+    end
+    
+  end
+  
+  class Point < GeoAPI::Geometry    
+    
+    attr_accessor :geometry_type, :coords
+    
+    def latitude
+      coords[0]
+    end
+    
+    def longitude
+      coords[1]
+    end
+    
+    def initialize *args
+      
+      params = args.extract_options!
+      params = params == {} ? nil : params
+      
+      puts "GEOAPI::Point.new #{params.to_json}"
+      
+      #raise ArgumentError, ":lat (latitude) must be sent as a parameter to the GeoAPI::Point constructor" unless params.has_key?(:lat)
+      #raise ArgumentError, ":lng (longitude) must be sent as a parameter to the GeoAPI::Point constructor" unless params.has_key?(:lng)
+      
+      self.coords = [params[:lng].to_f, params[:lat].to_f] unless params.blank? || params[:lat].blank?
+      super args
+    end
+    
+
+  end
+  
+  class Multipoint < GeoAPI::Geometry
+    
+    attr_accessor :geometry_type, :coords
+  
+    def initialize attrs
+      
+      self.coords = []
+      super attrs
+    end
+    
+
+  end
+  
+  class Polygon < GeoAPI::Geometry
+        
+    attr_accessor :geometry_type, :coords
+    
+    def initialize attrs
+      self.coords = [] 
+      super attrs
+    end
+    
+
+  end
+  
+  #todo add additional classes
+  
+end

data/lib/geoapi/neighborhood.rb

@@ -0,0 +1,17 @@
+module GeoAPI
+  class Neighborhood < GeoAPI::GeoObject
+    
+    attr_accessor :properties
+    
+    def self.entity_type
+      "neighborhood"
+    end
+    
+    def initialize attrs
+      super(attrs)
+      self.properties = attrs['properties']
+      
+    end
+    
+  end
+end

data/lib/geoapi/query.rb

@@ -0,0 +1,61 @@
+module GeoAPI
+  class Query
+    
+    class << self
+      # Uses GeoAPI's simple search method
+      def simple_search(lat, lon, options = {})
+        options[:lat] = lat
+        options[:lon] = lon
+        url = build_url('search', options)
+        get_then_parse(url)
+      end
+    
+      # Uses GeoAPI's MQL query method
+      def query(query)
+        q = JSON.generate(query)
+        url = build_url('q', {:q => URI.escape(q)})
+        get_then_parse(url)     
+      end
+    
+    
+      def get_then_parse(url)
+        JSON.parse(get(url))
+      end
+    
+      def build_url(resource_path, options = {})
+
+        options[:apikey] ||= GeoAPI.apikey
+        query_string = build_query_params(options)
+      
+        "#{GeoAPI::API_URL}#{resource_path}#{query_string}"
+      end
+    
+      def get(url)
+        RestClient.get(url)
+      rescue RestClient::RequestFailed
+        raise BadRequest, "Parameter invalid"
+      rescue RestClient::ResourceNotFound
+        raise NotFound, "GUID invalid"
+      end
+
+      protected
+    
+      # Take options and build query string
+      def build_query_params(options)
+        query = {}
+      
+        #convert True/False
+        options.each_pair do |key, value|
+          new_key = key.to_s
+          new_val = case value
+            when TrueClass then 1
+            when FalseClass then 0
+            else value
+          end
+          query[new_key] = new_val 
+        end
+        "?" + query.map{|k,v| "#{k}=#{v}"}.join('&')
+      end
+    end
+  end
+end

data/lib/geoapi/user_view.rb

@@ -0,0 +1,11 @@
+module GeoAPI
+  class UserView < GeoAPI::View
+    class << self
+      @@path_prefix = GeoAPI::USERVIEW_PATH_PREFIX
+    end
+    
+    def initialize attrs
+      super attrs
+    end
+  end
+end

data/lib/geoapi/version.rb

@@ -0,0 +1,8 @@
+module GeoAPI
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 1
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/geoapi/view.rb

@@ -0,0 +1,100 @@
+module GeoAPI
+  class View < GeoAPI::GeoObject
+    
+    attr_accessor :name, :guid, :view_type, :id, :entries
+    
+    class << self
+      attr_accessor :path_prefix
+    end
+    
+    GeoAPI::VIEW_PATH_PREFIX = "view"
+    GeoAPI::USERVIEW_PATH_PREFIX = "userview"
+
+    
+    # Class methods
+    
+    def self.path_prefix
+      case self.to_s
+        when "GeoAPI::View" then VIEW_PATH_PREFIX
+          
+        when "GeoAPI::UserView" then USERVIEW_PATH_PREFIX
+      end
+    end
+    
+    def self.find(*args)
+      
+      #raise ArgumentError, "First argument must be symbol (:all or :get)" unless args.first.kind_of?(Symbol)
+      
+      params = args.extract_options!
+      params = params == {} ? nil : params
+      
+      results = nil
+      params[:guid] = "user-#{GeoAPI::API_KEY}-#{params[:id]}" unless params[:id].blank?
+      raise ArgumentError, "Arguments should include a entity :guid or an :id" if params[:guid].blank? && params[:id].blank?
+      raise ArgumentError, "Arguments should include a view :name" if params[:name].blank?
+      
+      begin
+        debugger
+        
+        response = get("/e/#{params[:guid]}/#{self.class.path_prefix}/#{params[:name]}")
+      rescue
+        raise BadRequest, "There was a problem communicating with the API"
+      end
+      
+      entries = {'entries' => response['result']} # There are no entries in this view
+    
+      results = View.new(entries.merge({'guid'=>params[:guid], 'name'=>params[:name]})) unless response['result'].blank? #the api doesn't return a guid in json?!
+
+      results
+    end
+    
+    
+    # Instance methods
+    def initialize attrs
+      setup(attrs)
+    end
+    
+    def setup attrs
+      self.name = attrs['name']
+      self.guid = attrs['guid']
+      self.view_type = attrs['type']
+      
+      self.entries = []
+      unless attrs['entries'].blank?
+        if attrs['entries'].size > 0
+          attrs['entries'].each do |entry|
+            self.entries << GeoAPI::Entry.new({'properties'=>entry})  
+          end
+          self.entries.reverse!
+        end
+      end
+    end
+    
+    
+    def load
+      raise ArgumentError, "Properties should include a .guid or .id" if self.guid.blank? && self.id.blank?
+      raise ArgumentError, "Properties should include a .name" if self.name.blank?
+      
+      the_guid = self.guid
+      
+      the_guid ||= "user-#{GeoAPI::API_KEY}-#{self.id}"
+      
+      begin
+        response = self.class.get("/e/#{the_guid}/#{self.class.path_prefix}/#{self.name}")
+      rescue
+        raise BadRequest, "There was a problem communicating with the API"
+      end
+    
+      entries = {'entries' => response['result']} # There are no entries in this view
+        
+      self.setup(entries.merge({'guid'=>self.guid, 'name'=>self.name })) 
+      
+      self
+    end
+    
+    def to_json options=nil
+      {:name=>name, :guid=>guid, :type=>view_type}.to_json
+    end
+  end
+
+end

data/lib/geoapi.rb

@@ -0,0 +1,89 @@
+
+%w{rubygems rest_client httparty json crack/json uuidtools}.each { |x| require x }
+
+# Patch HTTParty to debug 
+HTTParty::Request.class_eval do
+  class << self
+    attr_accessor :debug
+  end
+  self.debug = true
+
+  def perform_with_debug
+    if self.class.debug
+      puts "HTTParty making #{http_method::METHOD} request to:"
+      puts uri
+      puts "With Body: #{body}" 
+    end
+    perform_without_debug
+  end
+
+  alias_method :perform_without_debug, :perform
+  alias_method :perform, :perform_with_debug
+end
+
+# monkey patch HTTParty to use a configurable timeout
+module HTTParty
+  class Request
+    private
+      def http
+        http = Net::HTTP.new(uri.host, uri.port, options[:http_proxyaddr], options[:http_proxyport])
+        http.use_ssl = (uri.port == 443)
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        http.open_timeout = http.read_timeout = options[:timeout].to_i  if options[:timeout].to_i > 0
+        http
+      end
+  end
+end
+
+def retryable(options = {}, &block)
+  opts = { :tries => 1, :on => Exception }.merge(options)
+
+  retry_exception, retries = opts[:on], opts[:tries]
+
+  begin
+    return yield
+  rescue retry_exception
+    retry if (retries -= 1) > 0
+  end
+
+  yield
+end
+
+class Array
+  # Extract options from a set of arguments. Removes and returns the last element in the array if it's a hash, otherwise returns a blank hash.
+  #
+  #   def options(*args)
+  #     args.extract_options!
+  #   end
+  #
+  #   options(1, 2)           # => {}
+  #   options(1, 2, :a => :b) # => {:a=>:b}
+  def extract_options!
+    last.is_a?(::Hash) ? pop : {}
+  end
+end
+
+module GeoAPI
+  API_VERSION = "v1"
+  API_URL     = "http://api.geoapi.com/#{API_VERSION}/"
+
+  class ArgumentError        < StandardError; end
+  class BadRequest           < StandardError; end
+  class NotFound             < StandardError; end
+  class NotAcceptable        < StandardError; end
+end
+
+
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+  
+require 'geoapi/geo_object' 
+require 'geoapi/geometry' 
+require 'geoapi/version'
+require 'geoapi/entity'
+require 'geoapi/entry'
+require 'geoapi/view'
+require 'geoapi/user_view'
+require 'geoapi/query'
+require 'geoapi/client'
+require 'geoapi/neighborhood'

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification 
+name: steflewandowski-geoapi
+version: !ruby/object:Gem::Version 
+  version: 0.2.1
+platform: ruby
+authors: 
+- Stef Lewandowski
+- Chris Bruce
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-10 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.9"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: crack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: uuidtools
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: A Ruby wrapper for the GeoAPI.com API based on the work of Chris Bruce. See http://api.geoapi.com for more information about the API.
+email: stef@stef.io
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- LICENSE
+- geoapi.gemspec
+- lib/geoapi.rb
+- lib/geoapi/geo_object.rb
+- lib/geoapi/geometry.rb
+- lib/geoapi/query.rb
+- lib/geoapi/entity.rb
+- lib/geoapi/entry.rb
+- lib/geoapi/view.rb
+- lib/geoapi/user_view.rb
+- lib/geoapi/version.rb
+- lib/geoapi/client.rb
+- lib/geoapi/neighborhood.rb
+has_rdoc: true
+homepage: http://github.com/steflewandowski/GeoAPI/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A Ruby wrapper for the GeoAPI.com API.
+test_files: []
+