| Fix the following issue: |
|
|
| # Add a scoped configuration system for cogs |
|
|
| Red's cogs currently have no consistent way to declare the settings they use or |
| to read and write those settings at different scopes (the bot as a whole, a |
| particular guild, a channel, a role, a user, or a specific member of a guild). |
| We want a small configuration subsystem that gives every cog a single object to |
| work with. |
|
|
| Add a `Config` class, importable as `from core.config import Config`, with the |
| behaviour described below. |
|
|
| ## Obtaining a config object |
|
|
| `Config.get_conf(cog_name, unique_identifier=0, force_registration=False)` |
| returns a fresh config object for a cog. `cog_name` is a string; the other two |
| arguments are keyword options. `force_registration` controls the strict mode |
| described further down and defaults to `False`. |
|
|
| ## Registering defaults |
|
|
| A cog declares the keys it uses, per scope, by registering defaults: |
|
|
| - `register_global(**defaults)` |
| - `register_guild(**defaults)` |
| - `register_channel(**defaults)` |
| - `register_role(**defaults)` |
| - `register_user(**defaults)` |
| - `register_member(**defaults)` |
|
|
| Each call records the given keys together with their default values for that |
| scope. Calling a register method more than once merges the new keys with the |
| ones already registered for that scope (later calls override earlier defaults |
| for the same key). Defaults for one scope are independent from every other |
| scope. |
|
|
| ## Reading and writing values |
|
|
| The config object itself represents the **global** scope. To work with another |
| scope you ask for it by id: |
|
|
| - `config.guild(guild_id)` |
| - `config.channel(channel_id)` |
| - `config.role(role_id)` |
| - `config.user(user_id)` |
| - `config.member(guild_id, member_id)` |
|
|
| An id may be given either as an integer or as an object that exposes an `id` |
| attribute (the object's `id` is used). Each of these returns a scoped view of |
| the configuration. |
|
|
| Reading a value is done by calling the key as a method on the relevant scope. |
| On the global scope `config.foo()` returns the value of `foo`; on another scope |
| `config.guild(123).foo()` returns the value of `foo` for guild `123`. If no |
| value has been stored for that key in that scope, the registered default for the |
| scope is returned. If the key was never registered (and strict mode is off), the |
| reader returns `None`. |
|
|
| Writing a value is asynchronous: `await scope.set(key, value)` stores `value` |
| for `key` in that scope, e.g. `await config.set("foo", 1)` for the global scope |
| or `await config.guild(123).set("foo", 1)` for a guild. After a value has been |
| set, reading the same key in the same scope returns the stored value. |
|
|
| `await scope.clear()` removes every stored value for that exact scope, so |
| subsequent reads fall back to the registered defaults again. |
|
|
| ## Scope isolation |
|
|
| Scopes and individual ids are fully isolated. Storing a value for one guild must |
| not change what another guild, the global scope, or any other scope reports. |
| Members are identified by the pair `(guild_id, member_id)`, so the same member |
| id under two different guilds is two distinct scopes. |
|
|
| ## Strict mode |
|
|
| When a config object is created with `force_registration=True`, reading or |
| writing a key that has not been registered for the scope being used raises |
| `AttributeError`. When `force_registration` is `False` (the default), reading an |
| unregistered key returns `None` and writing an unregistered key is allowed. |
|
|
