simple_geolocation 0.0.1

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*.swp
+*.swo
+*.DS_Store

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in simple_geolocation.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/simple_geolocation.rb

@@ -0,0 +1,7 @@
+require 'active_support/core_ext'
+require File.join(File.dirname(__FILE__), 'simple_geolocation/utils/remove_accents')
+module SimpleGeolocation
+  autoload :Geocoder   , 'simple_geolocation/geocoder'
+  autoload :Location , 'simple_geolocation/location'
+  autoload :Geoworkers , 'simple_geolocation/geoworkers/geoworkers'
+end

data/lib/simple_geolocation/geocoder.rb

@@ -0,0 +1,39 @@
+module SimpleGeolocation
+  class Geocoder
+
+    attr_reader :success, :raw_location, :location
+    alias :success? :success
+
+    delegate *(Location::ATTRIBUTES + [:completeness]), :to => :location
+
+    def initialize(raw_location)
+      @raw_location = raw_location
+    end
+
+    def ip?
+      !!/^(\d+\.){3}\d+$/.match(@raw_location)
+    end
+
+    # Only brazilian zipcode is supported.
+    def zip?
+      return false if ip?
+      number = @raw_location.to_s.gsub(/(\.|\D|\-|\s)/, '')
+      number.size == 8
+    end
+
+    def address?
+      !ip? && !zip?
+    end
+
+    def geocode!
+      @geoworker = Geoworkers::Base.instantiate_geoworker_based_on(self)
+      @geoworker.process!
+      @location = @geoworker.location
+    end
+
+    def success!
+      @success = true
+    end
+
+  end
+end

data/lib/simple_geolocation/geoworkers/base.rb

@@ -0,0 +1,27 @@
+module SimpleGeolocation
+  module Geoworkers
+    class Base
+
+      attr_reader :location, :geocoder, :success
+      alias :success? :success
+
+      def initialize(geocoder)
+        @geocoder = geocoder
+      end
+
+      def process!
+        raise NotImplementedError
+      end
+
+      def self.instantiate_geoworker_based_on(geocoder)
+        if geocoder.ip?
+          GeoIP.new(geocoder)
+        elsif geocoder.zip?
+          Geozip.new(geocoder)
+        else
+          Geokit.new(geocoder)
+        end
+      end
+    end
+  end
+end

data/lib/simple_geolocation/geoworkers/geoip/geoip.rb

@@ -0,0 +1,34 @@
+require 'geoip'
+module SimpleGeolocation
+  module Geoworkers
+    class GeoIP < Base
+
+      def process!
+        get_location!
+        geocoder.success! if success?
+      end
+
+      private
+
+      def ip_geocoder
+        @ip_geocoder ||= ::GeoIP.new(File.join(File.dirname(__FILE__), 'data', 'GeoLiteCity.dat'))
+      end
+
+      def get_location!
+        result = ip_geocoder.city(geocoder.raw_location)
+        if @success  = result && result.city_name.present? && result.region_name.present?
+          @location = Location.new(
+            :lat => result.latitude,
+            :lng => result.longitude,
+            :city => result.city_name,
+            :state => result.region_name,
+            :provider => "geoip"
+          )
+        else
+          Geokit.new(geocoder).process!
+        end
+      end
+
+    end
+  end
+end

data/lib/simple_geolocation/geoworkers/geokit/geokit.rb

@@ -0,0 +1,36 @@
+require 'geokit'
+module SimpleGeolocation
+  module Geoworkers
+    class Geokit < Base
+
+      def process!
+        get_location!
+        geocoder.success! if success?
+      end
+
+      private
+
+      def multi_geocoder
+        @multi_geocoder ||= ::Geokit::Geocoders::MultiGeocoder
+      end
+
+      def get_location!
+        result = multi_geocoder.geocode(geocoder.raw_location.removeaccents)
+        if @success = result.success
+          @location = Location.new(
+            :lat => result.lat,
+            :lng => result.lng,
+            :city => result.city,
+            :state => result.state,
+            :street => result.street_name,
+            :number => result.street_number,
+            :zip => result.zip,
+            :district => result.district,
+            :provider => result.provider
+          )
+        end
+      end
+
+    end
+  end
+end

data/lib/simple_geolocation/geoworkers/geoworkers.rb

@@ -0,0 +1,8 @@
+module SimpleGeolocation
+  module Geoworkers
+    autoload :Base, 'simple_geolocation/geoworkers/base'
+    autoload :GeoIP, 'simple_geolocation/geoworkers/geoip/geoip'
+    autoload :Geokit, 'simple_geolocation/geoworkers/geokit/geokit'
+    autoload :Geozip, 'simple_geolocation/geoworkers/geozip/geozip'
+  end
+end

data/lib/simple_geolocation/geoworkers/geozip/geozip.rb

@@ -0,0 +1,32 @@
+require 'brcep'
+module SimpleGeolocation
+  module Geoworkers
+    class Geozip < Base
+
+      def process!
+        get_location!
+        geocoder.success! if success?
+      end
+
+      private
+
+      def get_location!
+        begin
+          result = ::BuscaEndereco.por_cep(geocoder.raw_location)
+          if @success = result && result.present?
+            street = "#{result.first} #{result.second}"
+            other_location_data = result[2..-1].join(', ')
+            new_raw_location = "#{street}, #{other_location_data}"
+            geokit = Geokit.new(Geocoder.new(new_raw_location))
+            geokit.process!
+            @success = geokit.success?
+            @location = geokit.location
+          end
+        rescue
+          @success = false
+        end
+      end
+
+    end
+  end
+end

data/lib/simple_geolocation/location.rb

@@ -0,0 +1,23 @@
+module SimpleGeolocation
+  class Location
+    ATTRIBUTES = [:lat, :lng, :city, :state, :provider, :zip, :street, :district, :number]
+    attr_accessor *ATTRIBUTES
+
+    def initialize(attributes = {})
+      unknown_attributes = attributes.keys.reject { |k| ATTRIBUTES.include?(k) }
+      raise ArgumentError, "Unknown parameters: #{unknown_attributes.join(', ')}" unless unknown_attributes.empty?
+      attributes.each do |k, v|
+        send("#{k}=", v)
+      end
+    end
+
+    def completeness(attributes = ATTRIBUTES)
+      total = attributes.size
+      used = attributes.reject {|attr| send(attr).blank? }.size
+      return 100 if used >= total
+      (used.to_f / total.to_f * 100.0).to_i
+    end
+
+  end
+end
+

data/lib/simple_geolocation/utils/remove_accents.rb

@@ -0,0 +1,61 @@
+class String
+  # The extended characters map used by removeaccents. The accented characters
+  # are coded here using their numerical equivalent to sidestep encoding issues.
+  # These correspond to ISO-8859-1 encoding.
+  ACCENTS_MAPPING = {
+    'E' => [200,201,202,203],
+    'e' => [232,233,234,235],
+    'A' => [192,193,194,195,196,197],
+    'a' => [224,225,226,227,228,229,230],
+    'C' => [199],
+    'c' => [231],
+    'O' => [210,211,212,213,214,216],
+    'o' => [242,243,244,245,246,248],
+    'I' => [204,205,206,207],
+    'i' => [236,237,238,239],
+    'U' => [217,218,219,220],
+    'u' => [249,250,251,252],
+    'N' => [209],
+    'n' => [241],
+    'Y' => [221],
+    'y' => [253,255],
+    'AE' => [306],
+    'ae' => [346],
+    'OE' => [188],
+    'oe' => [189]
+  }
+
+
+  # Remove the accents from the string. Uses String::ACCENTS_MAPPING as the source map.
+  def removeaccents
+    str = String.new(self)
+    String::ACCENTS_MAPPING.each {|letter,accents|
+      packed = accents.pack('U*')
+      rxp = Regexp.new("[#{packed}]", nil)
+      str.gsub!(rxp, letter)
+    }
+
+    str
+  end
+
+
+  # Convert a string to a format suitable for a URL without ever using escaped characters.
+  # It calls strip, removeaccents, downcase (optional) then removes the spaces (optional)
+  # and finally removes any characters matching the default regexp (/[^-_A-Za-z0-9]/).
+  #
+  # Options
+  #
+  # * :downcase => call downcase on the string (defaults to true)
+  # * :convert_spaces => Convert space to underscore (defaults to false)
+  # * :regexp => The regexp matching characters that will be converting to an empty string (defaults to /[^-_A-Za-z0-9]/)
+  def urlize(options = {})
+    options[:downcase] ||= true
+    options[:convert_spaces] ||= false
+    options[:regexp] ||= /[^-_A-Za-z0-9]/
+
+      str = self.strip.removeaccents
+    str.downcase! if options[:downcase]
+    str.gsub!(/\ /,'_') if options[:convert_spaces]
+    str.gsub(options[:regexp], '')
+  end
+end

data/lib/simple_geolocation/version.rb

@@ -0,0 +1,3 @@
+module SimpleGeolocation
+  VERSION = "0.0.1"
+end

data/simple_geolocation.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "simple_geolocation/version"
+
+Gem::Specification.new do |s|
+  s.name        = "simple_geolocation"
+  s.version     = SimpleGeolocation::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Esdras Mayrink"]
+  s.email       = ["falecom@oesdras.com.br"]
+  s.homepage    = "http://oesdras.com.br"
+  s.summary     = %q{A gem that fetch locations based on IP, ZIP and ordinary address through several existing geolocation gems.}
+  s.description = %q{
+    This gem is used with geolocation in mind, meaning that the main goal is to get a latitude and longitude, but it will return additional data if
+    available. With this gem you can pass an IP number or an ZIP number or an ordinary address and it will try to get as many information as possible
+    about the given argument.
+  }
+
+  s.add_development_dependency "rspec"
+  s.add_dependency "geokit"
+  s.add_dependency "geoip"
+  s.add_dependency "activesupport"
+  s.add_dependency "brcep"
+
+  s.rubyforge_project = "simple_geolocation"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/simple_geolocation_spec.rb

@@ -0,0 +1,63 @@
+# coding: utf-8
+require File.join(File.dirname(__FILE__), '..', 'lib', 'simple_geolocation')
+
+describe SimpleGeolocation do
+
+
+  it 'should identify if the given location is an ip' do
+    @geo = SimpleGeolocation::Geocoder.new("74.125.113.105")
+    @geo.ip?.should be_true
+    @geo.zip?.should be_false
+    @geo.address?.should be_false
+  end
+
+  it 'should identify if the given location is a zip' do
+    @geo = SimpleGeolocation::Geocoder.new("89237-440")
+    @geo.ip?.should be_false
+    @geo.zip?.should be_true
+    @geo.address?.should be_false
+  end
+
+  it 'should identify if the given location is an address' do
+    @geo = SimpleGeolocation::Geocoder.new("Joinville - SC")
+    @geo.ip?.should be_false
+    @geo.address?.should be_true
+    @geo.zip?.should be_false
+  end
+
+  it "should return the location of an user's based on IP" do
+    @geo = SimpleGeolocation::Geocoder.new("74.125.113.105")
+    @geo.ip?.should be_true
+    @geo.geocode!
+    @geo.success?.should be_true
+    @geo.lat.should == 37.41919999999999
+    @geo.lng.should == -122.0574
+    @geo.completeness.should == 55
+  end
+
+  it "should return the location of an ordinary address" do
+    @geo = SimpleGeolocation::Geocoder.new("Rua do Principe, 199, Joinville, SC")
+    @geo.address?.should be_true
+    @geo.geocode!
+    @geo.success?.should be_true
+    @geo.lat.should == -26.30101
+    @geo.lng.should == -48.8452974
+    @geo.completeness.should == 88
+  end
+
+  it "should return the location of a brazilian zipcode (CEP)" do
+    @geo = SimpleGeolocation::Geocoder.new("22640100")
+    @geo.zip?.should be_true
+    @geo.geocode!
+    @geo.success?.should be_true
+    @geo.street.should == "Av. Das Américas"
+    @geo.district.should == "Barra da Tijuca"
+    @geo.state.should == "RJ"
+    @geo.city.should == "Rio De Janeiro"
+    @geo.zip.should == "22640-100"
+    @geo.lat.should == -23.0032808
+    @geo.lng.should == -43.3230295
+    @geo.completeness.should == 88
+  end
+
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification 
+name: simple_geolocation
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Esdras Mayrink
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-04 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: geokit
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: geoip
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: brcep
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id005
+description: "\n    This gem is used with geolocation in mind, meaning that the main goal is to get a latitude and longitude, but it will return additional data if\n    available. With this gem you can pass an IP number or an ZIP number or an ordinary address and it will try to get as many information as possible\n    about the given argument.\n  "
+email: 
+- falecom@oesdras.com.br
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- lib/simple_geolocation.rb
+- lib/simple_geolocation/geocoder.rb
+- lib/simple_geolocation/geoworkers/base.rb
+- lib/simple_geolocation/geoworkers/geoip/data/GeoLiteCity.dat
+- lib/simple_geolocation/geoworkers/geoip/geoip.rb
+- lib/simple_geolocation/geoworkers/geokit/geokit.rb
+- lib/simple_geolocation/geoworkers/geoworkers.rb
+- lib/simple_geolocation/geoworkers/geozip/geozip.rb
+- lib/simple_geolocation/location.rb
+- lib/simple_geolocation/utils/remove_accents.rb
+- lib/simple_geolocation/version.rb
+- simple_geolocation.gemspec
+- spec/simple_geolocation_spec.rb
+has_rdoc: true
+homepage: http://oesdras.com.br
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: simple_geolocation
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: A gem that fetch locations based on IP, ZIP and ordinary address through several existing geolocation gems.
+test_files: 
+- spec/simple_geolocation_spec.rb