timezone 0.2.1 → 0.3.0

data/lib/timezone/parser.rb

@@ -0,0 +1,29 @@
+require 'timezone/parser/rule'
+require 'timezone/parser/data'
+require 'timezone/parser/zone'
+require 'timezone/parser/zone/data_generator'
+
+module Timezone
+  module Parser
+    COMMENT_REGEXP = /^\s*#/
+    RULE_REGEXP    = /^Rule/
+    LINK_REGEXP    = /^Link/
+    ZONE_REGEXP    = /^Zone/
+
+    def self.parse(file)
+      IO.readlines(file).map(&:strip).each do |line|
+        if line =~ COMMENT_REGEXP
+          next
+        elsif line =~ RULE_REGEXP
+          rule(line)
+        elsif line =~ LINK_REGEXP
+          # TODO [panthomakos] Need to add linking.
+        elsif line =~ ZONE_REGEXP || (line != '' && !line.nil?)
+          zone(line)
+        else
+          Timezone::Parser::Zone.generate(Timezone::Parser::Zone.last)
+        end
+      end
+    end
+  end
+end

data/lib/timezone/parser/data.rb

@@ -0,0 +1,103 @@
+require 'json'
+
+module Timezone
+  module Parser
+    def self.data(*args) ; Data.new(*args) ; end
+
+    def self.from_zone(previous, zone)
+      data(previous && previous.end_date, zone.end_date, zone)
+    end
+
+    def self.extension(previous, zone)
+      data(previous.end_date, nil, zone)
+    end
+
+    def self.from_rule(zone, rule)
+      data(rule.start_date, nil, zone, rule)
+    end
+
+    START_DATE = -377705116800000 # The very last date '9999-12-31T23:59:59Z'.
+    END_DATE = 253402300799000 # The very first date '-9999-01-01T00:00:00Z'.
+
+    class NilRule
+      def letter ; '-' ; end
+      def offset ; 0 ; end
+      def utime? ; false ; end
+      def dst? ; false ; end
+    end
+
+    # The resulting JSON data structure for a timezone file.
+    class Data
+      attr_accessor :start_date, :dst, :offset, :name
+
+      def initialize(start_date, end_date, zone, rule = NilRule.new)
+        @dst = rule.dst?
+        @offset = parse_offset(zone, rule)
+        @name = parse_name(zone.format, rule.letter)
+        @utime = rule.utime?
+        @start_date = parse_start_date(start_date)
+        self.end_date = end_date
+      end
+
+      def end_date=(date)
+        if date.nil? || @utime
+          @end_date = date
+        else
+          @end_date = date - (@offset * 1_000)
+        end
+      end
+
+      def end_date
+        @end_date || END_DATE
+      end
+
+      def has_end_date?
+        !!@end_date
+      end
+
+      def to_hash
+        {
+          '_from' => _from,
+          'from' => @start_date,
+          '_to' => _to,
+          'to' => end_date,
+          'dst' => @dst,
+          'offset' => @offset,
+          'name' => @name
+        }
+      end
+
+      def to_json
+        to_hash.to_json
+      end
+
+      private
+
+      def parse_offset(zone, rule)
+        zone.offset + rule.offset
+      end
+
+      def parse_start_date(date)
+        date || START_DATE
+      end
+
+      # Fills in a zone entry format with a rule entry letter.
+      #
+      # Examples:
+      #
+      #     format "EE%sT" w/ letter "S" results in EEST
+      #     format "EE%sT" w/ letter "-" results in EET
+      def parse_name(format, letter)
+        format.sub(/%s/, letter == '-' ? '' : letter)
+      end
+
+      def _from ; ftime(@start_date) ; end
+      def _to ; ftime(end_date) ; end
+
+      # Converts a millisecond time into the proper JSON output string.
+      def ftime(time)
+        Time.at(time / 1_000).utc.strftime('%Y-%m-%dT%H:%M:%SZ')
+      end
+    end
+  end
+end

data/lib/timezone/parser/link.rb

@@ -0,0 +1,10 @@
+module Timezone
+  module Parser
+    def self.link(line) ; Link.new(line) ; end
+
+    class Link
+      def initialize(line)
+      end
+    end
+  end
+end

data/lib/timezone/parser/rule.rb

@@ -0,0 +1,55 @@
+require 'time'
+
+module Timezone
+  module Parser
+    # Given a rule from a TZDATA file, generate the appropriate rule objects.
+    def self.rule(line) ; Rule.generate(line) ; end
+
+    # Get a list of all processed rules.
+    def self.rules ; Rule.rules ; end
+
+    # Select rules based on a name and end date.
+    def self.select_rules(name, end_date)
+      rules.fetch(name){ [] }
+        .select{ |rule| end_date.nil? || rule.start_date < end_date }
+    end
+
+    module Rule
+      # Format:  Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+      # Example: Rule	EUAsia	1981	max	-	Mar	lastSun	 1:00u	1:00	S
+      RULE = /Rule\s+([\w-]+?)\s+(\d+?)\s+([^\s]+?)\s+([^\s]+?)\s+(\s*\w+?)\s+([\d\w\=\>\<]+?)\s+([\d:us]+?)\s+([\d:]+?)\s+([\w-]+)/
+
+      END_YEAR = 2050 # The actual value for the "to" field when set to "max".
+
+      # Rules are stored in a hash of arrays that are referenced by rule name.
+      @@rules = Hash.new{ |h, k| h[k] = [] }
+      def self.rules ; @@rules ; end
+
+      class << self
+        def generate(line)
+          name, from, to, *values = *line.match(RULE)[1..-1]
+
+          years(from, to).each do |year|
+            @@rules[name] << Entry.new(name, year, *values)
+          end
+        end
+
+        private
+
+        def years(from, to)
+          (from.to_i..parse_end_year(from, to))
+        end
+
+        def parse_end_year(from, to)
+          case to
+          when 'only' then from.to_i
+          when 'max' then END_YEAR
+          else to.to_i
+          end
+        end
+      end
+    end
+  end
+end
+
+require 'timezone/parser/rule/entry'

data/lib/timezone/parser/rule/entry.rb

@@ -0,0 +1,74 @@
+require 'timezone/parser/rule'
+require 'timezone/parser/rule/on_rules'
+
+module Timezone::Parser::Rule
+  class Entry
+    attr_accessor :name, :offset
+    attr_reader :letter, :start_date
+
+    UTIME = /^.*u$/
+    STIME = /^.*s$/
+    START_DATE = '%Y %b %d %H:%M %Z'
+
+    def initialize(name, year, type, month, day, time, save, letter)
+      @name, @offset, @letter = name, offset, letter
+
+      @month, @day = parse_month_day(day, month, year)
+      @utime       = parse_utime(time)
+      @stime       = parse_stime(time)
+      @time        = parse_time(time)
+      @day         = parse_day(@day)
+      @offset      = parse_offset(save)
+      @start_date  = parse_start_date(year, @month, @day, @time)
+      @dst         = parse_dst(save)
+    end
+
+    def utime? ; @utime ; end
+    def stime? ; @stime ; end
+    def dst?   ; @dst   ; end
+
+    private
+
+    # Day should be zero padded.
+    def parse_day(day)
+      '%.2d' % day.to_i
+    end
+
+    # Time should be zero padded and not include 'u' or 's'.
+    def parse_time(time)
+      time = "0#{time}" if time.match(/^\d:\d\d/)
+      time = time.gsub(/u/, '') if utime?
+      time = time.gsub(/s/, '') if stime?
+
+      time
+    end
+
+    def parse_utime(time)
+      time =~ UTIME
+    end
+
+    def parse_stime(time)
+      time =~ STIME
+    end
+
+    # Offset is calculated in seconds.
+    def parse_offset(save)
+      offset = Time.parse(save == '0' ? '0:00' : save)
+      offset.hour*60*60 + offset.min*60 + offset.sec
+    end
+
+    # Check special rules that modify the month and day depending on the year.
+    def parse_month_day(day, month, year)
+      On.parse(day, month, year)
+    end
+
+    # The UTC time on which the rule beings to apply in milliseconds.
+    def parse_start_date(y, m, d, t)
+      Time.strptime([y, m, d, t, 'UTC'].join(' '), START_DATE).to_i * 1_000
+    end
+
+    def parse_dst(save)
+      save != '0'
+    end
+  end
+end

data/lib/timezone/parser/rule/on.rb

@@ -0,0 +1,30 @@
+require 'timezone/parser/rule'
+require 'time'
+
+module Timezone::Parser::Rule
+  def self.on(*args) ; On.new(*args) ; end
+
+  class On
+    @@rules = []
+
+    # Given a Rule `on` field, parse the appropriate day and month.
+    def self.parse(day, month, year)
+      @@rules.each do |rule|
+        if match = day.match(rule.expression)
+          return rule.block.call(match, day, month, year)
+        end
+      end
+
+      [month, day]
+    end
+
+    attr_reader :expression, :block
+
+    def initialize(name, expression, block)
+      @name = name
+      @expression = expression
+      @block = block
+      @@rules << self
+    end
+  end
+end

data/lib/timezone/parser/rule/on_rules.rb

@@ -0,0 +1,30 @@
+require 'timezone/parser/rule/on'
+
+# A simple DSL for definining rules to parse the "ON" field in TZData rules.
+module Timezone::Parser::Rule
+  on 'lastDAY', /^last(\w+)$/, lambda{ |match, _, month, year|
+    31.downto(1).each do |day|
+      begin
+        date = Time.strptime("#{year} #{month} #{day}", '%Y %b %d')
+
+        if date.strftime('%a') == match[1]
+          return [month, date.strftime('%d')]
+        end
+      rescue
+        next
+      end
+    end
+  }
+
+  on 'DAY>=NUM', /^(\w+)>=(\d+)$/, lambda{ |match, _, month, year|
+    start = Time.strptime("#{year} #{month} #{match[2]}", '%Y %b %d')
+
+    (1..8).to_a.each do |plus|
+      date = start + (plus * 24 * 60 * 60)
+
+      if date.strftime('%a') == match[1]
+        return [date.strftime('%b'), date.strftime('%d')]
+      end
+    end
+  }
+end

data/lib/timezone/parser/zone.rb

@@ -0,0 +1,37 @@
+require 'time'
+
+module Timezone
+  module Parser
+    # Given a line from the TZDATA file, generate an Entry object.
+    def self.zone(line) ; Zone.parse(line) ; end
+
+    # Get a list of all processed entries.
+    def self.zones ; Zone.zones ; end
+
+    module Zone
+      # Each entry follows this format.
+      # GMT-OFFSET RULES FORMAT [UNTIL]
+      ENTRY = /(\d+?:\d+?:*\d*?)\s+(.+?)\s([^\s]+)\s*(.*?)$/
+
+      # The header entry also includes the Zone name.
+      # Zone ZONE-NAME GMT-OFFSET RULES FORMAT [UNTIL]
+      HEADER = /Zone\s+(.+?)\s+/
+
+      # Zones are stored in a hash of arrays that are referenced by name.
+      @@zones = Hash.new{ |h, k| h[k] = [] }
+      def self.zones ; @@zones ; end
+
+      # The name of the current zone is parsed from the header zone entry.
+      # It can then be accessed using `Timezone::Parser::Zone.last`.
+      class << self ; attr_accessor :last ; end
+
+      def self.parse(line)
+        self.last = $~[1] if line.match(HEADER)
+
+        @@zones[last] << Entry.new(last, *line.match(ENTRY)[1..-1])
+      end
+    end
+  end
+end
+
+require 'timezone/parser/zone/entry'

data/lib/timezone/parser/zone/data_generator.rb

@@ -0,0 +1,77 @@
+require 'timezone/parser/zone'
+require 'timezone/parser/data'
+require 'time'
+
+module Timezone::Parser::Zone
+  def self.generate(zones) ; DataGenerator.generate(zones) ; end
+
+  def self.data ; DataGenerator.data ; end
+
+  # TODO [panthomakos] This needs refactoring.
+  module DataGenerator
+    @@data = Hash.new{ |h,k| h[k] = [] }
+    def self.data ; @@data ; end
+
+    class << self
+      def generate(zone)
+        zones = Timezone::Parser.zones[zone].to_a
+
+        return if zones.empty?
+
+        @@data[zone] = zones
+          .each_cons(2)
+          .inject(update(zones.first)) do |set, (previous, zone)|
+            update(zone, set, previous && previous.end_date)
+        end
+      end
+
+      private
+
+      def update(zone, set = [], limit = nil)
+        additions = [first_addition(zone, set)]
+
+        zone.rules.each do |rule|
+          data = additions.last
+
+          if rule_applies?(rule, data, limit)
+            Timezone::Parser.from_rule(zone, rule).tap do |insert|
+              data.end_date = insert.start_date
+              # We do this because the start date is always based on the
+              # previous entry end date calculation.
+              insert.start_date = data.end_date
+
+              additions << insert
+            end
+          end
+        end
+
+        set + additions
+      end
+
+      # The rule has to fall within the time range (start_date..limit).
+      def rule_applies?(rule, data, limit)
+        rule.start_date > data.start_date &&
+          (!limit || rule.start_date > limit)
+      end
+
+      def first_addition(zone, set)
+        previous = set.last
+
+        if zone.rules.empty?
+          # If there are no rules, generate a new entry for this time period.
+          Timezone::Parser.from_zone(previous, zone)
+        else
+          if previous && previous.has_end_date?
+            # If the last entry had a hard cutoff end date, create a new
+            # addition that picks up from where the last entry left off.
+            Timezone::Parser.extension(previous, zone)
+          else
+            # If the last entry did not have a hard cutoff end date, pop it off
+            # the stack for use in these calculations.
+            set.pop
+          end
+        end
+      end
+    end
+  end
+end