TimezoneParser 0.4.0 → 1.0.0

data/lib/timezone_parser/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 module TimezoneParser
     # Version
-    VERSION = '0.4.0'
+    VERSION = '1.0.0'
 end

data/lib/timezone_parser/windows_zone.rb

@@ -1,27 +1,6 @@
 # encoding: utf-8
 
 module TimezoneParser
-    # Windows Timezone data
-    class WindowsData < Data
-        protected
-        @WindowsZone = nil
-
-        public
-        attr_reader :WindowsZone
-        def processEntry(entry, region)
-            @Types += entry['Types'] if entry['Types']
-            if entry.has_key?('Metazones')
-                entry['Metazones'].each do |zone|
-                    @WindowsZone = zone
-                    @Metazones << zone
-                    @Timezones += Storage.getTimezones2(zone, region)
-                    @Offsets += Storage.getOffsets(zone, entry['Types'])
-                end
-            end
-            self
-        end
-    end
-
     # Windows Timezone
     class WindowsZone < ZoneInfo
         protected
@@ -49,28 +28,24 @@ module TimezoneParser
 
         attr_accessor :Locales
         attr_accessor :Regions
-        attr_accessor :All
 
         # Windows Timezone instance
         # @param name [String] Windows Timezone name
         def initialize(name)
             @Name = name
-            @Data = WindowsData.new
             @Valid = nil
-            set(@@Locales.dup, @@Regions.dup, true)
+            set(@@Locales.dup, @@Regions.dup)
         end
 
-        # Set locales, regions and all
+        # Set locales and regions
         # @param locales [Array<String>] search only in these locales
         # @param regions [Array<String>] filter for these regions
-        # @param all [Boolean] specify whether should search for all timezones or return as soon as found any
         # @return [WindowsZone] self
         # @see Locales
         # @see Regions
-        def set(locales = nil, regions = nil, all = true)
+        def set(locales = nil, regions = nil)
             @Locales = locales unless locales.nil?
             @Regions = regions unless regions.nil?
-            @All = all ? true : false
             self
         end
 
@@ -78,42 +53,31 @@ module TimezoneParser
         # @return [Boolean] whether timezone is valid
         def isValid?
             if @Valid.nil?
-                locales = @Locales
-                locales = Data::Storage.WindowsZones.keys if locales.empty?
-                locales.each do |locale|
-                    next unless Data::Storage.WindowsZones.has_key?(locale)
-                    @Valid = Data::Storage.WindowsZones[locale].has_key?(@Name)
-                    return @Valid if @Valid
+                params = []
+                joins = ''
+                where = ''
+
+                if not @Locales.empty?
+                    joins += ' LEFT JOIN `Locales` AS L ON TN.Locale = L.ID'
+                    where = 'L.Name COLLATE NOCASE IN (' + Array.new(@Locales.count, '?').join(',') + ') AND '
+                    params += @Locales
                 end
-            end
-            @Valid = false
-        end
 
-        # Windows Timezone data
-        # @return [WindowsData] data
-        def getData
-            unless @Loaded
-                @Loaded = true
-                @Valid = false
-                locales = @Locales
-                locales = Data::Storage.WindowsZones.keys if locales.empty?
-                locales.each do |locale|
-                    next unless Data::Storage.WindowsZones.has_key?(locale)
-                    entry = Data::Storage.WindowsZones[locale][@Name]
-                    if entry
-                        @Data.processEntry(entry, @Regions)
-                        @Valid = true
-                        return @Data unless @All
-                    end
-                end
+                sql = "SELECT 1 FROM `WindowsZoneNames` TN #{joins} WHERE #{where}TN.`NameLowercase` = ? LIMIT 1"
+                params << @Name.downcase
+
+                @Valid = Data::Storage.getStatement(sql).execute(*params).count > 0
             end
-            @Data
+            @Valid
         end
 
         # Windows Timezone identifier
         # @return [String] Timezone identifier
         def getZone
-            getData.WindowsZone
+            unless @Zone
+                @Zone = self.getFilteredData(:Zone).first
+            end
+            @Zone
         end
 
         # Check if given Windows Timezone name is a valid timezone
@@ -128,42 +92,108 @@ module TimezoneParser
         # Get UTC offsets in seconds for given Windows Timezone name
         # @param name [String] Windows Timezone name
         # @param locales [Array<String>] search Timezone 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, locales = nil, all = true)
-            self.new(name).set(locales, nil, all).getOffsets
+        def self.getOffsets(name, locales = nil)
+            self.new(name).set(locales, nil).getOffsets
         end
 
         # Get Timezone identifiers for given Windows Timezone name
         # @param name [String] Windows Timezone name
         # @param locales [Array<String>] search Timezone name only for these locales
         # @param regions [Array<String>] look for timezones only for these regions
-        # @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
         # @see Regions
-        def self.getTimezones(name, locales = nil, regions = nil, all = true)
-            self.new(name).set(locales, regions, all).getTimezones
+        def self.getTimezones(name, locales = nil, regions = nil)
+            self.new(name).set(locales, regions).getTimezones
         end
 
         # Get Metazone identifiers for given Windows Timezone name
         # @param name [String] Windows Timezone name
         # @param locales [Array<String>] search Timezone 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
-        def self.getMetazones(name, locales = nil, all = true)
-            self.new(name).set(locales, nil, all).getMetazones
+        def self.getMetazones(name, locales = nil)
+            self.new(name).set(locales, nil).getMetazones
         end
 
         # Windows Timezone identifier
         # @param name [String] Windows Timezone name
         # @param locales [Array<String>] search Timezone 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, nil, all).getZone
+        def self.getZone(name, locales = nil)
+            self.new(name).set(locales, nil).getZone
         end
+
+        protected
+
+        def getFilteredData(dataType)
+            params = []
+            column = nil
+            joins = ''
+            regionJoins = ''
+            useRegionFilter = !@Regions.nil? && !@Regions.empty?
+            case dataType
+            when :Zone
+                column = '`WindowsZones`.`Name`'
+                joins += ' LEFT JOIN `WindowsZoneName_Zones` AS NameZones ON NameZones.Name = ZN.ID'
+                joins += ' INNER JOIN `WindowsZones` ON WindowsZones.ID = NameZones.Zone'
+            when :Offsets
+                column = '`WindowsZones`.`Standard`, `WindowsZones`.`Daylight`, ZN.`Types`'
+                joins += ' LEFT JOIN `WindowsZoneName_Zones` AS NameZones ON NameZones.Name = ZN.ID'
+                joins += ' INNER JOIN `WindowsZones` ON WindowsZones.ID = NameZones.Zone'
+            when :Timezones
+                column = '`Timezones`.`Name`'
+                joins += ' LEFT JOIN `WindowsZoneName_Zones` AS NameZones ON NameZones.Name = ZN.ID'
+                joins += ' INNER JOIN `WindowsZone_Timezones` ZoneTimezones ON ZoneTimezones.Zone = NameZones.Zone'
+                joins += ' INNER JOIN `Timezones` ON ZoneTimezones.Timezone = Timezones.ID'
+                regionJoins += ' LEFT JOIN `Territories` ON ZoneTimezones.Territory = Territories.ID'
+            when :Metazones
+                raise StandardError, "Metazones is not implemented!"
+            when :Types
+                column = 'ZN.`Types`'
+                useRegionFilter = false
+            else
+                raise StandardError, "Unkown dataType '#{dataType}'"
+            end
+
+            if not @Locales.empty?
+                joins += ' LEFT JOIN `Locales` AS L ON ZN.Locale = L.ID'
+                where = 'L.Name COLLATE NOCASE IN (' + Array.new(@Locales.count, '?').join(',')  + ') AND '
+                params += @Locales
+            end
+
+            sql = 'SELECT DISTINCT ' + column + ' FROM `WindowsZoneNames` AS ZN'
+            sql += joins
+            if useRegionFilter
+                sql += regionJoins
+            end
+
+            sql += " WHERE #{where}ZN.NameLowercase = ?"
+            params << @Name.downcase
+
+            if useRegionFilter
+                sql += ' AND Territories.Territory IN (' + Array.new(@Regions.count, '?').join(',')  + ')'
+                params += @Regions
+            end
+            sql += ' ORDER BY ' + column
+
+            if dataType == :Offsets
+                allOffsets = Set.new
+                Data::Storage.getStatement(sql).execute(*params).each do |row|
+                    allOffsets << row[0] if not (row.last & 0x01).zero?
+                    allOffsets << row[1] if not (row.last & 0x02).zero?
+                end
+                result = allOffsets.sort
+            else
+                result = Data::Storage.getStatement(sql).execute(*params).collect { |row| row.first }
+                if dataType == :Types
+                    result = self.class.convertTypes(result)
+                end
+            end
+            result
+        end
+
     end
 end

data/lib/timezone_parser/zone_info.rb

@@ -4,13 +4,18 @@ module TimezoneParser
     # Generic Timezone class
     class ZoneInfo
         protected
-        @Data = nil
-        @Loaded = false
         @Offsets = nil
         @Timezones = nil
         @Metazones = nil
+        @TimezoneTypes = nil
+        @ToTime = nil
+        @FromTime = nil
 
         public
+
+        TIMEZONE_TYPE_STANDARD = 0x01
+        TIMEZONE_TYPE_DAYLIGHT = 0X02
+
         attr_accessor :ToTime
         attr_accessor :FromTime
         # Set time range
@@ -25,16 +30,12 @@ module TimezoneParser
             self
         end
 
-        # Get Timezone data
-        def getData
-            raise StandardError, '#getData must be implemented in subclass'
-        end
 
         # Get UTC offsets in seconds
         # @return [Array<Fixnum>] list of timezone offsets in seconds
         def getOffsets
             unless @Offsets
-                @Offsets = getData.Offsets.to_a
+                @Offsets = self.getFilteredData(:Offsets)
             end
             @Offsets
         end
@@ -43,28 +44,98 @@ module TimezoneParser
         # @return [Array<String>] list of timezone identifiers
         def getTimezones
             unless @Timezones
-                @Timezones = getData.Timezones.to_a
+                @Timezones = self.getFilteredData(:Timezones)
             end
             @Timezones
         end
 
-        # Get types
-        # @return [Symbol] types
-        def getTypes
-            unless @Types
-                @Types = getData.Types.to_a
-            end
-            @Types
-        end
-
         # Get Metazone identifiers
         # @return [Array<String>] list of Metazone identifiers
         def getMetazones
             unless @Metazones
-                @Metazones = getData.Metazones.to_a
+                @Metazones = self.getFilteredData(:Metazones)
             end
             @Metazones
         end
 
+        # Get Types
+        # @return [Array<Symbol>] list of types
+        def getTypes
+            unless @TimezoneTypes
+                @TimezoneTypes = self.getFilteredData(:Types)
+            end
+            @TimezoneTypes
+        end
+
+        # Reset cached result
+        def reset
+            @Offsets = nil
+            @Timezones = nil
+            @Metazones = nil
+            @TimezoneTypes = nil
+            @ToTime = nil
+            @FromTime = nil
+        end
+
+        protected
+
+        def getFilteredData(dataType)
+            raise StandardError, '#getFilteredData must be implemented in subclass'
+        end
+
+        def self.findOffsets(timezones, toTime, fromTime, types = nil)
+            toTime = Time.now unless toTime
+            types = types.to_a unless types
+            types = [:daylight, :standard] if types.empty?
+            allOffsets = Set.new
+            timezones.each do |timezone|
+                begin
+                    tz = TZInfo::Timezone.get(timezone)
+                rescue TZInfo::InvalidTimezoneIdentifier
+                    tz = nil
+                end
+                next unless tz
+                offsets = []
+                self.addOffset(offsets, tz.period_for_utc(fromTime).offset, types)
+                tz.transitions_up_to(toTime, fromTime).each do |transition|
+                    self.addOffset(offsets, transition.offset, types)
+                end
+                allOffsets += offsets
+            end
+            allOffsets.sort
+        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
+
+        def self.convertTypes(rawTypes)
+            types = Set.new
+            rawTypes.each do |t|
+                types << :standard unless (t.to_i & TIMEZONE_TYPE_STANDARD).zero?
+                types << :daylight unless (t.to_i & TIMEZONE_TYPE_DAYLIGHT).zero?
+            end
+            types.sort
+        end
+
+        def self.findOffsetsFromTimezonesTypes(timezonesTypes, toTime, fromTime, types)
+            timezones = Set.new
+            timezoneTypes = Set.new
+            timezonesTypes.each do |timezoneType|
+                timezones << timezoneType[0]
+                timezoneTypes << timezoneType[1]
+            end
+
+            timezoneTypes = self.convertTypes(timezoneTypes)
+
+            if not types.nil? and not types.empty? and not timezoneTypes.empty?
+               types &= timezoneTypes
+            elsif not timezoneTypes.empty?
+               types = timezoneTypes
+            end
+
+            self.findOffsets(timezones, toTime, fromTime, types).sort
+        end
+
     end
 end

data/spec/abbreviation_spec.rb

@@ -76,7 +76,7 @@ describe TimezoneParser do
 
         describe '#getTimezones' do
             it 'should return all timezones for KMT abbreviation' do
-                expect(TimezoneParser::Abbreviation.new('KMT').getTimezones).to eq(['Europe/Kiev'])
+                expect(TimezoneParser::Abbreviation.new('KMT').setTime(DateTime.parse('1920-01-01T00:00:00+00:00')).getTimezones).to eq(['Europe/Kiev', 'Europe/Vilnius'])
             end
 
             context 'between specified time' do
@@ -86,6 +86,23 @@ describe TimezoneParser do
                     expect(TimezoneParser::Abbreviation.new('EET').setTime(DateTime.parse('1985-04-19T21:00:00+00:00'), DateTime.parse('1978-10-14T21:00:00+00:00')).getTimezones).to_not include('Europe/Istanbul')
                 end
             end
+
+            context 'between times' do
+                it 'should include correct timezones for AWT' do
+                    abbr = TimezoneParser::Abbreviation.new('AWT')
+                    abbr.FromTime = nil
+                    abbr.ToTime = DateTime.parse('1990-01-01T00:00:00+00:00')
+                    expect(abbr.getTimezones).to eq(['Antarctica/Casey', 'Australia/Perth'])
+
+                    abbr.reset
+                    abbr.FromTime = DateTime.parse('2014-01-01T00:00:00+00:00')
+                    abbr.ToTime = nil
+                    expect(abbr.getTimezones).to eq(['Antarctica/Casey', 'Australia/Perth'])
+
+                    abbr.reset
+                    expect(abbr.setTime(DateTime.parse('2015-01-01T00:00:00+00:00'), DateTime.parse('1985-01-01T00:00:00+00:00')).getTimezones).to eq(['Antarctica/Casey', 'Australia/Perth'])
+                end
+            end
         end
 
         describe '#getMetazones' do
@@ -94,6 +111,13 @@ describe TimezoneParser do
             end
         end
 
+        describe '#getTypes' do
+            it 'should return types for abbreviations' do
+                expect(TimezoneParser::Abbreviation.new('EET').getTypes).to eq([:daylight, :standard])
+                expect(TimezoneParser::Abbreviation.new('EEST').getTypes).to eq([:daylight])
+            end
+        end
+
         describe '.isValid?' do
             it 'should be valid abbreviation' do
                 expect(TimezoneParser::Abbreviation::isValid?('WAST')).to be true

data/spec/rails_zone_spec.rb

@@ -27,6 +27,10 @@ describe TimezoneParser do
             it 'should return all offsets for "Grönland"' do
                 expect(TimezoneParser::RailsZone.new('Grönland').getOffsets).to eq([-10800, -7200])
             end
+
+            it 'should return all offsets for "Ньюфаундленд" in CA region' do
+                expect(TimezoneParser::RailsZone.new('Ньюфаундленд').set( nil, ['CA']).getOffsets).to eq([-12600, -9000])
+            end
         end
 
         describe '#getTimezones' do
@@ -66,13 +70,13 @@ describe TimezoneParser do
 
         describe '.getTimezones' do
             it 'should find timezones' do
-                expect(TimezoneParser::RailsZone::getTimezones('치와와', [], true)).to eq(['America/Chihuahua'])
+                expect(TimezoneParser::RailsZone::getTimezones('치와와', [])).to eq(['America/Chihuahua'])
             end
         end
 
         describe '.getMetazones' do
-            it 'should return zone names' do
-                expect(TimezoneParser::RailsZone::getMetazones('치와와')).to eq(['Chihuahua'])
+            it 'should raise error' do
+                expect { TimezoneParser::RailsZone::getMetazones('치와와') }.to raise_error(StandardError)
             end
         end