TimezoneParser 0.1.0

data/lib/timezone_parser/data/tzinfo.rb

@@ -0,0 +1,151 @@
+# encoding: utf-8
+require 'tzinfo'
+require 'tzinfo/data/tzdataparser'
+require 'uri'
+require 'open-uri'
+require 'rubygems/package'
+require 'zlib'
+require 'yaml'
+require 'pathname'
+require 'timezone_parser/data'
+
+module TimezoneParser
+    # TZInfo module
+    module TZInfo
+
+        protected
+        @@Version = nil
+        @@TimezoneCountries = nil
+
+        public
+
+        # TZData source location
+        TZDataSource = 'ftp://ftp.iana.org/tz/tzdata-latest.tar.gz'
+        # Extracted TZData path
+        TZDataPath = TimezoneParser::Data::VendorDir + 'zoneinfo'
+        # TZInfo data path
+        TZInfoData = TimezoneParser::Data::VendorDir + 'tzinfo'
+        # Max Timestamp
+        LastTimestamp = 2147483647
+        def self.download(source = TZDataSource, location = TZDataPath, target = TZInfoData)
+            URI.parse(source).open do |tempfile|
+                FileUtils.mkdir_p(location)
+                tar = Gem::Package::TarReader.new(Zlib::GzipReader.open(tempfile.path))
+                tar.each do |entry|
+                    path = location + entry.full_name
+                    FileUtils.mkdir_p(path.dirname)
+                    if entry.file?
+                        File.open(path, 'wb') do |file|
+                            file.write(entry.read)
+                        end
+                    end
+                end
+                tar.close
+            end
+            parser = ::TZInfo::Data::TZDataParser.new(location, target)
+            parser.execute
+            getVersion(location)
+        end
+
+        def self.getVersion(source = TZDataPath)
+            return @@Version if @@Version
+            File.open(source + 'Makefile', 'r', { :encoding => 'UTF-8:UTF-8' }) do |file|
+                file.each_line do |line|
+                    line = line.gsub(/#.*$/, '')
+                    v = line.match(/^\s*VERSION\s*=\s*(\w+)\s*$/)
+                    @@Version = v[1] if v
+                end
+            end
+            @@Version
+        end
+
+        def self.init
+            ::TZInfo::DataSource.set(:ruby, TZInfoData)
+        end
+
+        def self.getTimezoneCountries
+            unless @@TimezoneCountries
+                @@TimezoneCountries = {}
+                ::TZInfo::Country.all.each do |countryData|
+                    countryData.zone_identifiers.each do |timezone|
+                        @@TimezoneCountries[timezone] ||= []
+                        @@TimezoneCountries[timezone] << countryData.code
+                        @@TimezoneCountries[timezone].uniq!
+                        @@TimezoneCountries[timezone].sort!
+                    end
+                end
+                @@TimezoneCountries = Hash[@@TimezoneCountries.to_a.sort_by { |pair| pair.first }]
+            end
+            @@TimezoneCountries
+        end
+
+        def self.getAbbreviations
+            transitionData = {}
+            ::TZInfo::Timezone.all_data_zone_identifiers.each do |name|
+                zone = ::TZInfo::Timezone.get(name)
+                zone_transitions = zone.transitions_up_to(Time.at(LastTimestamp))
+                zone_transitions.each_index do |i|
+                    offset = zone_transitions[i].offset
+                    next if offset.abbreviation == :LMT or offset.abbreviation == :zzz
+                    abbr = offset.abbreviation.to_s
+                    transitionData[abbr] = [] unless transitionData[abbr]
+                    period = ::TZInfo::TimezonePeriod.new(zone_transitions[i], zone_transitions[i+1])
+                    transitionData[abbr] << { :name => name, :period => period }
+                end
+            end
+            timezoneData = {}
+            transitionData.keys.sort.each do |name|
+                transitions = []
+                transitionData[name].each do |transition|
+                    period_start = transition[:period].utc_start
+                    period_start = period_start.to_s
+                    period_end = transition[:period].utc_end
+                    period_end = period_end.to_s if period_end
+                    timezone = transition[:name]
+                    countries = getTimezoneCountries[timezone]
+                    countries = countries.dup if countries
+                    data = { 'Offset' => transition[:period].utc_total_offset,  'Timezones' => [timezone], 'Countries' => countries, 'From' => period_start }
+                    data['To'] = period_end if period_end
+                    transitions << data
+                end
+                transitions.sort_by! { |data| [data['To'] ? data['To'] : 'zzzz', data['From']] }
+
+                abbreviationData = []
+                abbreviationData << transitions.shift
+                transitions.each do |data|
+                    current = abbreviationData.last
+                    if data['Offset'] == current['Offset'] and (current['Timezones'].sort == data['Timezones'].sort || (data['From'] == current['From'] and data['To'] == current['To']))
+                        current['Timezones'] += data['Timezones']
+                        current['Timezones'].uniq!
+                        current['Timezones'].sort!
+                        if data['Countries']
+                            current['Countries'] = current['Countries'].to_a + data['Countries']
+                            current['Countries'].uniq!
+                            current['Countries'].sort!
+                        end
+                        current['To'] = data['To']
+                        current.delete('To') unless current['To']
+                    else
+                        abbreviationData << data
+                    end
+                end
+                previous = nil
+                abbreviationData.delete_if do |item|
+                    if previous.nil?
+                        previous = item
+                        false
+                    elsif previous['Offset'] == item['Offset'] and previous['Timezones'] == item['Timezones']
+                        previous['To'] = item['To']
+                        previous.delete('To') unless previous['To']
+                        true
+                    else
+                        previous = item
+                        false
+                    end
+                end
+                timezoneData[name] = abbreviationData
+            end
+            timezoneData
+        end
+    end
+end

data/lib/timezone_parser/data/windows.rb

@@ -0,0 +1,124 @@
+# encoding: utf-8
+require 'win32/registry'
+require 'fiddle'
+
+module TimezoneParser
+    # Windows module
+    module Windows
+
+        protected
+
+        @@Version = nil
+        @@Errors = ''
+
+        public
+        # Windows Registry path to Time Zone data
+        TimeZonePath = 'SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones'
+        def self.errors
+            @@Errors
+        end
+
+        def self.getVersion(path = TimeZonePath)
+            return @@Version if @@Version
+            begin
+                Win32::Registry::HKEY_LOCAL_MACHINE.open(path, Win32::Registry::KEY_READ) do |reg|
+                    @@Version = reg['TzVersion', Win32::Registry::REG_DWORD].to_s(16)
+                end
+            rescue Win32::Registry::Error => e
+                @@Errors << e.message
+            end
+            @@Version
+        end
+
+        def self.getTimezones(path = TimeZonePath)
+            timezones = {}
+            begin
+                Win32::Registry::HKEY_LOCAL_MACHINE.open(path, Win32::Registry::KEY_READ).each_key do |key, wtime|
+                    Win32::Registry::HKEY_LOCAL_MACHINE.open(path + '\\' + key, Win32::Registry::KEY_READ) do |reg|
+                        timezones[key] ||= {}
+                        tzi = reg.read('TZI', Win32::Registry::REG_BINARY).last
+                        # TZI Structure (http://msdn.microsoft.com/en-us/library/windows/desktop/ms725481.aspx)
+                        # typedef struct _REG_TZI_FORMAT
+                        # {
+                        #    LONG Bias;
+                        #    LONG StandardBias;
+                        #    LONG DaylightBias;
+                        #    SYSTEMTIME StandardDate;
+                        #    SYSTEMTIME DaylightDate;
+                        # } REG_TZI_FORMAT;
+                        unpacked = tzi.unpack('lllSSSSSSSSSSSSSSSS')
+                        timezones[key]['standard'] = (0 - unpacked[0] - unpacked[1]) * 60
+                        timezones[key]['daylight'] = (0 - unpacked[0] - unpacked[2]) * 60
+                    end
+                end
+            rescue Win32::Registry::Error => e
+                @@Errors << e.message
+            end
+            timezones = Hash[timezones.to_a.sort_by { |d| d.first } ]
+            timezones
+        end
+
+        def self.getMUIOffsets(path = TimeZonePath)
+            offsets = {}
+            begin
+                Win32::Registry::HKEY_LOCAL_MACHINE.open(path, Win32::Registry::KEY_READ).each_key do |key, wtime|
+                    Win32::Registry::HKEY_LOCAL_MACHINE.open(path + '\\' + key, Win32::Registry::KEY_READ) do |reg|
+                        muiDlt = reg.read_s('MUI_Dlt')
+                        muiStd = reg.read_s('MUI_Std')
+
+                        offsets[self.parseMUI(muiDlt)] = ['daylight', key]
+                        offsets[self.parseMUI(muiStd)] = ['standard', key]
+                    end
+                end
+            rescue Win32::Registry::Error => e
+                @@Errors << e.message
+            end
+            puts @@Errors
+            offsets
+        end
+
+        def self.parseMUI(str)
+            str.split(',').last.to_i.abs
+        end
+
+        def self.parseMetazones(metazoneList, offsets)
+            metazones = {}
+            metazoneList.each do |lcid, data|
+                localeMem = Fiddle::Pointer.malloc(LOCALE_NAME_MAX_LENGTH)
+                chars = LCIDToLocaleName.call(lcid, localeMem, LOCALE_NAME_MAX_LENGTH, 0)
+                return nil if chars.zero?
+                locale = localeMem.to_s((chars-1)*2).force_encoding(Encoding::UTF_16LE).encode(Encoding::UTF_8)
+                metazones[locale] = {}
+                offsets.each do |id, info|
+                    name = data[id]
+                    metazones[locale][name] ||= {}
+                    metazones[locale][name]['Types'] ||= []
+                    metazones[locale][name]['Metazones'] ||= []
+                    metazones[locale][name]['Types'] << info.first
+                    metazones[locale][name]['Metazones'] << info.last
+                    metazones[locale][name]['Types'].uniq!
+                    metazones[locale][name]['Metazones'].uniq!
+                end
+                metazones[locale] = Hash[metazones[locale].to_a.sort_by { |d| d.first } ]
+            end
+            metazones = Hash[metazones.to_a.sort_by { |d| d.first } ]
+            metazones
+        end
+
+        # Windows Kernel32 library
+        kernel32 = Fiddle.dlopen('kernel32')
+
+        # function
+        # int LCIDToLocaleName (
+        # _In_       LCID Locale,
+        # _Out_opt_  LPWSTR lpName,
+        # _In_       int cchName,
+        # _In_       DWORD dwFlags
+        # );
+        # @see http://msdn.microsoft.com/en-us/library/windows/desktop/dd318698.aspx
+        LCIDToLocaleName = Fiddle::Function.new( kernel32['LCIDToLocaleName'],
+        [Fiddle::TYPE_LONG, Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT, Fiddle::TYPE_LONG], Fiddle::TYPE_INT )
+        # Max locale length
+        LOCALE_NAME_MAX_LENGTH = 85
+    end
+end

data/lib/timezone_parser/rails_zone.rb

@@ -0,0 +1,178 @@
+# encoding: utf-8
+
+module TimezoneParser
+    # Rails zone data
+    class RailsData < Data
+        protected
+        @RailsZone = nil
+
+        public
+        attr_reader :RailsZone
+        def processEntry(data, rails)
+            if rails
+                @RailsZone = rails
+                @Metazones << rails
+                @Timezones << data
+            else
+                rails = Storage.RailsZones[data]
+                if rails
+                    @RailsZone = data
+                    @Metazones << data
+                    @Timezones << rails
+                end
+            end
+            self
+        end
+    end
+
+    # Rails zone
+    class RailsZone < ZoneInfo
+        protected
+        @@Locales = []
+
+        public
+        # Locales which will be used for RailsZone methods if not specified there
+        #
+        # Each locale is language identifier based on IETF BCP 47 and ISO 639 code
+        # @return [Array<String>] list containing locale identifiers
+        # @see http://en.wikipedia.org/wiki/IETF_language_tag
+        def self.Locales
+            @@Locales
+        end
+
+        attr_accessor :All
+
+        # Rails zone instance
+        # @param name [String] Rails zone name
+        def initialize(name)
+            @Name = name
+            @Data = RailsData.new
+            @Valid = nil
+            setTime
+            set(@@Locales.dup, true)
+        end
+
+        # Set locales and all
+        # @param locales [Array<String>] search only in these locales
+        # @param all [Boolean] specify whether should search for all zones or return as soon as found any
+        # @return [RailsZone] self
+        # @see Locales
+        def set(locales = nil, all = true)
+            @Locales = locales unless locales.nil?
+            @All = all ? true : false
+            self
+        end
+
+        # Check if Rails zone is valid
+        # @return [Boolean] whether Rails zone is valid
+        def isValid?
+            if @Valid.nil?
+                @Valid = false
+                @Valid = Data::Storage.RailsZones.has_key?(@Name) if (not @Locales) or (@Locales and @Locales.include?('en'))
+                return @Valid if @Valid
+                locales = @Locales
+                locales = Data::Storage.RailsTranslated.keys if locales.empty?
+                locales.each do |locale|
+                    next unless Data::Storage.RailsTranslated.has_key?(locale)
+                    @Valid = Data::Storage.RailsTranslated[locale].has_key?(@Name)
+                    return @Valid if @Valid
+                end
+            end
+            @Valid = false
+        end
+
+        # Rails zone data
+        # @return [RailsData] data
+        def getData
+            unless @Loaded
+                @Loaded = true
+                @Valid = false
+                @Valid = Data::Storage.RailsZones.has_key?(@Name) if (not @Locales) or (@Locales and @Locales.include?('en'))
+                if @Valid
+                    @Data.processEntry(Data::Storage.RailsZones[@Name], @Name)
+                    return @Data unless @All
+                end
+                locales = @Locales
+                locales = Data::Storage.RailsTranslated.keys if locales.empty?
+                locales.each do |locale|
+                    next unless Data::Storage.RailsTranslated.has_key?(locale)
+                    entry = Data::Storage.RailsTranslated[locale][@Name]
+                    if entry
+                        @Data.processEntry(entry, false)
+                        @Valid = true
+                        return @Data unless @All
+                    end
+                end
+            end
+            @Data
+        end
+
+        # Get UTC offsets in seconds
+        # @return [Array<Fixnum>] list of timezone offsets in seconds
+        def getOffsets
+            if not @Offsets and not getTimezones.empty?
+                @Offsets = @Data.findOffsets(@ToTime, @FromTime).to_a
+            else
+                super
+            end
+            @Offsets
+        end
+
+        # Rails zone identifier
+        # @return [String] Rails zone identifier
+        def getZone
+            getData.RailsZone
+        end
+
+        # Check if given Rails zone name is a valid timezone
+        # @param name [String] Rails zone name
+        # @param locales [Array<String>] search zone name only for these locales
+        # @return [Boolean] whether Timezone is valid
+        # @see Locales
+        def self.isValid?(name, locales = nil)
+            self.new(name).set(locales).isValid?
+        end
+
+        # Get UTC offsets in seconds for given Rails zone name
+        # @param name [String] Rails zone name
+        # @param toTime [DateTime] look for offsets which came into effect before this date, exclusive
+        # @param fromTime [DateTime] look for offsets which came into effect at this date, inclusive
+        # @param locales [Array<String>] search zone name only for these locales
+        # @param all [Boolean] specify whether should search for all timezones or return as soon as found any
+        # @return [Array<Fixnum>] list of timezone offsets in seconds
+        # @see Locales
+        def self.getOffsets(name, toTime = nil, fromTime = nil, locales = nil, all = true)
+            self.new(name).setTime(toTime, fromTime).set(locales, all).getOffsets
+        end
+
+        # Get Timezone identifiers for given Rails zone name
+        # @param name [String] Rails zone name
+        # @param locales [Array<String>] search zone name only for these locales
+        # @param all [Boolean] specify whether should search for all timezones or return as soon as found any
+        # @return [Array<String>] list of timezone identifiers
+        # @see Locales
+        def self.getTimezones(name, locales = nil, all = true)
+            self.new(name).set(locales, all).getTimezones
+        end
+
+        # Get Metazone identifiers for given Rails zone name
+        # @param name [String] Rails zone name
+        # @param locales [Array<String>] search zone name only for these locales
+        # @param all [Boolean] specify whether should search for all timezones or return as soon as found any
+        # @return [Array<String>] list of metazone identifiers
+        # @see Locales
+        # @see Regions
+        def self.getMetazones(name, locales = nil, all = true)
+            self.new(name).set(locales, all).getMetazones
+        end
+
+        # Rails zone identifier
+        # @param name [String] Rails zone name
+        # @param locales [Array<String>] search zone name only for these locales
+        # @param all [Boolean] specify whether should search for all timezones or return as soon as found any
+        # @return [String] Timezone identifier
+        def self.getZone(name, locales = nil, all = true)
+            self.new(name).set(locales, all).getZone
+        end
+    end
+end