[ros-bond-core] 01/01: Improve descriptions

[Wookey]

This is an automated email from the git hooks/post-receive script.

wookey pushed a commit to branch master
in repository ros-bond-core.

commit ba2a5a450832da51def428ea9102401de1763b03
Author: Wookey <wookey at wookware.org>
Date:   Wed Oct 28 18:09:15 2015 +0000

    Improve descriptions
---
 debian/control | 77 ++++++++++++++++++++++++++++++++++++----------------------
 1 file changed, 48 insertions(+), 29 deletions(-)

diff --git a/debian/control b/debian/control
index 1394fce..3f44a18 100644
--- a/debian/control
+++ b/debian/control
@@ -23,38 +23,49 @@ Package: libbond-dev
 Section: libdevel
 Architecture: any
 Depends: ${misc:Depends}
-Description: Messages related to ROS bond_core - development
- A bond allows two processes, A and B, to know when the other has terminated,
- either cleanly or by crashing. The bond remains connected until it is either
- broken explicitly or until a heartbeat times out. Development package.
+Description: Messages related to Robot OS bond_core - development
+ This package is part of Robot OS (ROS). This is the 'bond' process state
+ machine library development files.
+ . 
+ Bond is a mechanism for checking when another process has
+ terminated. A bond allows two processes, A and B, to know when the
+ other has terminated, either cleanly or by crashing. The bond remains
+ connected until it is either broken explicitly or until a heartbeat
+ times out.
 
 Package: python-bond
 Section: python
 Architecture: all
 Depends: ${python:Depends}, ${shlibs:Depends}, ${misc:Depends}, python-genpy, python-std-msgs
-Description: Messages related to ROS bond_core - Python
- A bond allows two processes, A and B, to know when the other has terminated,
- either cleanly or by crashing. The bond remains connected until it is either
- broken explicitly or until a heartbeat times out.
+Description: Messages related to Robot OS bond_core - Python
+ This package is part of Robot OS (ROS). This is the 'bond' process state
+ machine library python bindings.
  .
- This package contains the generated Python package.
+ Bond is a mechanism for checking when another process has
+ terminated. A bond allows two processes, A and B, to know when the
+ other has terminated, either cleanly or by crashing. The bond remains
+ connected until it is either broken explicitly or until a heartbeat
+ times out.
 
 Package: cl-bond
 Section: lisp
 Architecture: all
 Depends: ${misc:Depends}
-Description: Messages related to ROS bond_core - LISP
- A bond allows two processes, A and B, to know when the other has terminated,
- either cleanly or by crashing. The bond remains connected until it is either
- broken explicitly or until a heartbeat times out.
+Description: Messages related to Robot OS bond_core - LISP
+ This package is part of Robot OS (ROS). This is the 'bond' process state
+ machine library LISP bindings.
  .
- This package contains the generated LISP library.
+ Bond is a mechanism for checking when another process has
+ terminated. A bond allows two processes, A and B, to know when the
+ other has terminated, either cleanly or by crashing. The bond remains
+ connected until it is either broken explicitly or until a heartbeat
+ times out.
 
 Package: libsmc-dev
 Section: libdevel
 Architecture: any
 Depends: ${misc:Depends}
-Description: State Machine Compiler (SMC) 
+Description: Robot OS 'bond' State Machine Compiler interface 
  The State Machine Compiler (SMC) from http://smc.sourceforge.net/
  converts a language-independent description of a state machine
  into the source code to support that state machine.
@@ -66,40 +77,48 @@ Package: python-smclib
 Section: python
 Architecture: any
 Depends: ${python:Depends}, ${shlibs:Depends}, ${misc:Depends}
-Description: State Machine Compiler (SMC) - Python package
+Description: Robot OS 'bond' State Machine Compiler python package
  The State Machine Compiler (SMC) from http://smc.sourceforge.net/
  converts a language-independent description of a state machine
  into the source code to support that state machine.
  .
- This package contains the libraries that a compiled state machine
- depends on, but it does not contain the compiler itself.
- .
- This package contains the Python package.
+ This package contains the Python interface.
 
 Package: libbondcpp-dev
 Section: libdevel
 Architecture: any
 Depends: libbondcpp0d (= ${binary:Version}), uuid-dev, ${misc:Depends}, libbond-dev, libroscpp-dev, libsmc-dev
-Description: Development files for ROS bondcpp library
- C++ implementation of bond, a mechanism for checking when another process has
- terminated.
+Description: Development files for Robot OS bondcpp library
+ This package is part of Robot OS (ROS). It is the 'bond' process state
+ machine library C++ implementation development files.
  .
- This package contains the development files for the library.
+ Bond is a mechanism for checking when another process has
+ terminated. A bond allows two processes, A and B, to know when the
+ other has terminated, either cleanly or by crashing. The bond remains
+ connected until it is either broken explicitly or until a heartbeat
+ times out.
 
 Package: libbondcpp0d
 Architecture: any
 Depends: ${shlibs:Depends}, ${misc:Depends}
-Description: ROS bondcpp library
- C++ implementation of bond, a mechanism for checking when another process has
- terminated.
- .
- This package contains the library.
+Description: Robot OS bondcpp library
+ This package is part of Robot OS (ROS). It is the 'bond' process state
+ machine library C++ implementation.
+ . 
+ Bond is a mechanism for checking when another process has
+ terminated. A bond allows two processes, A and B, to know when the
+ other has terminated, either cleanly or by crashing. The bond remains
+ connected until it is either broken explicitly or until a heartbeat
+ times out.
 
 Package: python-bondpy
 Section: python
 Architecture: any
 Depends: ${python:Depends}, ${shlibs:Depends}, ${misc:Depends}, python-bond, python-rospy, python-smclib
 Description: Python implementation of bond
+ This package is part of Robot OS (ROS). It is the 'bond' process state
+ machine library python implementation.
+ . 
  Bond is a mechanism for checking when another process has terminated. A
  bond allows two processes, A and B, to know when the other has terminated, 
  either cleanly or by crashing. The bond remains connected until it is either 

-- 
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/ros/ros-bond-core.git