summaryrefslogtreecommitdiffstats
path: root/API.txt
blob: ab0d0676d90e5d966e7c3f598fcf08eecedc8ff0 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
Features 1.x API for Drupal 7.x
-------------------------------
This file contains documentation for two audiences: site builders interested in
creating and managing features and module developers interested in integrating
with the features module.


Terminology
-----------
- A **feature module** is a Drupal module that contains the `feature` key in its
`.info` file. This array describes the components that should be managed by
Features within the module.

- A **component** is a configuration object that can be exported. Examples: a
view, content type or CCK field instance.

- A **machine name** is a string identifier for a specific type of component and
should be unique within a single Drupal site. It should not be a numerically
generated serial id.

- An **exportable** component is one that can be used solely from a default hook
in code and without an instance in the database. For example, a view that lives
in code does not need an entry in the database in order to be used.

- A **faux-exportable** component is one that must exist in the database in
order to be used. Any exports of this component are used to create or
synchronize entries in the database that share the same machine name.


### Component states

Features provides some infrastructure to determine the state of components on
the site. To determine the state of a component Features keeps track of three
things using an md5 hash of

- current code for the component. This is the configuration as actually
represented in code by a given feature.

- the most recent prior code state that differs from the current code state. For
example, if an `svn update` changes the configuration of a view, this stores the
code state *prior* to the update.

- The "normal" component state. This is the configuration represented by the
component as stored in the database or the default component (with any changes
introduced by `drupal_alter()`) if no database override exists.

Using these three values, Features determines a component to be in one of the
following five states:

- **Default** (`FEATURES_DEFAULT`) The object has no database entry or the
database entry matches the state of the component in code. This should be the
default state of components after installing a feature. Updating the component
can be done by altering the code definition directly.

- **Overridden** (`FEATURES_OVERRIDDEN`) The code remains constant but the
database object does not match the state of the component in code. Changes must
be reverted before the component can be updated from code.

- **Needs review** (`FEATURES_NEEDS_REVIEW`) The previous code state, database
state, and current code state all differ. This occurs most commonly when a user
changes one of her components and then pulls updates to her codebase. Since
there is no way to tell whether the code state or the database state is more
recent/valid, user input is necessary to resolve this state.

- **Rebuildable** (`FEATURES_REBUILDABLE`) This state only applies to
**faux-exportables** and indicates that the database component must and can be
safely updated from the code definition. The database entry does not match the
current code state but does match the previous code state. Features assumes that
in this scenario the user has made no substantive changes and the component can
be updated automatically.

- **Rebuilding** (`FEATURES_REBUILDING`) This state is rarely seen and only
applies to **faux-exportables.** This state is shown when a
`FEATURES_REBUILDABLE` component is *currently* being synced to the database.
Usually this operation is very fast and short lived. However, if the operation
is interrupted (e.g. the server goes down) this state will be seen until the
rebuild locking semaphore is cleared.


How a feature is generated
--------------------------
At a high level Features writes the code in a feature module using the following
steps:

1. An `.info` file describing the components that should be included in a
Feature is generated. It is either read from an existing feature or generated
through the Features UI.

2. Features converts the info file into an `$export` array which contains a list
of elements to be exported. Each component type is given a chance to add to the
export list as well as request that *other* components be given a second chance
to add to the `$export` array.

3. If any additional components have been queued up in the `$pipe` we repeat
step 2 for each of the queued component types.

4. Once a full `$export` array is populated each component renders items from
the `$export` array to PHP code as a exportable defaults hook.

5. Finally, Features writes the code into files and delivers it as a
downloadable package (UI) or writes it directly to a module directory (drush).

This workflow makes a variety of things possible:

### Add components to a feature

Add the components to the `features` array in the feature's `.info` file and run
`drush features-update`. The same operation can be performed using the
*Recreate* page in the Features UI.

### Remove components from a feature

Remove the corresponding component lines from the feature's `.info` file and run
`drush features-update`. The same operation can be performed using the
*Recreate* page in the Features UI.

### Rename a component

Rename a component by changing its name in the feature's `.info` file and the
key and name property of the exported object in the appropriate `.inc` file in
the feature. Note that any references in other configuration objects to the
previous name should also be updated.


Integrating your module with the Features API
---------------------------------------------
This section is for developers interested in adding Features-based management
for the configuration objects in their modules. From the perspective of
Features, there are a few different ways that modules store their configuration:

- In the `variable` table using `variable_set()`. If a module is using variables
for storing configuration, these variable settings can be exported with Features
by using the [Strongarm][1] module.

  **Features integration:** Install the Strongarm module.

- Using a custom table with a serial ID for identifying configuration objects.
If this is the case, you will need to change your schema to use a string
identifier / machine name for each object.

  **Features integration:** Fix your schema first, then see below.

- Using a custom table with a machine name identifier and custom exportables
handling (e.g. you have your own defaults hook handling and export generation).
If this is the case, you will need to implement many of the features hooks
yourself.

  **Features integration:** `hook_features_api()`, `hook_features_export()`,
`hook_features_export_render()`, `hook_features_export_options()`,
`hook_features_revert()`.

- Using a custom table with CTools Export API integration. If this is the case,
Features will automatically have integration with your module. You can implement
any of the Features hooks in order to override the default CTools exportables
integration behavior.

  **Features integration:** Automatically provided. You may implement any of the
Features hooks where you need further customization for your configuration
object.

If it isn't clear by now, we highly recommend using the [CTools][2] Export API
for adding exportables to your module. Stella has written a [fantastic HOWTO][3]
on using the CTools Export API that can get you started.


An overview of Features hooks
-----------------------------
Extensive documentation of the hooks provided by Features is available in
`features.api.php`. This section provides a short overview of each hook and its
role.

- `hook_features_api()` defines one or more component types that are available
to Features for export and a variety of settings for each type.
- `hook_features_export()` processes a list of components, detecting any
dependencies or further components
- `hook_features_export_options()` provides an array of components that can be
exported for a given type.
- `hook_features_export_render()` renders a set of components to code as a
defaults hook.
- `hook_features_revert()` reverts components of a feature back to their default
state.
- `hook_features_rebuild()` updates faux-exportable components back to their
default state. Only applies to faux-exportables.


[1]: http://drupal.org/project/strongarm
[2]: http://drupal.org/project/ctools
[3]: http://civicactions.com/blog/2009/jul/24/using_chaos_tools_module_create_exportables