Construct a list of Canvas LMS REST API endpoints.

In preparation for implementing the full API functionality in the
canvaslms package, I needed to first obtain a list of all the API
endpoints.

 - get_api_docs.sh
   - Retrieves the "All Resources" page of the Canvas LMS API docs
     (https://canvas.instructure.com/doc/api/all_resources.html)
   - Output saved as all_resources.html
 - extract_endpoints.sh
   - Perl script that pulls all of the GET/PUT/POST/DELETE endpoints
     from all_resources.html.
   - Requires two arguments: 1) the path of the all_resources.html
     file; 2) the intended path of the output file (I prefer
     api_endpoints.html).

These two scripts can be used to update the API list from time to time
as Canvas undergoes constant development.
Create development roadmap notes.
Put CSV string conversion code into its own function.

Separation of concerns.  Originally the CSV conversion code was
part of a function that also called the API, etc.  This code
now resides in canvaslms/api/util/__init__.py as toCSVString.
Rename callapi/call_api_csv.py to bin/callapi.py

These names are more in the spirit of what these scripts are
intended to do.  Because the name no longer suggests CSV output
specifically, I will add functionality in the future to allow the
user to be able to choose the output format.  For now, however, the
default output format is still CSV.
Implement function to read JSON-formatted config files.

Decided to use JSON as the representation for the configuration files
due to its ubiquitous nature.  Configuration files should therefore
consist of exactly one map (dict) object.  Anything else will throw
an exception.

canvaslms/bin/configutil.py contains the following functions:
 - readconfig(config_str): Decodes the JSON-encoded configuration map
   from a string.
 - readconfigfile(path): Read the file at path and pass its contents
   as a string to readconfig.
Implement function to update one dict with new values from another.

CCS -- Cascading Config Sheets

I'd like to be able to apply partial configurations at multiple stages.
For example:
 1) Check the CANVASLMS_API_CONFIG_PATH environment variable. If one exists,
    read in the configuration data from the specified file.
 2) Check the --config command line argument.  If it is given, read in the
    configuration data from the specified file, superseding the options
    obtained in 1).
 3) Check for other command line arguments specifying various configuration
    options.  These supersede options obtained from both 1) and 2).

To that end, I created a function (updatedict in
canvaslms/bin/configutil.py) to update a map with values from a new map.
Check CANVASLMS_API_CONFIG_PATH environment variable for config file.

First stage in the configuration process will be to check the
CANVASLMS_API_CONFIG_PATH environment variable for a path leading to a
configuration file. If it is found, load it.
Implement functions for retrieving values from configuration object.

canvaslms/bin/configutil.py:
 - get_config_value(config_obj, key): Return the configuration value in
   config_obj that is associated with key.  If key does not exist,
   return None.
 - get_required_config_value(config_obj, key): Same as get_config_value,
   but instead throws a MissingConfigurationValueError.
Switch from command line args to a configuration file.

In its current state, the program looks for a file path in the
CANVASLMS_API_CONFIG_PATH environment variable.  If found, it reads
in the JSON-encoded configuration map object.

The three specific configuration values that the program looks for at
this point are (case-sensitive):
 - TokenPath: the path of the file containing the Canvas API
   authentication token.
 - CavnasHost: the name of the host running the instance of Canvas for
   which you'd like to access the API.
 - APICall: the actual call to make (e.g., "accounts/123/courses")

Currently the only way to specify an API call is to set the APICall
value in the configuration file.  This will change shortly.
Add support for configuration files and command line args.

Something that made this script really klunky to use in the past
was that, in addition to the actual API call you were trying to make,
you also had to specify the Canvas host and the path to the
authentication token file on the command line.

By adding functionality for configuration files and for command
line options, I've made the process more efficient and user-friendly.

For example, if a proper configuration file is used one can make a
call to the API with an invocation as simple as follows:

  python3 -m canvaslms.bin.callapi account/123456/courses
Clean up documentation.