Adds alternative formatter

sdispater · sdispater · commit 4b6c5ae13dab · 2016-08-28T00:15:37.000-05:00
diff --git a/pendulum/formatting/__init__.py b/pendulum/formatting/__init__.py
@@ -1,8 +1,10 @@
 # -*- coding: utf-8 -*-
 
 from .classic_formatter import ClassicFormatter
+from .alternative_formatter import AlternativeFormatter
 
 
 FORMATTERS = {
-    'classic': ClassicFormatter()
+    'classic': ClassicFormatter(),
+    'alternative': AlternativeFormatter(),
 }
diff --git a/pendulum/formatting/alternative_formatter.py b/pendulum/formatting/alternative_formatter.py
@@ -0,0 +1,214 @@
+# -*- coding: utf-8 -*-
+
+import re
+import datetime
+
+from .formatter import Formatter
+
+
+class AlternativeFormatter(Formatter):
+
+    _TOKENS = '\[([^\[]*)\]|\\\(.)|' \
+              '(' \
+              'Mo|MM?M?M?' \
+              '|Do|DDDo|DD?D?D?|ddd?d?|do?' \
+              '|w[o|w]?|W[o|W]?|Qo?' \
+              '|YYYY|YY|Y' \
+              '|gg(ggg?)?|GG(GGG?)?' \
+              '|e|E|a|A' \
+              '|hh?|HH?|kk?' \
+              '|mm?|ss?|S{1,9}' \
+              '|x|X' \
+              '|zz?|ZZ?' \
+              ')'
+
+    _FORMAT_RE = re.compile(_TOKENS)
+
+    _LOCALIZABLE_TOKENS = (
+        'Mo', 'MMM', 'MMMM',
+        'Qo',
+        'Do',
+        'DDDo',
+        'do', 'dd', 'ddd', 'dddd',
+        'wo',
+        'Wo',
+        'A', 'a',
+    )
+
+    _TOKENS_RULES = {
+        # Year
+        'YYYY': lambda dt: '{:d}'.format(dt.year),
+        'YY': lambda dt: '{:d}'.format(dt.year)[2:],
+        'Y': lambda dt: '{:d}'.format(dt.year),
+
+        # Quarter
+        'Q': lambda dt: '{:d}'.format(dt.quarter),
+
+        # Month
+        'MM': lambda dt: '{:02d}'.format(dt.month),
+        'M': lambda dt: '{:d}'.format(dt.month),
+
+        # Day
+        'DD': lambda dt: '{:02d}'.format(dt.day),
+        'D': lambda dt: '{:d}'.format(dt.day),
+
+        # Day of Year
+        'DDDD': lambda dt: '{:03d}'.format(dt.day_of_year),
+        'DDD': lambda dt: '{:d}'.format(dt.day_of_year),
+
+        # Day of Week
+        'd': lambda dt: '{:d}'.format(dt.day_of_week),
+
+        # Hour
+        'HH': lambda dt: '{:02d}'.format(dt.hour),
+        'H': lambda dt: '{:d}'.format(dt.hour),
+        'hh': lambda dt: '{:02d}'.format(dt.hour % 12 or 12),
+        'h': lambda dt: '{:d}'.format(dt.hour % 12 or 12),
+
+        # Minute
+        'mm': lambda dt: '{:02d}'.format(dt.minute),
+        'm': lambda dt: '{:d}'.format(dt.minute),
+
+        # Second
+        'ss': lambda dt: '{:02d}'.format(dt.second),
+        's': lambda dt: '{:d}'.format(dt.second),
+
+        # Fractional second
+        'S': lambda dt: '{:1d}'.format(dt.microsecond // 100000),
+        'SS': lambda dt: '{:2d}'.format(dt.microsecond // 10000),
+        'SSS': lambda dt: '{:3d}'.format(dt.microsecond // 1000),
+        'SSSS': lambda dt: '{:4d}'.format(dt.microsecond // 100),
+        'SSSSS': lambda dt: '{:5d}'.format(dt.microsecond // 10),
+        'SSSSSS': lambda dt: '{:6d}'.format(dt.microsecond),
+
+        # Timestamp
+        'X': lambda dt: '{:d}'.format(dt.timestamp),
+
+        # Timezone
+        'z': lambda dt: '{}'.format(dt.tzinfo.abbrev),
+        'zz': lambda dt: '{}'.format(dt.timezone_name),
+    }
+
+    def format(self, dt, fmt, locale=None):
+        """
+        Formats a Pendulum instance with a given format and locale.
+
+        :param dt: The instance to format
+        :type dt: Pendulum
+
+        :param fmt: The format to use
+        :type fmt: str
+
+        :param locale: The locale to use
+        :type locale: str or None
+
+        :rtype: str
+        """
+        if not locale:
+            locale = dt.get_locale()
+
+        return self._FORMAT_RE.sub(
+            lambda m: m.group(1)
+                if m.group(1)
+                else m.group(2)
+                if m.group(2)
+                else self._format_token(dt, m.group(3), locale),
+            fmt
+        )
+
+    def _format_token(self, dt, token, locale):
+        """
+        Formats a Pendulum instance with a given token and locale.
+
+        :param dt: The instance to format
+        :type dt: Pendulum
+
+        :param token: The token to use
+        :type token: str
+
+        :param locale: The locale to use
+        :type locale: str or None
+
+        :rtype: str
+        """
+        if token in self._LOCALIZABLE_TOKENS:
+            return self._format_localizable_token(dt, token, locale)
+
+        if token in self._TOKENS_RULES:
+            return self._TOKENS_RULES[token](dt)
+
+        # Timezone
+        if token in ['ZZ', 'Z']:
+            separator = ':' if token == 'ZZ' else ''
+            offset = dt.utcoffset() or datetime.timedelta()
+            minutes = offset.total_seconds() / 60
+
+            if minutes >= 0:
+                sign = '+'
+            else:
+                sign = '-'
+
+            hour, minute = divmod(abs(int(minutes)), 60)
+
+            return '{}{:02d}{}{:02d}'.format(sign, hour, separator, minute)
+
+        return token
+
+    def _format_localizable_token(self, dt, token, locale):
+        """
+        Formats a Pendulum instance
+        with a given localizable token and locale.
+
+        :param dt: The instance to format
+        :type dt: Pendulum
+
+        :param token: The token to use
+        :type token: str
+
+        :param locale: The locale to use
+        :type locale: str or None
+
+        :rtype: str
+        """
+        if token == 'MMM':
+            count = dt.month
+            trans_id = 'months_abbrev'
+        elif token == 'MMMM':
+            count = dt.month
+            trans_id = 'months'
+        elif token in ('dd', 'ddd'):
+            count = dt.day_of_week
+            trans_id = 'days_abbrev'
+        elif token == 'dddd':
+            count = dt.day_of_week
+            trans_id = 'days'
+        elif token == 'Do':
+            count = dt.day
+            trans_id = 'ordinal'
+        elif token == 'do':
+            count = dt.day_of_week
+            trans_id = 'ordinal'
+        elif token == 'Mo':
+            count = dt.month
+            trans_id = 'ordinal'
+        elif token == 'Qo':
+            count = dt.quarter
+            trans_id = 'ordinal'
+        elif token == 'wo':
+            count = dt.week_of_year
+            trans_id = 'ordinal'
+        elif token == 'DDDo':
+            count = dt.day_of_year
+            trans_id = 'ordinal'
+        elif token == 'A':
+            count = dt.hour
+            trans_id = 'meridian'
+        else:
+            return token
+
+        trans = dt.translator().transchoice(trans_id, count, locale=locale)
+
+        if trans_id == 'ordinal':
+            return '{:d}{}'.format(count, trans)
+
+        return trans
diff --git a/pendulum/pendulum.py b/pendulum/pendulum.py
@@ -899,6 +899,11 @@ def format(self, fmt, locale=None, formatter=None):
         :rtype: str
         """
         if formatter is None:
+            message = 'format() will default to the [alternative] formatter ' \
+                      'in the next major version. If you want to keep ' \
+                      'the current behavior in the future add the "formatter" ' \
+                      'keyword argument: format(formatter=\'classic\')'
+            warnings.warn(message, DeprecationWarning, 2)
             formatter = 'classic'
 
         if formatter not in FORMATTERS:
diff --git a/tests/formatting_tests/test_alternative_formatter.py b/tests/formatting_tests/test_alternative_formatter.py
@@ -0,0 +1,147 @@
+# -*- coding: utf-8 -*-
+
+from pendulum import Pendulum
+from pendulum.formatting.alternative_formatter import AlternativeFormatter
+from .. import AbstractTestCase
+
+
+class ClassicFormatterTest(AbstractTestCase):
+
+    def test_year_tokens(self):
+        d = Pendulum(2009, 1, 14, 15, 25, 50, 123456)
+        f = AlternativeFormatter()
+        self.assertEqual('2009', f.format(d, 'YYYY'))
+        self.assertEqual('09', f.format(d, 'YY'))
+        self.assertEqual('2009', f.format(d, 'Y'))
+
+    def test_quarter_tokens(self):
+        f = AlternativeFormatter()
+        d = Pendulum(1985, 1, 4)
+        self.assertEqual('1', f.format(d, 'Q'))
+        d = Pendulum(2029, 8, 1)
+        self.assertEqual('3', f.format(d, 'Q'))
+        d = Pendulum(1985, 1, 4)
+        self.assertEqual('1st', f.format(d, 'Qo'))
+        d = Pendulum(2029, 8, 1)
+        self.assertEqual('3rd', f.format(d, 'Qo'))
+        d = Pendulum(1985, 1, 4)
+        self.assertEqual('1er', f.format(d, 'Qo', locale='fr'))
+        d = Pendulum(2029, 8, 1)
+        self.assertEqual('3e', f.format(d, 'Qo', locale='fr'))
+
+    def test_month_tokens(self):
+        f = AlternativeFormatter()
+        d = Pendulum(2016, 3, 24)
+        self.assertEqual('03', f.format(d, 'MM'))
+        self.assertEqual('3', f.format(d, 'M'))
+
+        self.assertEqual('Mar', f.format(d, 'MMM'))
+        self.assertEqual('March', f.format(d, 'MMMM'))
+        self.assertEqual('3rd', f.format(d, 'Mo'))
+
+        self.assertEqual('mars', f.format(d, 'MMM', locale='fr'))
+        self.assertEqual('mars', f.format(d, 'MMMM', locale='fr'))
+        self.assertEqual('3e', f.format(d, 'Mo', locale='fr'))
+
+    def test_day_tokens(self):
+        f = AlternativeFormatter()
+        d = Pendulum(2016, 3, 7)
+        self.assertEqual('07', f.format(d, 'DD'))
+        self.assertEqual('7', f.format(d, 'D'))
+
+        self.assertEqual('7th', f.format(d, 'Do'))
+        self.assertEqual('1st', f.format(d.first_of('month'), 'Do'))
+
+        self.assertEqual('7e', f.format(d, 'Do', locale='fr'))
+        self.assertEqual('1er', f.format(d.first_of('month'), 'Do', locale='fr'))
+
+    def test_day_of_year(self):
+        f = AlternativeFormatter()
+        d = Pendulum(2016, 8, 28)
+        self.assertEqual('241', f.format(d, 'DDDD'))
+        self.assertEqual('241', f.format(d, 'DDD'))
+        self.assertEqual('001', f.format(d.start_of('year'), 'DDDD'))
+        self.assertEqual('1', f.format(d.start_of('year'), 'DDD'))
+
+        self.assertEqual('241st', f.format(d, 'DDDo'))
+        self.assertEqual('244th', f.format(d.add(days=3), 'DDDo'))
+
+        self.assertEqual('241e', f.format(d, 'DDDo', locale='fr'))
+        self.assertEqual('244e', f.format(d.add(days=3), 'DDDo', locale='fr'))
+
+    def test_day_of_week(self):
+        f = AlternativeFormatter()
+        d = Pendulum(2016, 8, 28)
+        self.assertEqual('0', f.format(d, 'd'))
+
+        self.assertEqual('Sun', f.format(d, 'dd'))
+        self.assertEqual('Sun', f.format(d, 'ddd'))
+        self.assertEqual('Sunday', f.format(d, 'dddd'))
+
+        self.assertEqual('dim', f.format(d, 'dd', locale='fr'))
+        self.assertEqual('dim', f.format(d, 'ddd', locale='fr'))
+        self.assertEqual('dimanche', f.format(d, 'dddd', locale='fr'))
+
+    def test_am_pm(self):
+        f = AlternativeFormatter()
+        d = Pendulum(2016, 8, 28, 23)
+        self.assertEqual('PM', f.format(d, 'A'))
+        self.assertEqual('AM', f.format(d.hour_(11), 'A'))
+
+    def test_hour(self):
+        f = AlternativeFormatter()
+        d = Pendulum(2016, 8, 28, 7)
+        self.assertEqual('7', f.format(d, 'H'))
+        self.assertEqual('07', f.format(d, 'HH'))
+
+        d = Pendulum(2016, 8, 28, 0)
+        self.assertEqual('12', f.format(d, 'h'))
+        self.assertEqual('12', f.format(d, 'hh'))
+
+    def test_minute(self):
+        f = AlternativeFormatter()
+        d = Pendulum(2016, 8, 28, 7, 3)
+        self.assertEqual('3', f.format(d, 'm'))
+        self.assertEqual('03', f.format(d, 'mm'))
+
+    def test_second(self):
+        f = AlternativeFormatter()
+        d = Pendulum(2016, 8, 28, 7, 3, 6)
+        self.assertEqual('6', f.format(d, 's'))
+        self.assertEqual('06', f.format(d, 'ss'))
+
+    def test_fractional_second(self):
+        f = AlternativeFormatter()
+        d = Pendulum(2016, 8, 28, 7, 3, 6, 123456)
+        self.assertEqual('1', f.format(d, 'S'))
+        self.assertEqual('12', f.format(d, 'SS'))
+        self.assertEqual('123', f.format(d, 'SSS'))
+        self.assertEqual('1234', f.format(d, 'SSSS'))
+        self.assertEqual('12345', f.format(d, 'SSSSS'))
+        self.assertEqual('123456', f.format(d, 'SSSSSS'))
+
+    def test_timezone(self):
+        f = AlternativeFormatter()
+        d = Pendulum(2016, 8, 28, 7, 3, 6, 123456, 'Europe/Paris')
+        self.assertEqual('CEST', f.format(d, 'z'))
+        self.assertEqual('Europe/Paris', f.format(d, 'zz'))
+
+        d = Pendulum(2016, 1, 28, 7, 3, 6, 123456, 'Europe/Paris')
+        self.assertEqual('CET', f.format(d, 'z'))
+        self.assertEqual('Europe/Paris', f.format(d, 'zz'))
+
+    def test_timezone_offset(self):
+        f = AlternativeFormatter()
+        d = Pendulum(2016, 8, 28, 7, 3, 6, 123456, 'Europe/Paris')
+        self.assertEqual('+0200', f.format(d, 'Z'))
+        self.assertEqual('+02:00', f.format(d, 'ZZ'))
+
+        d = Pendulum(2016, 1, 28, 7, 3, 6, 123456, 'Europe/Paris')
+        self.assertEqual('+0100', f.format(d, 'Z'))
+        self.assertEqual('+01:00', f.format(d, 'ZZ'))
+
+    def test_timestamp(self):
+        f = AlternativeFormatter()
+        d = Pendulum(1970, 1, 1)
+        self.assertEqual('0', f.format(d, 'X'))
+        self.assertEqual('86400', f.format(d.add(days=1), 'X'))

Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,10 @@`
`1`	`1`	`# -- coding: utf-8 --`
`2`	`2`
`3`	`3`	`from .classic_formatter import ClassicFormatter`
	`4`	`+from .alternative_formatter import AlternativeFormatter`
`4`	`5`
`5`	`6`
`6`	`7`	`FORMATTERS = {`
`7`		`- 'classic': ClassicFormatter()`
	`8`	`+ 'classic': ClassicFormatter(),`
	`9`	`+ 'alternative': AlternativeFormatter(),`
`8`	`10`	`}`