timezone 0.3.2 → 0.3.3

data/lib/timezone/parser/data.rb

@@ -1,103 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

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

@@ -1,39 +0,0 @@
-require 'timezone/parser/zone'
-require 'timezone/parser/zone/until'
-require 'timezone/parser/rule'
-require 'time'
-
-# The data object that represents a zone entry in the TZData file.
-# Tests for this class are contained in the parser/zone_test.rb file.
-module Timezone::Parser::Zone
-  class Entry
-    attr_reader :name, :format, :offset, :end_date, :rules
-
-    def initialize(name, offset, rule, format, end_date)
-      @name, @format = name, format
-
-      @end_date = parse_end_date(end_date)
-      @offset   = parse_offset(offset)
-      @rules    = parse_rules(rule, @end_date)
-    end
-
-    private
-
-    # Only select rules that fall within the timeline of this entry.
-    # Then apply the rule to this entry so that the offset is accurate.
-    def parse_rules(name, end_date)
-      Timezone::Parser.select_rules(name, end_date).sort_by(&:start_date)
-    end
-
-    # Use the UNTIL parser to decode the end date.
-    def parse_end_date(end_date)
-      Until.parse(end_date)
-    end
-
-    # The offset is calculated in minutes.
-    def parse_offset(offset)
-      offset = Time.parse(offset)
-      offset.hour*60*60 + offset.min*60 + offset.sec
-    end
-  end
-end