TimezoneParser 0.1.0

data/lib/timezone_parser/abbreviation.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+
+module TimezoneParser
+    # Timezone abbreviation
+    class Abbreviation < ZoneInfo
+        protected
+        @@Regions = []
+
+        public
+        # Regions which will be used for Abbreviation methods if not specified there
+        #
+        # Each region is either ISO 3166-1 alpha-2 code
+        # @return [Array<String>] list containing region identifiers
+        # @see http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2
+        def self.Regions
+            @@Regions
+        end
+
+        attr_accessor :Regions
+        attr_accessor :Type
+
+        # Abbreviation instance
+        # @param abbreviation [String] Timezone abbreviation
+        def initialize(abbreviation)
+            @Abbreviation = abbreviation
+            @Data = Data.new
+            setTime
+            set(@@Regions.dup, nil)
+        end
+
+        # Set regions and type
+        # @param regions [Array<String>] filter for these regions
+        # @param type [Symbol] filter by type, :standard time or :daylight
+        # @return [Abbreviation] self
+        # @see Regions
+        def set(regions = nil, type = nil)
+            @Regions = regions unless regions.nil?
+            @Type = type.to_sym if type
+            self
+        end
+
+        # Check if abbreviation is valid
+        # @return [Boolean] whether abbreviation is valid
+        def isValid?
+            Data::Storage.Abbreviations.has_key?(@Abbreviation)
+        end
+
+        # Abbreviation data
+        # @return [Data] data
+        def getData
+            unless @Loaded
+                @Loaded = true
+                if isValid?
+                    data = Data::Storage.Abbreviations[@Abbreviation]
+                    if data.count == 1
+                        @Data.processEntry(data.first, @ToTime, @FromTime, @Regions)
+                        return @Data
+                    end
+                    entries = Data.filterData(data, @ToTime, @FromTime, @Type, @Regions)
+                    entries.each do |entry|
+                        @Data.processEntry(entry, @ToTime, @FromTime, @Regions)
+                    end
+                    return @Data
+                end
+            end
+            @Data
+        end
+
+        # Get UTC offsets in seconds
+        # @return [Array<Fixnum>] list of timezone offsets in seconds
+        def getOffsets
+            unless @Offsets
+                @Offsets = getData.Offsets.to_a
+                if @Offsets.empty? and not getTimezones.empty?
+                    types = nil
+                    types = [@Type] if @Type
+                    @Offsets = @Data.findOffsets(@ToTime, @FromTime, @Regions, types).to_a
+                end
+            end
+            @Offsets
+        end
+
+        # Check if given Timezone abbreviation is a valid timezone
+        # @param abbreviation [String] Timezone abbreviation
+        # @return [Boolean] whether Timezone is valid
+        def self.isValid?(abbreviation)
+            Data::Storage.Abbreviations.has_key?(abbreviation)
+        end
+
+        # Get UTC offsets in seconds for given Timezone abbreviation
+        # @param abbreviation [String] Timezone abbreviation
+        # @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 regions [Array<String>] look for offsets only for these regions
+        # @param type [Symbol] specify whether offset should be :standard time or :daylight
+        # @return [Array<Fixnum>] list of timezone offsets in seconds
+        # @see Regions
+        def self.getOffsets(abbreviation, toTime = nil, fromTime = nil, regions = nil, type = nil)
+            self.new(abbreviation).setTime(toTime, fromTime).set(regions, type).getOffsets
+        end
+
+        # Get Timezone identifiers for given Timezone abbreviation
+        # @param abbreviation [String] Timezone abbreviation
+        # @param toTime [DateTime] look for timezones which came into effect before this date, exclusive
+        # @param fromTime [DateTime] look for timezones which came into effect at this date, inclusive
+        # @param regions [Array<String>] look for timezones only for these regions
+        # @param type [Symbol] specify whether timezones should be :standard time or :daylight
+        # @return [Array<String>] list of timezone identifiers
+        # @see Regions
+        def self.getTimezones(abbreviation, toTime = nil, fromTime = nil, regions = nil, type = nil)
+            self.new(abbreviation).setTime(toTime, fromTime).set(regions, type).getTimezones
+        end
+
+        # Get Metazone identifiers for given Timezone abbreviation
+        # @param abbreviation [String] Timezone abbreviation
+        def self.getMetazones(abbreviation)
+            self.new(abbreviation).getMetazones
+        end
+    end
+end

data/lib/timezone_parser/data.rb

@@ -0,0 +1,121 @@
+# encoding: utf-8
+require 'pathname'
+require 'set'
+require 'tzinfo'
+require 'timezone_parser/data/storage'
+
+module TimezoneParser
+    # Timezone data
+    class Data
+        # Library Root directory
+        RootDir = Pathname.new(__FILE__).realpath.dirname.parent.parent
+        # Path to Data directory
+        DataDir = RootDir + 'data'
+        # Path to Vendor directory
+        VendorDir = RootDir + 'vendor'
+
+        attr_reader :Offsets
+        attr_reader :Timezones
+        attr_reader :Types
+        attr_reader :Metazones
+        def initialize
+            @Offsets = SortedSet.new
+            @Timezones = SortedSet.new
+            @Types = SortedSet.new
+            @Metazones = SortedSet.new
+        end
+
+        def processEntry(entry, toTime, fromTime, regions = [])
+            @Timezones += entry['Timezones'] if entry['Timezones']
+            @Offsets << entry['Offset'] if entry['Offset']
+            @Types += entry['Types'].map(&:to_sym) if entry['Types']
+            if entry.has_key?('Metazones')
+                entry['Metazones'].each do |zone|
+                    @Metazones << zone
+                    @Timezones += Storage.getTimezones(zone, toTime, fromTime, regions)
+                end
+            end
+            self
+        end
+
+        def findOffsets(toTime, fromTime, regions = nil, types = nil)
+            types = @Types.to_a unless types
+            types = [:daylight, :standard] if types.empty?
+            @Timezones.each do |timezone|
+                if regions and not regions.empty?
+                    timezoneRegions = Data::Storage.TimezoneCountries[timezone]
+                    next if timezoneRegions and (timezoneRegions & regions).empty?
+                end
+                begin
+                    tz = TZInfo::Timezone.get(timezone)
+                rescue TZInfo::InvalidTimezoneIdentifier
+                    tz = nil
+                end
+                next unless tz
+                offsets = []
+                ts = false
+                tz.transitions_up_to(toTime, fromTime).each do |transition|
+                    ts = true
+                    self.class.addOffset(offsets, transition.offset, types)
+                end
+                self.class.addOffset(offsets, tz.period_for_utc(toTime - 0.001).offset, types) unless ts
+                @Offsets += offsets
+            end
+            @Offsets
+        end
+
+        # Load data entries which match specified time
+        # @param data [Array<Hash>] array of entries
+        # @param toTime [DateTime] entries before this date, exclusive
+        # @param fromTime [DateTime] entries after/at this date, inclusive
+        # @return [Array<Hash>] resulting array containing filtered entries
+        def self.loadEntries(data, toTime, fromTime, offsets = false)
+            result = []
+            data.each do |entry|
+                result << entry if (entry['From'] && entry['To'] and toTime > entry['From'] and fromTime < entry['To']) or
+                (entry['From'] && !entry['To'] and toTime > entry['From']) or
+                (!entry['From'] && entry['To'] and fromTime < entry['To']) or
+                (!entry['From'] && !entry['To'])
+            end
+            result.each do |entry|
+                return result if not offsets or (offsets and entry['Offset'])
+            end
+            data.each_index do |i|
+                entry = data[i]
+                nextentry = offsets ? getNextEntry(data, i) : data[i+1]
+                result << entry if ( entry['From'] && entry['To'] and toTime > entry['From'] and fromTime < entry['To'] ) or
+                ( entry['To'] and ( (nextentry.nil? and fromTime >= entry['To']) or
+                (nextentry and nextentry['From'] and fromTime >= entry['To'] and toTime <= nextentry['From']) or
+                (!entry['From'] and fromTime < entry['To']) ) ) or
+                ( entry['From'] and ( (i.zero? and toTime <= entry['From']) or (!entry['To'] and toTime > entry['From']) ) )
+            end
+            result
+        end
+
+        def self.filterData(data, toTime, fromTime, type, regions)
+            entries = []
+            data.each do |entry|
+                next if type and entry['Types'] and not entry['Types'].include?(type)
+                next if not regions.empty? and entry['Countries'] and (entry['Countries'] & regions).empty?
+                entries << entry
+            end
+            loadEntries(entries, toTime, fromTime, true)
+        end
+
+        protected
+
+        def self.getNextEntry(data, i)
+            j = 1
+            begin
+                entry = data[i+j]
+                j += 1
+            end until entry.nil? or (entry and entry['Offset'])
+            entry
+        end
+
+        def self.addOffset(offsets, offset, types)
+            offsets << offset.utc_total_offset if (offset.dst? and types.include?(:daylight)) or (not offset.dst? and types.include?(:standard))
+        end
+
+    end
+end

data/lib/timezone_parser/data/cldr.rb

@@ -0,0 +1,175 @@
+# encoding: utf-8
+require 'cldr'
+require 'cldr/download'
+require 'cldr/export/data'
+require 'cldr/export/data/timezones'
+require 'pathname'
+
+module TimezoneParser
+    # CLDR module
+    module CLDR
+
+        # Data directory
+        DataDir = Pathname.new(Cldr::Export::Data.dir)
+
+        protected
+        @@Version = nil
+
+        public
+        def self.download(source = 'http://unicode.org/Public/cldr/latest/core.zip', target = nil)
+            Cldr.download(source, target)
+        end
+
+        def self.updateHash(hash, name, data)
+            hash[name] ||= []
+            hash[name] << data.to_s
+            hash[name].uniq!
+            hash[name].sort!
+            hash
+        end
+
+        def self.getVersion(source = DataDir)
+            return @@Version if @@Version
+            content = File.read(source + 'dtd' + 'ldml.dtd')
+            content.gsub!(/<!--.*?-->/, '')
+            data = content.match(/\s+cldrVersion\s+[\#\w\s]+\s+"(\d+)"\s*\>/)
+            @@Version = data[1].to_i if data
+            @@Version
+        end
+
+        def self.getTimezones
+            timezones = { }
+            Cldr::Export::Data.locales.sort.each do |locale|
+                tz = Cldr::Export::Data::Timezones.new(locale)
+                next if tz.timezones.empty? and tz.metazones.empty?
+
+                tz.timezones.each do |timezone, data|
+                    next if timezone == :'Etc/Unknown' or data[:city].nil?
+                    city = data[:city].to_s.encode(Encoding::UTF_8).chomp.strip
+                    timezones[locale] ||= {}
+                    timezones[locale][city] ||= {}
+                    self.updateHash(timezones[locale][city], 'Timezones', timezone)
+                    data[:long].to_a.each do |type, name|
+                        name = name.to_s.encode(Encoding::UTF_8).chomp.strip
+                        type = type.to_s.encode(Encoding::UTF_8)
+                        timezones[locale][name] ||= {}
+                        if type == 'generic'
+                            self.updateHash(timezones[locale][name], 'Types', 'standard')
+                            self.updateHash(timezones[locale][name], 'Types', 'daylight')
+                        else
+                            self.updateHash(timezones[locale][name], 'Types', type)
+                        end
+                        self.updateHash(timezones[locale][name], 'Timezones', timezone.to_s.encode(Encoding::UTF_8))
+                    end
+                end
+                tz.metazones.each do |metazone, data|
+                    data[:long].to_a.each do |type, name|
+                        name = name.to_s.encode(Encoding::UTF_8).chomp.strip
+                        next if name.empty?
+                        type = type.to_s.encode(Encoding::UTF_8)
+                        timezones[locale] ||= {}
+                        timezones[locale][name] ||= {}
+                        if type == 'generic'
+                            self.updateHash(timezones[locale][name], 'Types', 'standard')
+                            self.updateHash(timezones[locale][name], 'Types', 'daylight')
+                        else
+                            self.updateHash(timezones[locale][name], 'Types', type)
+                        end
+                        self.updateHash(timezones[locale][name], 'Metazones', metazone.to_s.encode(Encoding::UTF_8))
+                    end
+                end
+                timezones[locale] = Hash[timezones[locale].to_a.sort_by { |d| d.first } ] if timezones[locale]
+            end
+            timezones
+        end
+
+        def self.updateAbbreviations(abbreviations)
+            Cldr::Export::Data.locales.sort.each do |locale|
+                tz = Cldr::Export::Data::Timezones.new(locale)
+                next if tz.timezones.empty? and tz.metazones.empty?
+                tz.timezones.each do |timezone, data|
+                    data[:short].to_a.each do |type, name|
+                        next if name == '∅∅∅'
+                        name = name.chomp.strip
+                        type = type.to_s.encode(Encoding::UTF_8)
+                        abbreviations[name] ||= []
+                        data = {}
+                        add = true
+                        abbreviations[name].each_index do |i|
+                            next unless abbreviations[name][i]['Offset'].nil?
+                            data = abbreviations[name][i]
+                            add = false
+                            break
+                        end
+                        if type == 'generic'
+                            self.updateHash(data, 'Types', 'standard')
+                            self.updateHash(data, 'Types', 'daylight')
+                        else
+                            self.updateHash(data, 'Types', type)
+                        end
+                        self.updateHash(data, 'Timezones', timezone)
+                        abbreviations[name] << data if add
+                    end
+                end
+                tz.metazones.each do |metazone, data|
+                    data[:short].to_a.each do |type, name|
+                        next if name == '∅∅∅'
+                        name = name.chomp.strip
+                        type = type.to_s.encode(Encoding::UTF_8)
+                        abbreviations[name] ||= []
+                        data = {}
+                        add = true
+                        abbreviations[name].each_index do |i|
+                            next unless abbreviations[name][i]['Offset'].nil?
+                            data = abbreviations[name][i]
+                            add = false
+                            break
+                        end
+                        if type == 'generic'
+                            self.updateHash(data, 'Types', 'standard')
+                            self.updateHash(data, 'Types', 'daylight')
+                        else
+                            self.updateHash(data, 'Types', type)
+                        end
+                        self.updateHash(data, 'Metazones', metazone)
+                        abbreviations[name] << data if add
+                    end
+                end
+            end
+            abbreviations = Hash[abbreviations.to_a.sort_by { |d| d.first } ]
+            abbreviations
+        end
+
+        def self.getMetazones
+            zones = {}
+            Cldr::Export::Data::Metazones.new[:timezones].each do |timezone, zonedata|
+                zonedata.each do |data|
+                    entry = {}
+                    add = true
+                    zones[data['metazone']] ||= []
+                    zones[data['metazone']].each_index do |i|
+                        next if zones[data['metazone']][i]['From'].to_s != data['from'].to_s or zones[data['metazone']][i]['To'].to_s != data['to'].to_s
+                        entry = zones[data['metazone']][i]
+                        add = false
+                        break
+                    end
+                    self.updateHash(entry, 'Timezones', timezone)
+                    if add
+                        entry['From'] = data['from'].to_s if data['from']
+                        entry['To'] = data['to'].to_s if data['to']
+                        zones[data['metazone']] << entry
+                    end
+                    zones[data['metazone']].sort_by! { |d| [d['To'] ? d['To'] : 'zzzz', d['From'] ? d['From'] : ''] }
+                end
+            end
+            zones = Hash[zones.to_a.sort_by { |d| d.first } ]
+            zones
+        end
+
+        def self.getWindowsZones
+            zones = Cldr::Export::Data::WindowsZones.new
+            zones = Hash[zones.to_a.sort_by { |d| d.first } ]
+            zones
+        end
+    end
+end

data/lib/timezone_parser/data/storage.rb

@@ -0,0 +1,172 @@
+# encoding: utf-8
+require 'yaml'
+require 'date'
+require 'insensitive_hash'
+
+module TimezoneParser
+    class Data
+        # Timezone data Storage class
+        class Storage
+            protected
+            @@Abbreviations = nil
+            @@Timezones = nil
+            @@TimezoneCountries = nil
+            @@Metazones = nil
+            @@WindowsZones = nil
+            @@WindowsTimezones = nil
+            @@WindowsOffsets = nil
+            @@RailsZones = nil
+            @@RailsTranslated = nil
+
+            public
+            def self.Abbreviations
+                unless @@Abbreviations
+                    @@Abbreviations = Marshal.load(File.open(Data::DataDir + 'abbreviations.dat')).insensitive
+                    @@Abbreviations.each do |abbr, data|
+                        proccessData(data)
+                    end
+                end
+                @@Abbreviations
+            end
+
+            def self.Timezones
+                unless @@Timezones
+                    @@Timezones = Marshal.load(File.open(Data::DataDir + 'timezones.dat')).insensitive
+                end
+                @@Timezones
+            end
+
+            def self.TimezoneCountries
+                unless @@TimezoneCountries
+                    @@TimezoneCountries = Marshal.load(File.open(Data::DataDir + 'countries.dat')).insensitive
+                end
+                @@TimezoneCountries
+            end
+
+            def self.Metazones
+                unless @@Metazones
+                    @@Metazones = Marshal.load(File.open(Data::DataDir + 'metazones.dat')).insensitive
+                    @@Metazones.each do |zone, data|
+                        proccessData(data)
+                    end
+                end
+                @@Metazones
+            end
+
+            def self.WindowsZones
+                unless @@WindowsZones
+                    @@WindowsZones = Marshal.load(File.open(Data::DataDir + 'windows_zonenames.dat')).insensitive
+                end
+                @@WindowsZones
+            end
+
+            def self.WindowsTimezones
+                unless @@WindowsTimezones
+                    @@WindowsTimezones = Marshal.load(File.open(Data::DataDir + 'windows_timezones.dat')).insensitive
+                end
+                @@WindowsTimezones
+            end
+
+            def self.WindowsOffsets
+                unless @@WindowsOffsets
+                    @@WindowsOffsets = Marshal.load(File.open(Data::DataDir + 'windows_offsets.dat')).insensitive
+                end
+                @@WindowsOffsets
+            end
+
+            def self.RailsZones
+                unless @@RailsZones
+                    @@RailsZones = Marshal.load(File.open(Data::DataDir + 'rails.dat')).insensitive
+                end
+                @@RailsZones
+            end
+
+            def self.RailsTranslated
+                unless @@RailsTranslated
+                    @@RailsTranslated = Marshal.load(File.open(Data::DataDir + 'rails_i18n.dat')).insensitive
+                end
+                @@RailsTranslated
+            end
+
+            def self.preload(modules)
+                preloaded = false
+                modules.each do |m|
+                    case m
+                    when :Abbreviations
+                        self.Abbreviations
+                        self.Metazones
+                        preloaded = true
+                    when :Timezones
+                        self.Timezones
+                        self.Metazones
+                        preloaded = true
+                    when :WindowsZones
+                        self.WindowsZones
+                        self.WindowsTimezones
+                        self.WindowsOffsets
+                        preloaded = true
+                    when :RailsZones
+                        self.RailsZones
+                        self.RailsTranslated
+                        preloaded = true
+                    end
+                end
+                preloaded
+            end
+
+            def self.getTimezones(metazone, toTime, fromTime, regions = [])
+                timezones = SortedSet.new
+                if self.Metazones.has_key?(metazone)
+                    entries = Data::loadEntries(self.Metazones[metazone], toTime, fromTime)
+                    entries.each do |entry|
+                        add = true
+                        timezones += entry['Timezones'].select do |timezone|
+                            if regions.empty?
+                                true
+                            else
+                                timezoneRegions = self.TimezoneCountries[timezone]
+                                timezoneRegions && !(regions & timezoneRegions).empty?
+                            end
+                        end
+                    end
+                end
+                timezones
+            end
+
+            def self.getTimezones2(zone, regions = [])
+                timezones = SortedSet.new
+                if self.WindowsTimezones.has_key?(zone)
+                    entries = self.WindowsTimezones[zone]
+                    regions = entries.keys if regions.empty?
+                    regions.each do |region|
+                        next unless entries.has_key?(region)
+                        timezones += entries[region]
+                    end
+                end
+                timezones
+            end
+
+            def self.getOffsets(zone, types = [])
+                offsets = SortedSet.new
+                if self.WindowsOffsets.has_key?(zone)
+                    data = self.WindowsOffsets[zone]
+                    types = [:standard, :daylight] if types.empty?
+                    types.each do |type|
+                        next unless data.has_key?(type)
+                        offsets << data[type]
+                    end
+                end
+                offsets
+            end
+
+            protected
+
+            def self.proccessData(data)
+                data.each do |entry|
+                    entry['From'] = DateTime.parse(entry['From']) if entry['From']
+                    entry['To'] = DateTime.parse(entry['To']) if entry['To']
+                end
+            end
+        end
+    end
+end