lib/Reaction/Manual/Glossary.pod

   1 =head1 NAME
   2
   3 Reaction::Manual::Glossary - Terms and Definitions used in Reaction
   4
   5 =head1 GLOSSARY
   6
   7
   8 =head3 Controller
   9
  10 Reaction controllers are extended L<Catalyst> controllers. The controllers coordinate
  11 L</Interface Model> access and actions with the view logic in your L</ViewPort>s.
  12
  13 =over
  14
  15 =item * L<Reaction::UI::Controller>
  16
  17 =item * L<Reaction::UI::Controller::Root>
  18
  19 =back
  20
  21
  22 =head3 Domain Model
  23
  24 This is the implementation of your business logic. An example would be a L<DBIx::Class> schema
  25 providing you with collections, objects and relationships.
  26
  27 Your Domain Model will interface with Reaction through an L</Interface Model>. Therefore your
  28 domain model itself can and should be decoupled from your Reaction application.
  29
  30 =over
  31
  32 =item * L<Reaction::Manual::Overview>
  33
  34 =back
  35
  36
  37 =head3 Focus Stack
  38
  39 Whenever you push a L</ViewPort> in your controller, you are pushing it onto the Focus Stack.
  40 When the root window (containing the root Focus Stack) is flushed by Reaction at the end
  41 of the request, the ViewPorts' L</Widget>s will be rendered inside each other.
  42
  43 A typical example would be a L<SiteLayout|Reaction::UI::ViewPort::SiteLayout> ViewPort
  44 being pushed onto the Focus Stack by your root action. A
  45 L<CRUD|Reaction::UI::Controller::Collection::CRUD> controller would then, if its list action
  46 was requested, push a L<ListView|Reaction::UI::ViewPort::ListView> ViewPort. On flushing,
  47 the ListView will be rendered inside the SiteLayout.
  48
  49 =over
  50
  51 =item * L<Reaction::UI::FocusStack>
  52
  53 =back
  54
  55
  56 =head3 Interface Model
  57
  58 Provides a standardized way for the application to interact with the
  59 L</Domain Model>s. It does this by providing objects, collections and actions.
  60
  61 A CRUD capable interface model can be generated from a L<DBIx::Class> schema on-the-fly via
  62 L<Reaction::InterfaceModel::Reflector::DBIC>.
  63
  64 =over
  65
  66 =item * L<Reaction::Manual::Overview>
  67
  68 =item * L<Reaction::Manual::Tutorial>
  69
  70 =item * L<Reaction::InterfaceModel::Object>
  71
  72 =item * L<Reaction::InterfaceModel::Collection>
  73
  74 =item * L<Reaction::InterfaceModel::Action>
  75
  76 =back
  77
  78
  79 =head3 Layout
  80
  81 Defines how a L</Widget> fragment is rendered. They are organized in L</LayoutSet>s. Its
  82 arguments are provided by the Widget the LayoutSet specified.
  83
  84 Layout fragments reference other fragments and can be overridden or wrapped when the
  85 LayoutSet is an extension of another.
  86
  87 =over
  88
  89 =item * L<Reaction::Manual::Templates>
  90
  91 =item * L<Reaction::Manual::RenderPage>
  92
  93 =back
  94
  95
  96 =head3 LayoutSet
  97
  98 Contains L</Layout>s. A LayoutSet is specified (or autodiscovered) for any
  99 L</ViewPort>. It determines which L</Widget> to use as the functional part used to
 100 render the ViewPort. A LayoutSet can also extend on another LayoutSet. With this,
 101 L</Layout>s of the parent can be modified. This allows for very fine-grained control
 102 when developing different L<Skin>s.
 103
 104 =over
 105
 106 =item * L<Reaction::Manual::RenderPage>
 107
 108 =item * L<Reaction::Manual::Overview>
 109
 110 =item * L<Reaction::UI::LayoutSet>
 111
 112 =back
 113
 114
 115 =head3 ListView
 116
 117 The ListView L</Widget>, L</ViewPort> and L</LayoutSet> group
 118 allows you to render an L</Interface Model> collection as a table.
 119
 120 =over
 121
 122 =item * L<Reaction::UI::ViewPort::ListView>
 123
 124 =item * L<Reaction::UI::Widget::ListView>
 125
 126 =item * L<Reaction::InterfaceModel::Collection>
 127
 128 =back
 129
 130
 131 =head3 MVC
 132
 133 Model-View-Controller - a high-level software design pattern, which focuses on separation of
 134 concerns.  For details on MVC, try here, here, and here.  Reaction is an extended MVC system;
 135 it uses a two-layer Model (the Interface Model, with the Domain Model below it).  Views are
 136 implemented by DOCTODO.  Controllers are represented by DOCTODO.
 137
 138
 139 =head3 Observer
 140
 141 DOCTODO: A software design pattern in which one
 142
 143
 144 =head3 RenderingContext
 145
 146 The context in which the L</Widget>'s rendering via the L</LayoutSet> will be done. A typical
 147 example would be a L<Template Toolkit|Template> LayoutSet being used to render a
 148 L</Widget> in the L<Reaction::UI::RenderingContext::TT> context.
 149
 150 =over
 151
 152 =item * L<Reaction::Manual::RenderPage>
 153
 154 =item * L<Reaction::UI::RenderingContext>
 155
 156 =back
 157
 158
 159 =head3 Role
 160
 161 A particular interface that a class implements.  Here, Role is used in the sense of Moose::Role;
 162 this same concept is sometimes called a Mix-In Class or a Decorator pattern.
 163
 164 =over
 165
 166 =item * L<Moose>
 167
 168 =item * L<Moose::Role>
 169
 170 =back
 171
 172
 173 =head3 Skin
 174
 175 A Skin usually contains L</LayoutSet>s and files for static delivery. Since Skins are extendable
 176 and can be switched by configuration, they allow easy customization of your application's
 177 look and feel.
 178
 179 =over
 180
 181 =item * L<Reaction::Manual::RenderPage>
 182
 183 =item * L<Reaction::UI::Skin>
 184
 185 =back
 186
 187
 188 =head3 View
 189
 190 In Reaction, the View modules handle rendering the ViewPort. ViewPorts are the V in MVC.
 191
 192 Technically, the View creates the L</RenderingContext> and finds the L</LayoutSet>s via the
 193 L</ViewPort>s and L</Widget>s from the LayoutSets that are required to render your page.
 194
 195 =over
 196
 197 =item * L<Reaction::Manual::RenderPage>
 198
 199 =item * L<Reaction::UI::View>
 200
 201 =item * L<Reaction::UI::View::TT>
 202
 203
 204 =back
 205
 206 =head3 ViewPort
 207
 208 Represents a part of your web pages output. Your application creates a page by stacking
 209 ViewPorts referencing your L</Interface Model>s inside another. To each ViewPort belongs a
 210 L</LayoutSet>, which will determine the layout and type of the L</Widget>s rendering your page.
 211
 212 =over
 213
 214 =item * L<Reaction::Manual::RenderPage>
 215
 216 =item * L<Reaction::UI::ViewPort>
 217
 218 =back
 219
 220
 221 =head3 Widget
 222
 223 The functionality needed to render a part of your page. The Widget that is used
 224 is determined by the L</LayoutSet>, which is in turn determined by the L</ViewPort>.
 225
 226 The Widget organizes the layouts contained in the LayoutSet and provides them with
 227 data to render.
 228
 229 =over
 230
 231 =item * L<Reaction::Manual::RenderPage>
 232
 233 =item * L<Reaction::Manual::Widgets>
 234
 235 =item * L<Reaction::UI::Widget>
 236
 237 =back
 238
 239
 240 =head1 SEE ALSO
 241
 242 Please refer to these documents for further and more general information:
 243
 244 =over
 245
 246 =item * L<Reaction::Manual>
 247
 248 =item * L<Reaction::Manual::Overview>
 249
 250 =item * L<Reaction::Manual::Intro>
 251
 252 =back
 253
 254 =head1 AUTHORS
 255
 256 See L<Reaction::Class> for authors.
 257
 258 =head1 LICENSE
 259
 260 See L<Reaction::Class> for the license.
 261
 262 =cut