Commits

Marius Gedminas committed 44ee07a

Multiple typos fixed.

Comments (0)

Files changed (11)

docs/whats_new.rst

 
 WebHelpers 1.0 has a lot of new features compared to 0.6.4. Several modules
 deprecated in 0.6.4 were removed, but otherwise there are only a few API
-incompatibilties with the 0.6 series.
+incompatibilities with the 0.6 series.
 
 Deleted packages
 ++++++++++++++++
 New helpers to flatten nested lists and tuples, and to
 gather all the subclasses of a specified class. There's an exception
 ``OverwriteError``, a ``DeclarativeException`` class for making your own
-exceptions with constant messages, and a ``deprecate`` functioand n.
+exceptions with constant messages, and a ``deprecate`` function.
 
 webhelpers.number
 +++++++++++++++++

webhelpers/containers.py

     
     Alternatives to this class include ``collections.namedtuple`` in Python
     2.6, and ``formencode.declarative.Declarative`` in Ian Bicking's FormEncode
-    package.  Both alternatives offer more featues, but ``DumbObject``
+    package.  Both alternatives offer more features, but ``DumbObject``
     shines in its simplicity and lack of dependencies.
 
     """
     ::
 
         >> extract_keys({"From": "F", "To": "T", "Received", R"}, ["To", "From"]) 
-        ({"From": "F", "To": "T"}, {"Recived": "R"})
+        ({"From": "F", "To": "T"}, {"Received": "R"})
         >>> regular, extra = extract_keys({"From": "F", "To": "T", "Received": "R"}, ["To", "From"]) 
         >>> sorted(regular.keys())
         ['From', 'To']
     of the keys are missing.
 
     ``optional`` is a list of optional keys. The corresponding values will be
-    appended to the return list, substititing None for missing keys.
+    appended to the return list, substituting None for missing keys.
 
     ``one_of`` is a list of alternative keys. Take the first key that exists 
     and append its value to the list. Raise KeyError if none of the keys exist.
     table is row major: it consists of several <tr> rows, each containing
     several <td> cells.  But a <div> layout consists of only one row, each
     containing an entire subarray. The <div>s have style "float:left", which
-    makes them appear horizonally. The items within each <div> are placed in
-    their own <div>'s or separatad by <br />, which makes them appear
+    makes them appear horizontally. The items within each <div> are placed in
+    their own <div>'s or separated by <br />, which makes them appear
     vertically.  The point is that an HTML table is row major (``array[0]`` is
     the first row), while a group of div columns is column major (``array[0]``
     is the first column). ``transpose()`` can be used to switch between the

webhelpers/date.py

     
     carry_over = [('month', 'year', granularity_size['month']),
                   ('year', 'decade', granularity_size['year']),
-                  ('decade', 'centry', granularity_size['decade'])]
+                  ('decade', 'century', granularity_size['decade'])]
     
     _process_carryover(deltas, carry_over)
     

webhelpers/feedgenerator.py

     def add_georss_point(self, handler, coords, w3c_geo=False):
         """
         Adds a GeoRSS point with the given coords using the given handler.
-        Handles the differences between simple GeoRSS and the more pouplar
+        Handles the differences between simple GeoRSS and the more popular
         W3C Geo specification.
         """
         if w3c_geo:

webhelpers/markdown.py

 
     """
        Replaces underlined headers with hashed headers to avoid
-       the nead for lookahead later.
+       the need for lookahead later.
     """
 
     def run (self, lines):

webhelpers/mimehelper.py

             MIMETypes.add_alias('csv', 'text/csv')
             
             # code in a Pylons controller
-            def somaction(self):
+            def someaction(self):
                 # prepare a bunch of data
                 # ......
                 

webhelpers/number.py

 #### Number formatting ####
 
 def format_number(n, thousands=",", decimal="."):
-    """Format a number with a thousands separator and decimal delimeter.
+    """Format a number with a thousands separator and decimal delimiter.
 
     ``n`` may be an int, long, float, or numeric string.
     ``thousands`` is a separator to put after each thousand.

webhelpers/paginate.py

 ------------------
 
 One page of items is represented by the *Page* object. A *Page* gets
-initalized with two parameters at least:
+initialized with two parameters at least:
 
 - the collection of items to pick a range from
 - the page number that is required (default is 1 - the first page)
 Page numbers and item numbers start at 1. This concept has been used
 because users expect that the first page has number 1 and the first item
 on a page also has number 1. So if you want to use the page's items by
-their index number please note that you have to substract 1.
+their index number please note that you have to subtract 1.
 
 This module is the successor to the obsolete ``webhelpers.pagination``
 module.  It is **NOT** API compatible.
             Default: '>'
 
         separator:
-            String that is used to seperate page links/numbers in the 
+            String that is used to separate page links/numbers in the 
             above range of pages.
 
             Default: ' '
             action (onclick) then this parameter gets set and the application
             is supposed to return a partial content. And without
             Javascript this parameter is not set. The application thus has
-            to check for the existance of this parameter to determine
+            to check for the existence of this parameter to determine
             whether only a partial or a full page needs to be returned.
             See also the examples in this modules docstring.
 
             radius of linked pages around the current page in
             regexp_match.group(1) as a string
 
-        This funtion is supposed to be called as a callable in 
+        This function is supposed to be called as a callable in 
         re.sub.
         
         """

webhelpers/pylonslib/flash.py

         -webkit-box-shadow: 0 0 5px silver;
     }
 
-Choosing different colours for the categories is left as an exersise
+Choosing different colours for the categories is left as an exercise
 for the reader.
 
 Next we create the javascript that will manage the needed behaviour (this
 JSON integration
 ----------------
 
-It is not unusal to perform a remote task using a JSON call and show a
+It is not unusual to perform a remote task using a JSON call and show a
 result message to the user. This can easily be done using a simple wrapper
 around the ShowMessage method::
 
    </script>
 
 This sets up a simple form which can be submitted normally by non-javascript
-enabled browsers. If a user does hava javascript an AJAX call will be made
+enabled browsers. If a user does have javascript an AJAX call will be made
 to the server and the result will be shown in a message. While the call is
 active the button will be marked with a *processing* class.
 
     def handler(self):
        ..
        ..
-       return dict(message=u"Settings succesfully updated")
+       return dict(message=u"Settings successfully updated")
 """
 
 # Do not import Pylons at module level; only within functions.  All WebHelpers

webhelpers/pylonslib/secure_form.py

 This ensures the request came from the originating page. See
 http://en.wikipedia.org/wiki/Cross-site_request_forgery for more information.
 
-Pylons provides an ``authenticate_form`` decorator that does this verfication
+Pylons provides an ``authenticate_form`` decorator that does this verification
 on the behalf of controllers.
 
 These helpers depend on Pylons' ``session`` object.  Most of them can be easily 

webhelpers/text.py

         return form
 
 def chop_at(s, sub, inclusive=False):
-    """Truncate string ``s`` at the first occurence of ``sub``.
+    """Truncate string ``s`` at the first occurrence of ``sub``.
 
     If ``inclusive`` is true, truncate just after ``sub`` rather than at it.
 
     """Simplify HTML text by removing tags and several kinds of formatting.
     
     If the ``unidecode`` package is installed, it will also transliterate 
-    non-ASCII Unicode characters to their nearest pronounciation equivalent in
+    non-ASCII Unicode characters to their nearest pronunciation equivalent in
     ASCII.
 
     Based on Ruby's stringex package
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.