fixed http://code.google.com/p/simplejson/issues/detail?id=35 -- no longer checks exactly for True and False

git-svn-id: http://simplejson.googlecode.com/svn/trunk@164 a4795897-2c25-0410-b006-0d3caba88fa1

1 files changed, 32 insertions, 28 deletions

diff --git a/index.rst b/index.rst
index 0c25930..41133c0 100644
--- a/index.rst
+++ b/index.rst
@@ -97,13 +97,13 @@ Specializing JSON object encoding::
 
 .. highlight:: none
 
-Using simplejson.tool from the shell to validate and pretty-print::
+Using :mod:`simplejson.tool` from the shell to validate and pretty-print::
 
-    $ echo '{"json":"obj"}' | python -msimplejson.tool
+    $ echo '{"json":"obj"}' | python -m simplejson.tool
     {
         "json": "obj"
     }
-    $ echo '{ 1.2:3.4}' | python -msimplejson.tool
+    $ echo '{ 1.2:3.4}' | python -m simplejson.tool
     Expecting property name: line 1 column 2 (char 2)
 
 .. highlight:: python
@@ -122,40 +122,44 @@ Basic Usage
    Serialize *obj* as a JSON formatted stream to *fp* (a ``.write()``-supporting
    file-like object).
 
-   If *skipkeys* is ``True`` (default: ``False``), then dict keys that are not
+   If *skipkeys* is true (default: ``False``), then dict keys that are not
    of a basic type (:class:`str`, :class:`unicode`, :class:`int`, :class:`long`,
    :class:`float`, :class:`bool`, ``None``) will be skipped instead of raising a
    :exc:`TypeError`.
 
-   If *ensure_ascii* is ``False`` (default: ``True``), then some chunks written
+   If *ensure_ascii* is false (default: ``True``), then some chunks written
    to *fp* may be :class:`unicode` instances, subject to normal Python
    :class:`str` to :class:`unicode` coercion rules.  Unless ``fp.write()``
    explicitly understands :class:`unicode` (as in :func:`codecs.getwriter`) this
    is likely to cause an error. It's best to leave the default settings, because
    they are safe and it is highly optimized.
 
-   If *check_circular* is ``False`` (default: ``True``), then the circular
+   If *check_circular* is false (default: ``True``), then the circular
    reference check for container types will be skipped and a circular reference
    will result in an :exc:`OverflowError` (or worse).
 
-   If *allow_nan* is ``False`` (default: ``True``), then it will be a
+   If *allow_nan* is false (default: ``True``), then it will be a
    :exc:`ValueError` to serialize out of range :class:`float` values (``nan``,
-   ``inf``, ``-inf``) in strict compliance of the JSON specification, instead of
-   using the JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).
+   ``inf``, ``-inf``) in strict compliance of the JSON specification.
+   If *allow_nan* is true, their JavaScript equivalents will be used
+   (``NaN``, ``Infinity``, ``-Infinity``).
 
    If *indent* is a non-negative integer, then JSON array elements and object
    members will be pretty-printed with that indent level.  An indent level of 0
    will only insert newlines.  ``None`` (the default) selects the most compact
    representation.
 
-   If *separators* is an ``(item_separator, dict_separator)`` tuple, then it
-   will be used instead of the default ``(', ', ': ')`` separators.  ``(',',
-   ':')`` is the most compact JSON representation.
+   If specified, *separators* should be an ``(item_separator, dict_separator)`` 
+   tuple.  By default, ``(', ', ': ')`` are used.  To get the most compact JSON
+   representation, you should specify ``(',', ':')`` to eliminate whitespace.
 
-   *encoding* is the character encoding for str instances, default is UTF-8.
+   *encoding* is the character encoding for str instances, default is
+   ``'utf-8'``.
 
-   *default(obj)* is a function that should return a serializable version of
-   *obj* or raise :exc:`TypeError`.  The default simply raises :exc:`TypeError`.
+   If specified, *default* should be a function that gets called for objects
+   that can't otherwise be serialized.  It should return a JSON encodable
+   version of the object or raise a :exc:`TypeError`.  If not specified,
+   :exc:`TypeError` is always raised in those cases.
 
    To use a custom :class:`JSONEncoder` subclass (e.g. one that overrides the
    :meth:`default` method to serialize additional types), specify it with the
@@ -172,7 +176,7 @@ Basic Usage
 
    Serialize *obj* to a JSON formatted :class:`str`.
 
-   If *ensure_ascii* is ``False``, then the return value will be a
+   If *ensure_ascii* is false, then the return value will be a
    :class:`unicode` instance.  The other arguments have the same meaning as in
    :func:`dump`. Note that the default *ensure_ascii* setting has much
    better performance.
@@ -232,7 +236,7 @@ Basic Usage
    specified.  Encodings that are not ASCII based (such as UCS-2) are not
    allowed and should be decoded to :class:`unicode` first.
 
-   The other arguments have the same meaning as in :func:`dump`.
+   The other arguments have the same meaning as in :func:`load`.
 
 
 Encoders and decoders
@@ -342,26 +346,26 @@ Encoders and decoders
    for ``o`` if possible, otherwise it should call the superclass implementation
    (to raise :exc:`TypeError`).
 
-   If *skipkeys* is ``False`` (the default), then it is a :exc:`TypeError` to
+   If *skipkeys* is false (the default), then it is a :exc:`TypeError` to
    attempt encoding of keys that are not str, int, long, float or None.  If
-   *skipkeys* is ``True``, such items are simply skipped.
+   *skipkeys* is true, such items are simply skipped.
 
-   If *ensure_ascii* is ``True`` (the default), the output is guaranteed to be
+   If *ensure_ascii* is true (the default), the output is guaranteed to be
    :class:`str` objects with all incoming unicode characters escaped.  If
-   *ensure_ascii* is ``False``, the output will be a unicode object.
+   *ensure_ascii* is false, the output will be a unicode object.
 
-   If *check_circular* is ``True`` (the default), then lists, dicts, and custom
+   If *check_circular* is false (the default), then lists, dicts, and custom
    encoded objects will be checked for circular references during encoding to
    prevent an infinite recursion (which would cause an :exc:`OverflowError`).
    Otherwise, no such check takes place.
 
-   If *allow_nan* is ``True`` (the default), then ``NaN``, ``Infinity``, and
+   If *allow_nan* is true (the default), then ``NaN``, ``Infinity``, and
    ``-Infinity`` will be encoded as such.  This behavior is not JSON
    specification compliant, but is consistent with most JavaScript based
    encoders and decoders.  Otherwise, it will be a :exc:`ValueError` to encode
    such floats.
 
-   If *sort_keys* is ``True`` (the default), then the output of dictionaries
+   If *sort_keys* is true (the default), then the output of dictionaries
    will be sorted by key; this is useful for regression tests to ensure that
    JSON serializations can be compared on a day-to-day basis.
 
@@ -371,12 +375,12 @@ Encoders and decoders
    compact representation.
 
    If specified, *separators* should be an ``(item_separator, key_separator)``
-   tuple.  The default is ``(', ', ': ')``.  To get the most compact JSON
+   tuple.  By default, ``(', ', ': ')`` are used.  To get the most compact JSON
    representation, you should specify ``(',', ':')`` to eliminate whitespace.
 
-   If specified, *default* is a function that gets called for objects that can't
-   otherwise be serialized.  It should return a JSON encodable version of the
-   object or raise a :exc:`TypeError`.
+   If specified, *default* should be a function that gets called for objects
+   that can't otherwise be serialized.  It should return a JSON encodable
+   version of the object or raise a :exc:`TypeError`.
 
    If *encoding* is not ``None``, then all input strings will be transformed
    into unicode using that encoding prior to JSON-encoding.  The default is