README.rdoc in rubu-0.0.6 vs README.rdoc in rubu-0.0.7

@@ -97,11 +97,11 @@
 process convenient.
 
 *Step* is build action that transforms source file(s) to target
 file(s). For example, a C source file compilation is a *Step* where
 one source file is converted to a corresponding object file. *Step* is
-given source *Mark* and target *Mark* as arguments. Hence this type of
+given *Source-Mark* and *Target-Mark* as arguments. Hence this type of
 *Step* a is one-to-one mapping.
 
 Linking multiple objects to an executable is a many-to-one
 mapping. This is performed by a *Step* where there are multiple
 sources and one target, i.e. objects and the executable respectively.
@@ -139,11 +139,11 @@
 *Var* space, for example.
 
 To summarize and highlight the relationships between concepts, see the
 diagram below:
 
-    RBP => Trail+ => Step+ [s/p] => Move+ [s/p] => SourceMark*, TargetMark*
+    RBP => Trail+ => Step+ [s/p] => Move+ [s/p] => Source-Mark*, Target-Mark*
         => Order+
         => Var*
         => Info*
 
     * = Zero or more
@@ -154,23 +154,23 @@
 RBP includes *Trails*, *Orders*, and possibly *Vars* and
 *Infos*. *Trail* includes one or more *Steps*, which can be executed
 in sequence or in parallel.
 
 *Step* includes one or more *Moves*, and they can also be sequential
-or parallel. *Move* has typically at least one *SourceMark* and at
-least one *TargetMark*. However, there are exceptions as well.
+or parallel. *Move* has typically at least one *Source-Mark* and at
+least one *Target-Mark*. However, there are exceptions as well.
 
 
 The suggested ordering within {Rubu} Build Program is:
 
 [configuration] Process command line arguments and assign options that
                 are used to control the build process.
 
 [file collection] Collect source and target files either using Ruby
                   with glob pattern, direct references, or through
-                  manifest files. Convert file names to *Mark*
-                  objects.
+                  manifest files. Convert file names to *Mark* objects
+                  (*Source-Mark*, *Target-Mark*).
 
 [step definition] Define *Steps*. Inherit one of the *Step* types
                   (classes) and define at least the "step" method.
 
 [trail definition] Define *Trails*. Create all possible flows that
@@ -200,12 +200,13 @@
 is typically easiest to collect files programmatically. For example,
 to get all C source files:
 
     cee_files = Mark.glob( "#{Var[:source_dir]}/*.c" )
 
-This creates a list of *Mark* objects which are source files. The
-corresponding object files can be created with "peer" method:
+This creates a list of *Mark* objects which are source files,
+i.e. *Source-Marks*. The corresponding object (target) files can be
+created with "peer" method:
 
     obj_files = cee_files.peer( Var[ :build_dir ], '.o' )
 
 This method invocation takes an Array of *Mark* objects and calls
 "peer" method for them. "peer" method changes the directory and
@@ -228,11 +229,11 @@
 
 
 "setup" method is typically used to change the command according to
 user configuration. "step" method is the action for *Step*. {Rubu}
 executes it, if necessary. For example, if *Step* is a *StepAged*
-class, then the "step" method is only called if the source *Mark* is
-newer than the target *Mark*.
+class, then the "step" method is only called if the *Source-Mark* is
+newer than the *Target-Mark*.
 
 "step" method may include only one command or a set of commands. If
 one command is needed, it can be simply executed:
 
     def step