Refactor Parser into Loader (#35)

* `Parser.parse` -> `Loader.load`
* `Parser._parse -> `Loader._load`
* Use `pytz.open_resource` for zone file loading to fix pytz installs
  using shared zoneinfo files.
* Fix for python2 setup and test (backport `FileNotFoundError` name).

Tested on Fedora Core 24 (linux), python2.7 (distro), python3.5
(distro)

Fixes #34

Author: mayfield

pendulum/_compat.py

@@ -12,9 +12,11 @@
     long = long
     unicode = unicode
     basestring = basestring
+    FileNotFoundError = IOError
 
 else:
 
+    FileNotFoundError = FileNotFoundError
     long = int
     unicode = str
     basestring = str

pendulum/tz/loader.py

@@ -1,11 +1,28 @@
 # -*- coding: utf-8 -*-
 
+import inspect
 import os
 import pytz
-import inspect
 
-from .parser import Parser
-from .._compat import decode
+from datetime import datetime
+from struct import unpack, calcsize
+
+from .. import _compat
+from .breakdown import local_time
+from .transition import Transition
+from .transition_type import TransitionType
+
+
+def _byte_string(s):
+    """Cast a string or byte string to an ASCII byte string."""
+    return s.encode('US-ASCII')
+
+_NULL = _byte_string('\0')
+
+
+def _std_string(s):
+    """Cast a string or byte string to an ASCII string."""
+    return str(s.decode('US-ASCII'))
 
 
 class Loader(object):
@@ -14,17 +31,104 @@ class Loader(object):
 
     @classmethod
     def load(cls, name):
-        name = decode(name)
+        name = _compat.decode(name)
+        try:
+            with pytz.open_resource(name) as f:
+                return cls._load(f)
+        except _compat.FileNotFoundError:
+            raise ValueError('Unknown timezone [{}]'.format(name))
 
-        name_parts = name.lstrip('/').split('/')
+    @classmethod
+    def _load(cls, fp):
+        head_fmt = '>4s c 15x 6l'
+        head_size = calcsize(head_fmt)
+        (magic, fmt, ttisgmtcnt, ttisstdcnt, leapcnt, timecnt,
+         typecnt, charcnt) = unpack(head_fmt, fp.read(head_size))
 
-        for part in name_parts:
-            if part == os.path.pardir or os.path.sep in part:
-                raise ValueError('Bad path segment: %r' % part)
+        # Make sure it is a tzfile(5) file
+        assert magic == _byte_string('TZif'), 'Got magic %s' % repr(magic)
 
-        filepath = os.path.join(cls.path, *name_parts)
+        # Read out the transition times,
+        # localtime indices and ttinfo structures.
+        data_fmt = '>%(timecnt)dl %(timecnt)dB %(ttinfo)s %(charcnt)ds' % dict(
+            timecnt=timecnt, ttinfo='lBB' * typecnt, charcnt=charcnt)
+        data_size = calcsize(data_fmt)
+        data = unpack(data_fmt, fp.read(data_size))
 
-        if not os.path.exists(filepath):
-            raise ValueError('Unknown timezone [{}]'.format(name))
+        # make sure we unpacked the right number of values
+        assert len(data) == 2 * timecnt + 3 * typecnt + 1
+        transition_times = tuple(trans for trans in data[:timecnt])
+        lindexes = tuple(data[timecnt:2 * timecnt])
+        ttinfo_raw = data[2 * timecnt:-1]
+        tznames_raw = data[-1]
+        del data
+
+        # Process ttinfo into separate structs
+        transition_types = tuple()
+        tznames = {}
+        i = 0
+        while i < len(ttinfo_raw):
+            # have we looked up this timezone name yet?
+            tzname_offset = ttinfo_raw[i + 2]
+            if tzname_offset not in tznames:
+                nul = tznames_raw.find(_NULL, tzname_offset)
+                if nul < 0:
+                    nul = len(tznames_raw)
+                tznames[tzname_offset] = _std_string(
+                    tznames_raw[tzname_offset:nul])
+            transition_types += (
+                TransitionType(
+                    ttinfo_raw[i], bool(ttinfo_raw[i + 1]),
+                    tznames[tzname_offset]
+                ),
+            )
+            i += 3
+
+        # Now build the timezone object
+        if len(transition_times) == 0:
+            transitions = tuple()
+        else:
+            # calculate transition info
+            transitions = tuple()
+            for i in range(len(transition_times)):
+                transition_type = transition_types[lindexes[i]]
+
+                if i == 0:
+                    pre_transition_type = transition_types[lindexes[i]]
+                else:
+                    pre_transition_type = transition_types[lindexes[i - 1]]
+
+                pre_time = datetime(*local_time(transition_times[i],
+                                                pre_transition_type)[:7])
+                time = datetime(*local_time(transition_times[i],
+                                            transition_type)[:7])
+                tr = Transition(
+                    transition_times[i],
+                    transition_type,
+                    pre_time,
+                    time,
+                    pre_transition_type
+                )
+
+                transitions += (tr,)
+
+        # Determine the before-first-transition type
+        default_transition_type_index = 0
+        if transitions:
+            index = 0
+            if transition_types[0].is_dst:
+                index = transition_types.index(transitions[0].transition_type)
+                while index != 0 and transition_types[index].is_dst:
+                    index -= 1
+
+            while index != len(transitions) and transition_types[index].is_dst:
+                index += 1
+
+            if index != len(transitions):
+                default_transition_type_index = index
 
-        return Parser.parse(filepath)
+        return (
+            transitions,
+            transition_types,
+            transition_types[default_transition_type_index]
+        )

pendulum/tz/local_timezone.py

@@ -7,7 +7,7 @@
 from contextlib import contextmanager
 
 from .timezone import Timezone
-from .parser import Parser
+from .loader import Loader
 
 
 class LocalTimezone(object):
@@ -165,7 +165,7 @@ def get_tz_name_for_unix(cls):
 
             if not os.path.exists(tzpath):
                 continue
-            return Timezone('', *Parser.parse(tzpath))
+            return Timezone('', *Loader.load(tzpath))
 
         raise RuntimeError('Can not find any timezone configuration')
 
@@ -176,7 +176,7 @@ def _tz_from_env(tzenv):
 
     # TZ specifies a file
     if os.path.exists(tzenv):
-        return Timezone('', *Parser.parse(tzenv))
+        return Timezone('', *Loader.load(tzenv))
 
     # TZ specifies a zoneinfo zone.
     try:

pendulum/tz/parser.py

@@ -8,6 +8,12 @@
 from distutils.command.build_ext import build_ext
 
 
+try:
+    FileNotFoundError
+except NameError:
+    FileNotFoundError = IOError  # py2k
+
+
 def get_version():
     basedir = os.path.dirname(__file__)
     with open(os.path.join(basedir, 'pendulum/version.py')) as f:

setup.py

@@ -3,6 +3,7 @@
 import pendulum
 from datetime import datetime
 from pendulum import timezone
+from pendulum.tz.loader import Loader
 
 from .. import AbstractTestCase
 
@@ -235,3 +236,12 @@ def test_convert_accept_pendulum_instance(self):
 
         self.assertIsInstanceOfPendulum(new)
         self.assertPendulum(new, 2016, 8, 7, 14, 53, 54)
+
+
+class TimezoneLoaderTest(AbstractTestCase):
+
+    def test_load_bad_timezone(self):
+        self.assertRaises(ValueError, Loader.load, '---NOT A TIMEZONE---')
+
+    def test_load_valid(self):
+        self.assertTrue(Loader.load('America/Toronto'))