Tidy creating-and-registering-behaviors.md

Author: stevepiercy

plone.app.dexterity/behaviors/creating-and-registering-behaviors.md

@@ -1,36 +1,35 @@
 ---
 myst:
   html_meta:
-    "description": ""
-    "property=og:description": ""
-    "property=og:title": ""
-    "keywords": ""
+    "description": "How to create a basic behavior that provides form fields for content types in Plone"
+    "property=og:description": "How to create a basic behavior that provides form fields for content types in Plone"
+    "property=og:title": "How to create a basic behavior that provides form fields for content types in Plone"
+    "keywords": "Plone, behaviors, content types, create, register"
 ---
 
 # Creating and registering behaviors
 
-**How to create a basic behavior that provides form fields**
+This chapter describes how to create a basic behavior that provides form fields.
 
-The following example is based on the [collective.gtags] product.
-It comes with a behavior that adds a *tags* field to the “Categorization” fieldset, storing the actual tags in the Dublin Core *Subject* field.
+The following example is based on the [`collective.gtags`](https://pypi.org/project/collective.gtags/) product.
+It comes with a behavior that adds a `tags` field to the `Categorization` fieldset, storing the actual tags in the Dublin Core `Subject` field.
 
-*collective.gtags* is a standard package, with a *configure.zcml*, a GenericSetup profile, and a number of modules.
-We won’t describe those here, though, since we are only interested in the behavior.
+`collective.gtags` is a standard package, with a `configure.zcml`, a GenericSetup profile, and a number of modules.
+We won't describe those here, though, since we are only interested in the behavior.
 
-First, there are a few dependencies in *setup.py*:
+First, there are a few dependencies in {file}`setup.py`.
 
 ```python
 install_requires=[
-    ...,
-    'plone.behavior',
-    'zope.schema',
-    'zope.interface',
-    'zope.component',
+    # ...,
+    "plone.behavior",
+    "zope.schema",
+    "zope.interface",
+    "zope.component",
 ],
 ```
 
-Next, we have *behaviors.zcml*, which is included from *configure.zcml* and contains all necessary configuration to set up the behaviors.
-It looks like this:
+Next, we have {file}`behaviors.zcml`, which is included from {file}`configure.zcml`, and contains all the necessary configuration to set up the behaviors.
 
 ```xml
 <configure
@@ -51,26 +50,26 @@ It looks like this:
 </configure>
 ```
 
-We first include the *plone.behavior meta.zcml* file, so that we get access to the *\<plone:behavior />* ZCML directive.
+We first include the `plone.behavior meta.zcml` file, so that we get access to the `<plone:behavior />` ZCML directive.
 
-The behavior itself is registered with the *\<plone:behavior />* directive.
-We set a *title* and a *description*, and then specify the **behavior interface** with the *provides* attribute.
+The behavior itself is registered with the `<plone:behavior />` directive.
+We set a `title` and a `description`, and then specify the `behavior interface` with the `provides` attribute.
 This attribute is required, and is used to construct the unique name for the behavior.
-In this case, the behavior name is *collective.gtags.behaviors.ITags*, the full dotted name to the behavior interface.
-When the behavior is enabled for a type, it will be possible to adapt instances of that type to *ITags*.
-That adaptation will invoke the factory specified by the *factory* attribute.
+In this case, the behavior name is `collective.gtags.behaviors.ITags`, the full dotted name to the behavior interface.
+When the behavior is enabled for a type, it will be possible to adapt instances of that type to `ITags`.
+That adaptation will invoke the factory specified by the `factory` attribute.
 
-The *behaviors.py* module looks like this:
+The following is the {file}`behaviors.py` module.
 
 ```python
-"""Behaviours to assign tags (to ideas).
+"""Behaviors to assign tags (to ideas).
 
-Includes a form field and a behaviour adapter that stores the data in the
+Includes a form field and a behavior adapter that stores the data in the
 standard Subject field.
 """
 
 from plone.dexterity.interfaces import DexterityContent
-# if your package was made with mr.bob, add your MessageFactory like this:
+# if your package was made with mr.bob, add your MessageFactory as shown:
 from collective.mypackage import _
 from plone.autoform.interfaces import IFormFieldProvider
 from plone.supermodel import directives
@@ -86,9 +85,9 @@ class ITags(model.Schema):
     """
 
     directives.fieldset(
-            'categorization',
-            label=_('Categorization'),
-            fields=('tags',),
+            "categorization",
+            label=_("Categorization"),
+            fields=("tags",),
         )
 
     tags = Tags(
@@ -120,24 +119,20 @@ class Tags(object):
         self.context.setSubject(tuple(value))
 ```
 
-We first define the *ITags* interface, which is also the behavior interface.
-Here, we define a single attribute, *tags*, but we could also have added methods and additional fields if required.
+We first define the `ITags` interface, which is also the behavior interface.
+Here we define a single attribute, `tags`, but we could also have added methods and additional fields if required.
 Naturally, these need to be implemented by the behavior adapter.
 
-Since we want this behavior to provide form fields, we derive the behavior interface from *model.Schema* and set form hints using
-*plone.supermodel.directives*.
-We also mark the *ITags* interface with *IFormFieldProvider* to signal that it should be processed for form fields by the standard forms.
-See the [Dexterity Developer Manual] for more information about setting form hints in schema interfaces.
+Since we want this behavior to provide form fields, we derive the behavior interface from `model.Schema` and set form hints using `plone.supermodel.directives`.
+We also mark the `ITags` interface with `IFormFieldProvider` to signal that it should be processed for form fields by the standard forms.
+See the {doc}`Dexterity Developer Manual <../index>` for more information about setting form hints in schema interfaces.
 
-If your behavior does not provide form fields, you can just derive from *zope.interface.Interface* and omit the *alsoProvides()* line.
+If your behavior does not provide form fields, you can just derive from `zope.interface.Interface` and omit the `alsoProvides()` line.
 
 Next, we write the class that implements the behavior adapter and acts as the adapter factory.
-Notice how it implements the behavior interface (*ITags*), and adapts a broad interface *(IDexterityContent*).
+Notice how it implements the behavior interface (`ITags`), and adapts a broad interface `(IDexterityContent`).
 The behavior cannot be enabled on types not supporting this interface.
-In many cases, you will omit the *adapter()* line, provided your behavior is generic enough to work on any context.
+In many cases, you will omit the `adapter()` line, provided your behavior is generic enough to work on any context.
 
 The adapter is otherwise identical to any other adapter.
-It implements the interface, here by storing values in the *Subject* field.
-
-[collective.gtags]: http://svn.plone.org/svn/collective/collective.gtags
-[dexterity developer manual]: ../index.html
+It implements the interface, here by storing values in the `Subject` field.