tzdetect 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tzdetect.gemspec
+gemspec
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Bojan Milosavljevic 
+
+MIT License
+
+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.md

@@ -0,0 +1,94 @@
+# TZDetect
+
+Detects timezone by address or location, using google or geoname web services.
+It will utilaze web services only if can't detect timezone by country code (when country has only one timezone) 
+
+Procedure for detecting time zone:
+
+1. Looks tah given country has only one time zone 
+2. Fetching time zone data through web services if position (latitude and longitude) is given
+3. First detects position for given country, city and region and then fetch timezone data from web
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'tzdetect'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tzdetect
+
+## Configuration 
+
+Can be set through block:
+
+    TZDetect::Configuration.begin do |c|
+      c.username = 'your_geonames_username'
+    end
+
+or 
+    TZDetect::Configuration.service = :geoname
+    TZDetect::Configuration.username = "username"
+
+Configuration params:
+
+* service - service name can be :google or :geoname - default google
+* username - username for geoname service
+* google_client_key = google api key (not tested )
+* google_signature = google api signature (not tested )
+  
+If you use geoname service, make sure you have a geonames username. It's free and easy to setup, you can do so [here](http://www.geonames.org/login).
+
+## Usage
+
+Country with many timezones without position data: System will find location for Miami and then find timezone
+ 
+    tz = TimeZone.new("US", "Miami", "Florida")
+    tz.timezone.name   #  "America/New_York"
+    tz.latitude        #   25.774265 
+    tz.longitude       #  -80.193658
+
+Country with many time zones with position data: System will directly find timezone with position data
+
+    tz = TimeZone.new("US", "Miami", "Florida", 25.774265, -80.193658)
+    tz.timezone.name   #  "America/New_York"
+
+Country with one time zone will not return location data 
+
+    tz = TimeZone.new("RS", "Novi Sad")
+    tz.timezone.name   #  "Europe/Belgrade"
+    tz.latitude        #   nil 
+    tz.longitude       #   nil
+
+
+## Class methods  
+
+### Get timezone by location
+
+Return TZInfo object 
+
+    tz = TimeZone.get!("RS", "Novi Sad")
+    tz.name   #  "Europe/Belgrade" 
+    
+    tz = TimeZone.new("US", "Miami", "Florida", 25.774265, -80.193658)
+    tz.name   #  "America/New_York"
+
+###  Getting the timezone for a specific latitude and longitude
+
+You can use class method by_location
+
+    TZDetect::TimeZone.by_location! 44.21, 21.0 
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,16 @@
+require "bundler/gem_tasks"
+require 'rubygems'
+require 'rake'
+require 'rdoc/task'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task :default => [:test]
+

data/TZDetect.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tzdetect/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "tzdetect"
+  gem.version       = TZDetect::VERSION
+  gem.authors       = ["Bojan Milosavljevic "]
+  gem.email         = ["milboj@gmail.com"]
+  gem.description   = %q{Detects  timezone by address or location using google or geoname web service}
+  gem.summary       = %q{Easy way to detect time zone by  address or location }
+  gem.homepage      = ""
+  gem.required_ruby_version = ">= 1.9.2"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.add_dependency 'tzinfo', '>= 0.3.33'
+  gem.add_dependency 'json', '>= 1.7'
+end

data/lib/TZDetect/configuration.rb

@@ -0,0 +1,56 @@
+module TZDetect
+  class Configuration
+    ALLOWED_TYPES= [:google, :geoname] 
+
+    @@google_signature  = nil
+    @@google_client_key = nil
+
+    def self.service= type
+      raise ArgumentError, "wrong service type" unless ALLOWED_TYPES.include?(type.to_sym)
+      @@service= type
+    end
+    
+    def self.service
+      @@service ||= :google
+    end
+
+    def self.google_client_key
+      @@google_client_key 
+    end
+
+    def self.google_client_key= google_key
+      @@google_client_key= google_key
+    end
+
+    def self.google_signature
+      @@google_signature 
+    end
+
+    def self.google_signature= google_signature
+      @@google_key= google_signature
+    end
+
+
+    def self.username= username
+      @@username = username
+    end
+    
+    def self.username
+      @@username 
+    end
+
+    def self.begin
+      yield self
+    end
+
+    protected
+    # Merge this params Set params https://developers.google.com/maps/documentation/business/webservices
+    def self.google_params
+      params             = {}
+      params[:client]    = @@google_client_key unless @@google_client_key.nil?
+      params[:signature] = @@google_signature unless @@google_signature.nil?
+      return params
+    end
+
+  end
+end

data/lib/TZDetect/error.rb

@@ -0,0 +1,9 @@
+
+module TZDetect
+  module Error
+    class Base < StandardError; end
+    class Configuration < Base; end
+    class Parser < Base; end
+    class GeoCoder < Base; end
+  end
+end

data/lib/TZDetect/geocoder.rb

@@ -0,0 +1,65 @@
+module TZDetect
+  Position = Struct.new(:latitude, :longitude, :timezone)
+  module Geocoder
+    attr_accessor :city, :country, :region
+    attr_reader   :latitude, :longitude, :timezone
+
+    # Constructor initalize country city and region 
+    def initialize country, city, region=""
+      @country = country
+      @city    = city
+      @region  = region
+    end
+
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      # Returns location position hash
+      #
+      #  *latitude
+      #  *longitude
+      #  *timezone - can be nil 
+      #
+      def self.get country, city, region=""
+        location = self.new country, city, region
+        location.position
+      end
+
+      # Returns location position hash (raise exception)
+      #
+      #  *latitude
+      #  *longitude
+      #  *timezone - can be nil 
+      #
+      def self.get! country, city, region=""
+        location = self.new country, city, region
+        return location.position!
+      end
+    end
+
+
+
+    # Returns position 
+    def postion
+      begin
+        self.postion! 
+      rescue 
+        nil
+      end
+    end
+
+    # Returns position raise excpetion 
+    def position!
+      raise TZDetect::Error::Geocoder, "not implemented method position!"
+    end
+
+    def fetched_data
+      Position.new(@latitude, @longitude, @timezone)
+    end
+
+  end
+end

data/lib/TZDetect/geocoders/geoname.rb

@@ -0,0 +1,47 @@
+require 'json'
+require 'net/http'
+require File.expand_path(File.dirname(__FILE__) + '/../geocoder')
+
+module TZDetect
+  class GeonameGeocode  
+    include Geocoder
+    GEONAME_GEOCODE_API = "http://api.geonames.org/searchJSON"
+
+    # Returns position 
+    def position! 
+      begin 
+
+        url =URI(GEONAME_GEOCODE_API)
+        url.query = URI.encode_www_form(geoname_params)
+
+        Net::HTTP.start(url.host, url.port, :use_ssl => false) do |http| 
+          request = Net::HTTP::Get.new(url.request_uri)
+          response = http.request request # Net::HTTPResponse object
+          json_result =JSON.parse(response.read_body)
+
+          unless json_result["geonames"].empty?
+            geoname = json_result["geonames"][0]
+            @latitude  = geoname["lat"]
+            @longitude = geoname["lng"]
+            @timezone  = geoname["timezone"]["timeZoneId"]
+            return fetched_data
+          else 
+            raise "no results"
+          end
+        end
+      rescue Exception => e
+        raise TZDetect::Error::GeoCoder, e.message
+      end
+    end
+
+    private
+    def geoname_params
+      username = Configuration.username
+      raise "no geoname username configured" if username.nil?
+      address = @region.nil? ? @city : "#{@city},#{@region}"
+      return {:q=> address, :country=>@country, :formated => "true",:maxRows => 5, :username => username, :style => "FULL" }
+    end
+
+  end
+
+end

data/lib/TZDetect/geocoders/google.rb

@@ -0,0 +1,49 @@
+require 'json'
+require 'net/http'
+require File.expand_path(File.dirname(__FILE__) + '/../geocoder')
+
+module TZDetect
+  class GoogleGeocode  
+    include Geocoder
+    GOOGLE_GEOCODE_API = "https://maps.google.com/maps/api/geocode/json"
+
+
+    # Returns position 
+    def position! 
+        other = @region.nil? ? @country : "#{@region},#{@country}"
+        address = "#{@city},#{other}"
+        position = self.class.fetch_by_address!(address)
+        @latitude = position["lat"]
+        @longitude = position["lng"]
+        return fetched_data
+    end
+
+
+    # Find position by addresss
+    def self.fetch_by_address! address
+      begin 
+        url =URI(GOOGLE_GEOCODE_API)
+        url.query = URI.encode_www_form(self.params(address))
+        Net::HTTP.start(url.host, url.port, :use_ssl => true) do |http| 
+          request = Net::HTTP::Get.new(url.request_uri)
+          response = http.request request # Net::HTTPResponse object
+          json_result =JSON.parse(response.read_body)
+          if json_result["status"] == "OK"
+            return  json_result["results"][0]["geometry"]["location"]
+          else 
+            raise "no results"
+          end
+        end
+      rescue Exception => e
+        raise TZDetect::Error::GeoCoder, e.message
+      end
+    end
+
+    # Set params https://developers.google.com/maps/documentation/business/webservices
+    def self.params address
+      {:address=> address, :sensor=>"false"}.merge(Configuration.google_params) 
+    end
+
+  end
+
+end

data/lib/TZDetect/parser.rb

@@ -0,0 +1,41 @@
+module TZDetect
+  module Parser
+    attr_accessor :latitude, :longitude
+    def initialize lat, lon
+      lat = lat.to_f if lat.kind_of? Integer
+      lon = lon.to_f if lon.kind_of? Integer
+      valid_latitude_and_longitude lat, lon
+      raise TZDetect::Error::Parser, "lat and long must be float" if !lat.kind_of?(Float) || !lon.kind_of?(Float)
+      @latitude  = lat
+      @longitude = lon
+    end
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def timezone! lat, lon
+        t = self.new lat, lon
+        t.timezone
+      end
+    end
+
+    def timezone
+      begin
+        m = self.timezone!
+      rescue
+        m = nil
+      end
+    end
+
+    private
+    def valid_latitude_and_longitude lat, lon
+      raise TZDetect::Error::Parser, "latitude and longitude must be number" if !lat.kind_of?(Float) || !lon.kind_of?(Float)
+      raise TZDetect::Error::Parser, "latitude must be beetween -90 and 90 degrees" if lat < -90 || lat > 90
+      raise TZDetect::Error::Parser, "longitude must be beetween -180 and 180 degrees" if lon < -180 || lon > 180
+    end
+
+
+  end
+end

data/lib/TZDetect/parsers/geoname.rb

@@ -0,0 +1,31 @@
+require 'json'
+require 'net/http'
+require File.expand_path(File.dirname(__FILE__) + '/../parser')
+    
+module TZDetect
+  class GeonameParser  
+    include Parser
+
+    GEONAME_GEOCODE_TIMEZONE_API = "http://api.geonames.org"
+    def timezone! 
+      begin
+
+        url =URI("#{GEONAME_GEOCODE_TIMEZONE_API}#{geoname_params}")
+        Net::HTTP.start(url.host, url.port, :use_ssl => false) do |http| 
+          request = Net::HTTP::Get.new(url.request_uri)
+          response = http.request request # Net::HTTPResponse object
+          json_result =JSON.parse(response.read_body)["timezoneId"]
+          raise "No result" if json_result.nil?
+          return json_result
+        end
+      rescue Exception => e
+        raise TZDetect::Error::Parser, e.message
+      end
+    end
+    def geoname_params
+      username = Configuration.username
+      raise "No geoname useraname" if username.nil?
+      "/timezoneJSON?lat=#{@latitude}&lng=#{@longitude}&username=#{username}"
+    end
+  end
+end

data/lib/TZDetect/parsers/google.rb

@@ -0,0 +1,36 @@
+require 'json'
+require 'net/http'
+require File.expand_path(File.dirname(__FILE__) + '/../parser')
+    
+module TZDetect
+  class GoogleParser 
+    include Parser
+    GOOGLE_GEOCODE_TIMEZONE_API = "https://maps.googleapis.com/maps/api/timezone/json"
+
+    def timezone! 
+      begin
+        url =URI(GOOGLE_GEOCODE_TIMEZONE_API)
+        url.query = URI.encode_www_form(self.params)
+        Net::HTTP.start(url.host, url.port, :use_ssl => true) do |http| 
+          request = Net::HTTP::Get.new(url.request_uri)
+          response = http.request request # Net::HTTPResponse object
+          json_result =JSON.parse(response.read_body)
+          if json_result["status"] == "OK"
+            json_result["timeZoneId"]
+          else
+            raise "No result"
+          end
+        end
+      rescue Exception => e
+        raise TZDetect::Error::Parser, e.message
+      end
+    end
+
+
+    def params
+        timestamp = Time.now.to_i
+        {:location =>"#{@latitude},#{@longitude}", :timestamp=>"#{timestamp}", :sensor=>"false"}.merge(Configuration.google_params) 
+    end
+
+  end
+end

data/lib/TZDetect/version.rb

@@ -0,0 +1,3 @@
+module TZDetect
+  VERSION = "0.1.0"
+end

data/lib/TZDetect/zone.rb

@@ -0,0 +1,172 @@
+require "tzinfo"
+require "tzdetect/error"
+require "tzdetect/configuration"
+
+require "tzdetect/parsers/geoname"
+require "tzdetect/parsers/google"
+
+require "tzdetect/geocoders/geoname"
+require "tzdetect/geocoders/google"
+
+module TZDetect
+  class TimeZone
+    attr_reader :country_code, :city, :region, :latitude, :longitude, :timezone
+  
+    # Constructor 
+    #
+    # * country_code - two character ISO 3166-1 alpha 2 code http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2
+    # * city 
+    # * region - use region 
+    # * latitude
+    # * longitude
+    #
+    # == Example
+    # 
+    # === Country with many timezones without position data. System will find location for Miami and then find timezone
+    # 
+    #  tz = TimeZone.new("US", "Miami", "Florida")
+    #  tz.timezone.name   #  "America/New_York"
+    #  tz.latitude        #   25.774265 
+    #  tz.longitude       #  -80.193658
+    #
+    # === Country with many timezones with position data. System will directly find timezone with position data
+    #
+    #  tz = TimeZone.new("US", "Miami", "Florida", 25.774265, -80.193658)
+    #  tz.timezone.name   #  "America/New_York"
+    #
+    # === Country with one timezone will not return location data 
+    #
+    #  tz = TimeZone.new("RS", "Novi Sad")
+    #  tz.timezone.name   #  "Europe/Belgrade"
+    #  tz.latitude        #   nil 
+    #  tz.longitude #   nil
+    #
+    #  
+    #
+    def initialize country_code, city, region=nil, latitude=nil, longitude=nil
+      @country_code = country_code.upcase
+      @city      = city
+      @region    = region
+      @latitude  = latitude
+      @longitude = longitude
+      timezone!
+    end
+
+   
+
+  
+    class << self
+
+      # Returns countries codes for countries with more then one timezone
+      def countries_with_many_tz
+        TZInfo::Country.all.select{|m| m.zones.count > 1}.map{|m| m.code}
+      end
+
+      # Detect timezone by country code city region and position data 
+      # Returns TZInfo object and raise errors
+      def get! country_code, city, region="", latitude=nil, longitude=nil
+        m = self.new country_code, city, region, latitude, longitude
+        m.timezone!
+      end
+
+      # Detect timezone by country code city region and position data 
+      # Returns TZInfo object and raise errors
+      def get country_code, city, region="", latitude=nil, longitude=nil
+        begin
+          m = self.new country_code, city, region, latitude, longitude
+          m.timezone
+        rescue Exception 
+          nil
+        end
+      end
+
+
+      # Detect timezone by latitude and longitude
+      # Returns TZInfo raise errors
+      def by_location! latitude, longitude
+        type = TZDetect::Configuration.service
+        case type
+        when :google
+          geocoder = GoogleParser.new(latitude, longitude)
+        when :geoname
+          geocoder = GeonameParser.new(latitude, longitude)
+        else
+          raise TZDetect::Error::Configuration, "wrong configuration for field type"
+        end
+        TZInfo::Timezone.get geocoder.timezone!
+      end
+
+
+      # Detect timezone by latitude and longitude
+      # Returns TZInfo object, if can't find timezone returns nil
+      def by_location latitude, longitude
+        begin
+          self.by_location! latitude, longitude
+        rescue Exception 
+          nil
+        end
+
+      end
+
+
+      # Detect timezone by latitude and longitude
+      # Returns TZInfo object, if can't find timezone returns nil
+      def get_location!(country_code, city, region=nil)
+        type = TZDetect::Configuration.service
+        case type
+        when :google
+          geocoder = GoogleGeocode.new(country_code, city, region)
+        when :geoname
+          geocoder = GeonameGeocode.new(country_code, city, region)
+        else
+          raise TZDetect::Error::Configuration, "wrong configuration for field type"
+        end
+        geocoder.position!
+      end
+
+    end
+
+    private 
+
+    def tz_name!
+      @timezone = self.class.by_location! @latitude, @longitude
+    end
+
+    def location_fetch!
+      location = self.class.get_location!(@country_code, @city, @region)
+      @latitude  = location.latitude
+      @longitude = location.longitude
+      @timezone  =  TZInfo::Timezone.get(location.timezone) unless location.timezone.nil?
+    end
+
+
+    def get_country! 
+      begin
+        return TZInfo::Country.get(@country_code)
+      rescue Exception => e
+        raise TZDetect::Error::Base, e
+      end
+    end
+    
+    # Returns TZInfo object with detected timezone information 
+    # can rise errors
+    def timezone!
+      if @timezone.nil?
+
+        tz =  get_country! 
+        # if country have only one zone then return that zone
+        if tz.zones.count == 1
+          @timezone = TZInfo::Timezone.get(tz.zones[0].name)
+        else
+          location_fetch! if @latitude.nil? or @longitude.nil?
+          # some services returns timezone when fetch location 
+          tz_name! if @timezone.nil?
+        end
+      end
+      return @timezone
+    end
+
+
+  end
+end
+

data/lib/TZDetect.rb

@@ -0,0 +1,5 @@
+require "tzdetect/version"
+require "tzdetect/zone"
+
+module TZDetect
+end

data/test/geoname_geocoder_test.rb

@@ -0,0 +1,37 @@
+require 'tzdetect'
+require 'test/unit'
+
+require 'helper'
+
+class TZDetect::ParserTest < Test::Unit::TestCase
+  include TZDetect
+  def test_no_configured_user  
+    assert_raises Error::GeoCoder do
+      geocoder =  GeonameGeocode.new("LL", "GDSAFDSAF")
+      geocoder.position!
+      
+    end
+
+  end
+  def test_geoname_get_location 
+    
+    assert_nothing_raised do
+      TZDetect::Configuration.username = GEONAME_USERNAME
+      geocoder =  GeonameGeocode.new("RS", "Novi Sad")
+      geocoder.position!
+      assert_instance_of Float, geocoder.latitude
+      assert_instance_of Float, geocoder.longitude
+    end
+  end
+
+  def test_geoname_wrong_location 
+    
+    assert_raises Error::GeoCoder do
+      TZDetect::Configuration.username = GEONAME_USERNAME
+      geocoder =  GeonameGeocode.new("LL", "tghyjukl")
+      geocoder.position!
+    end
+  end
+end
+
+

data/test/geoname_parser_test.rb

@@ -0,0 +1,37 @@
+require 'tzdetect'
+require 'test/unit'
+class TZDetect::ParserTest < Test::Unit::TestCase
+  include TZDetect
+  def test_geoname_parser_not_configured_username
+    assert_raises Error::Parser do
+      TZDetect::Configuration.username = nil
+      ge = TZDetect::GeonameParser.new(44.2, 22.0) 
+      ge.timezone!
+    end
+  end
+  def test_class_method 
+    assert_nothing_raised do
+      TZDetect::Configuration.username = GEONAME_USERNAME
+      ge = TZDetect::GeonameParser.timezone!(12.2, 25.0) 
+      ge.timezone!
+
+    end
+  end
+  def test_geoname_parser_bad_input
+    assert_raises Error::Parser do
+      ge = TZDetect::GeonameParser.new(44.2, "gthyju") 
+      ge.timezone!
+    end
+  end
+  def test_zones
+    TZDetect::Configuration.username = GEONAME_USERNAME
+    zones = {
+      "Europe/Belgrade"=> [44.2,22.0], 
+      "Africa/Tripoli" => [27.2,22.0],
+      "Africa/Johannesburg" => [-27.2,22.0]}
+    zones.each {|key, value|
+      assert_equal(key, TZDetect::GeonamParser.timezone!(value[0], value[1]))
+    }
+  end
+
+end

data/test/google_geocoder_test.rb

@@ -0,0 +1,26 @@
+require 'tzdetect'
+require 'test/unit'
+require 'helper'
+class TZDetect::ParserTest < Test::Unit::TestCase
+  include TZDetect
+  def test_get_location 
+    
+    assert_nothing_raised do
+      geocoder =  GoogleGeocode.new("RS", "Novi Sad")
+      geocoder.position!
+      assert_instance_of Float, geocoder.latitude
+      assert_instance_of Float, geocoder.longitude
+    end
+  end
+
+  def test_wrong_location 
+    
+    assert_raises Error::GeoCoder do
+      geocoder =  GoogleGeocode.new("LL", "rfgthjklfads f")
+      geocoder.position!
+
+    end
+  end
+end
+
+

data/test/google_parser_test.rb

@@ -0,0 +1,52 @@
+require 'tzdetect'
+require 'test/unit'
+
+require 'helper'
+class TZDetect::ParserTest < Test::Unit::TestCase
+  include TZDetect
+
+  def test_google_parser
+    assert_nothing_raised do
+      parsed =  TZDetect::GoogleParser.new(12.2, 25.0) 
+
+      parsed.timezone!
+      parsed =  TZDetect::GoogleParser.new(12, 25) 
+    end
+  end
+  def test_bad_inputs
+    assert_raises Error::Parser do
+      TZDetect::GoogleParser.new(12.2, "dd") 
+    end
+    assert_raises Error::Parser do
+      TZDetect::GoogleParser.new("dd", "tghyj") 
+    end
+    assert_raises Error::Parser do
+      TZDetect::GoogleParser.new(91, 1) 
+    end
+    assert_raises Error::Parser do
+      TZDetect::GoogleParser.new(89.99, 181.1) 
+    end
+
+    assert_raises Error::Parser do
+      TZDetect::GoogleParser.new(91.1, 181.1) 
+    end
+  end
+
+  def test_class_method 
+    assert_nothing_raised do
+       TZDetect::GoogleParser.timezone!(12.2, 25.0) 
+
+    end
+  end
+  def test_zones
+    zones = {
+      "Europe/Belgrade"=> [44.2,22.0], 
+      "Africa/Tripoli" => [27.2,22.0],
+      "Africa/Johannesburg" => [-27.2,22.0]}
+    zones.each {|key, value|
+      assert_equal(key, TZDetect::GoogleParser.timezone!(value[0], value[1]))
+    }
+  end
+
+end
+

data/test/helper.rb

@@ -0,0 +1 @@
+  GEONAME_USERNAME= "geoname"

data/test/main_functionality_test.rb

@@ -0,0 +1,89 @@
+require 'tzdetect'
+require 'test/unit'
+require 'helper'
+class TZDetect::MainTest < Test::Unit::TestCase
+  include TZDetect
+  def test_not_all_properties 
+    assert_raises ArgumentError do
+       TimeZone.new()
+    end
+    assert_raises ArgumentError do
+      TZDetect::Configuration.service = :geo
+    end
+  end
+  def test_geoname_get_location 
+    assert_nothing_raised do
+      TZDetect::Configuration.username = GEONAME_USERNAME
+      TZDetect::Configuration.service = :geoname
+      tz = TimeZone.new("RS", "Novi Sad")
+      m = tz.timezone
+      assert_kind_of  TZInfo::DataTimezone, m
+      assert_equal m.name, "Europe/Belgrade"
+    end
+  end
+  def test_google_get_location 
+    assert_nothing_raised do
+      TZDetect::Configuration.service = :google
+      tz = TimeZone.new("RS", "Novi Sad")
+      m = tz.timezone
+      assert_kind_of  TZInfo::DataTimezone, m
+      assert_equal m.name, "Europe/Belgrade"
+    end
+  end
+  def test_google_get_location_small_countyr 
+      TZDetect::Configuration.service = :google
+      tz = TimeZone.new("rs", "Novi Sad")
+      m = tz.timezone
+      assert_kind_of  TZInfo::DataTimezone, m
+      assert_equal m.name, "Europe/Belgrade"
+  end
+  def test_google_get_location_us_static 
+      TZDetect::Configuration.service = :google
+      tz = TimeZone.get_location!("US", "Miami", "Florida")
+      assert_kind_of  TZDetect::Position, tz
+  end
+  def test_google_get_location_us 
+      TZDetect::Configuration.service = :google
+      tz = TimeZone.new("US", "Miami", "Florida")
+      m = tz.timezone
+      assert_kind_of  TZInfo::DataTimezone, m
+      assert_equal  m.name, "America/New_York"
+  end
+  def test_geoname_get_location_us 
+      TZDetect::Configuration.service = :geoname
+      tz = TimeZone.new("US", "Miami", "Florida")
+      m = tz.timezone
+      assert_kind_of  TZInfo::DataTimezone, m
+      assert_equal  m.name, "America/New_York"
+  end
+  def test_wrong_country 
+    assert_raises Error::Base do
+      TZDetect::Configuration.service = :google
+      tz = TimeZone.new("ll", "burutifdas")
+      m = tz.timezone
+      assert_kind_of  tzinfo::datatimezone, m
+    end
+  end
+  def test_wrong_country_code_google 
+    assert_raises Error::Base do
+      TZDetect::Configuration.service = :geoname
+      tz = TimeZone.new("LL", "buruti")
+      tz.timezone
+    end
+  end
+  def test_static_by_location 
+      tz = TimeZone.by_location(44.21, 21.0)
+      assert_kind_of  TZInfo::DataTimezone, tz
+      assert_equal  tz.name, "Europe/Belgrade"
+  end
+
+  def test_static
+      m = TimeZone.get("rs", "Novi Sad")
+      assert_kind_of  TZInfo::DataTimezone, m
+      assert_equal m.name, "Europe/Belgrade"
+  end
+
+
+end
+
+

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: tzdetect
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- ! 'Bojan Milosavljevic '
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tzinfo
+  requirement: &70295667282600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.33
+  type: :runtime
+  prerelease: false
+  version_requirements: *70295667282600
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &70295667282140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70295667282140
+description: Detects  timezone by address or location using google or geoname web
+  service
+email:
+- milboj@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- TZDetect.gemspec
+- lib/TZDetect.rb
+- lib/TZDetect/configuration.rb
+- lib/TZDetect/error.rb
+- lib/TZDetect/geocoder.rb
+- lib/TZDetect/geocoders/geoname.rb
+- lib/TZDetect/geocoders/google.rb
+- lib/TZDetect/parser.rb
+- lib/TZDetect/parsers/geoname.rb
+- lib/TZDetect/parsers/google.rb
+- lib/TZDetect/version.rb
+- lib/TZDetect/zone.rb
+- test/geoname_geocoder_test.rb
+- test/geoname_parser_test.rb
+- test/google_geocoder_test.rb
+- test/google_parser_test.rb
+- test/helper.rb
+- test/main_functionality_test.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Easy way to detect time zone by  address or location
+test_files:
+- test/geoname_geocoder_test.rb
+- test/geoname_parser_test.rb
+- test/google_geocoder_test.rb
+- test/google_parser_test.rb
+- test/helper.rb
+- test/main_functionality_test.rb