Cleanup and minor fixes

Author: borntyping

dice/__init__.py

@@ -10,7 +10,8 @@
 
 __all__ = ['roll', 'ParseException']
 __author__ = "Sam Clements <[email protected]>"
-__version__ = '0.3.1'
+__version__ = '0.3.2'
+
 
 def roll(string, single=True, verbose=False):
     """Parses and evaluates a dice expression"""

dice/command.py

@@ -16,6 +16,7 @@
 
 __version__ = "dice v{0} by {1}".format(dice.__version__, dice.__author__)
 
+
 def main(argv=None):
     """Run roll() from a command line interface"""
     args = docopt.docopt(__doc__, argv=argv, version=__version__)

dice/elements.py

@@ -7,6 +7,7 @@
 
 from dice.utilities import classname
 
+
 class Element(object):
     def evaluate(self, verbose=False):
         """Evaluate the current object - a no-op by default"""

dice/grammar.py

@@ -8,14 +8,16 @@
 
 from __future__ import absolute_import, print_function, unicode_literals
 
-from pyparsing import (CaselessLiteral, Forward, Literal, OneOrMore,
-    StringStart, StringEnd, Suppress, Word, nums, opAssoc)
+from pyparsing import (
+    CaselessLiteral, Forward, Literal, OneOrMore, StringStart, StringEnd,
+    Suppress, Word, nums, opAssoc)
 
 from dice.elements import Integer, Dice, Total, Mul, Div, Sub, Add
 from dice.utilities import patch_pyparsing
 
 patch_pyparsing()
 
+
 def operatorPrecedence(base, operators):
     """
     This re-implements pyparsing's operatorPrecedence function.

dice/tests/conftest.py

@@ -2,6 +2,7 @@
 
 from termcolor import colored
 
+
 def pytest_report_teststatus(report):
     if report.when != "call":
         return None, None, None

dice/tests/test_command.py

@@ -1,11 +1,20 @@
 from __future__ import absolute_import
 
+import itertools
+
+from dice import roll
 from dice.command import main
 from dice.elements import Integer, Roll
 
 
+def test_roll():
+    for single, verbose in itertools.product((True, False), (True, False)):
+        assert roll('6d6', single=single, verbose=verbose)
+
+
 def test_main():
     assert isinstance(main(['2d6']), (Integer, Roll, list))
 
+
 def test_main_verbose():
     assert main(['1d6', '--verbose'])

dice/tests/test_elements.py

@@ -2,17 +2,25 @@
 
 from dice.elements import Integer, Roll, Dice
 
+
 def test_integer():
     assert isinstance(Integer(1), int)
 
+
 def test_dice_from_iterable():
     d = Dice.from_iterable((2, 6))
     assert d.amount == 2 and d.sides == 6
 
+
 def test_dice_from_string():
-    d = Dice.from_string("2d6")
+    d = Dice.from_string('2d6')
     assert d.amount == 2 and d.sides == 6
 
+
+def test_dice_roll():
+    assert isinstance(Dice(2, 6).roll(), Roll)
+
+
 def test_roll():
     amount, sides = 6, 6
     assert len(Roll.roll(amount, sides)) == amount

dice/tests/test_grammar.py

@@ -3,13 +3,14 @@
 from dice.elements import Integer, Roll
 from dice import roll
 
+
 class TestInteger(object):
     def test_value(self):
-        assert roll("1337") == 1337
+        assert roll('1337') == 1337
 
     def test_type(self):
-        assert isinstance(roll("1"), int)
-        assert isinstance(roll("1"), Integer)
+        assert isinstance(roll('1'), int)
+        assert isinstance(roll('1'), Integer)
 
 
 class TestDice(object):
@@ -22,44 +23,44 @@ def test_dice_type(self):
         assert isinstance(roll('1d6'), Roll)
 
     def test_dice_values(self):
-        for die in roll("6d6"):
+        for die in roll('6d6'):
             assert 0 < die <= 6
 
 
 class TestFunctionOperators(object):
     def test_add(self):
-        assert roll("2 + 2") == 4
+        assert roll('2 + 2') == 4
 
     def test_sub(self):
-        assert roll("2 - 2") == 0
+        assert roll('2 - 2') == 0
 
     def test_mul(self):
-        assert roll("2 * 2") == 4
+        assert roll('2 * 2') == 4
 
     def test_div(self):
-        assert roll("2 / 2") == 1
+        assert roll('2 / 2') == 1
 
     def test_total(self):
-        assert (6 * 1) <= roll("6d6t") <= (6 * 6)
+        assert (6 * 1) <= roll('6d6t') <= (6 * 6)
 
 
-def TestOperatorPrecedence(object):
+class TestOperatorPrecedence(object):
     def test_operator_precedence_1(self):
-        assert roll("16 / 8 * 4 + 2 - 1") == 9
+        assert roll('16 / 8 * 4 + 2 - 1') == 9
 
     def test_operator_precedence_2(self):
-        assert roll("16 - 8 + 4 * 2 / 1") == 16
+        assert roll('16 - 8 + 4 * 2 / 1') == 16
 
     def test_operator_precedence_3(self):
-        assert roll("10 - 3 + 2") == 9
+        assert roll('10 - 3 + 2') == 9
 
     def test_operator_precedence_4(self):
-        assert roll("1 + 2 * 3") == 7
+        assert roll('1 + 2 * 3') == 7
 
 
 class TestExpression(object):
     def test_expression(self):
-        assert isinstance(roll("2d6"), Roll)
+        assert isinstance(roll('2d6'), Roll)
 
     def test_sub_expression(self):
-        assert isinstance(roll("(2d6)d(2d6)"), Roll)
+        assert isinstance(roll('(2d6)d(2d6)'), Roll)

dice/tests/test_utilities.py

@@ -4,6 +4,7 @@
 
 from py.test import raises
 
+
 def test_enable_pyparsing_packrat_parsing():
     """Test that packrat parsing was enabled"""
     import pyparsing
@@ -21,6 +22,6 @@ def test_disable_pyparsing_arity_trimming_works():
     """Tests that arity trimming has been disabled and parse actions with
     the wrong number of arguments will raise TypeErrors"""
     for func in [lambda a: None, lambda a, b: None, lambda a, b, c, d: None]:
-        element = Literal("test").setParseAction(func)
+        element = Literal('test').setParseAction(func)
         with raises(TypeError):
-            element.parseString("test")
+            element.parseString('test')

dice/utilities.py

@@ -4,6 +4,7 @@
 
 import pyparsing
 
+
 def classname(obj):
     """Returns the name of an objects class"""
     return obj.__class__.__name__