anchor.diff:    use the `--properties` shell option and list properties as a comma separated
     list of key=value pairs, like so:
   
  -[source,bash,subs=attributes]
  +[source,bash]
   ----
   stream deploy foo
       --properties "app.transform.count=2,app.transform.producer.partitionKeyExpression=payload"
  
positive.code: If neither a `partitionSelectorClass` nor a `partitionSelectorExpression` is
  present the result is `key.hashCode() % partitionCount`.
  
  ==== Inline vs file reference properties
  
  When using the Spring Cloud Dataflow Shell, there are two ways to provide deployment
  
negative.code: 2016-06-01 09:45:12.250  INFO 79194 --- [  kafka-binder-] log.sink    : 06/01/16 09:45:12
  2016-06-01 09:45:13.251  INFO 79194 --- [  kafka-binder-] log.sink    : 06/01/16 09:45:13
  ```
  === Application properties
  
  Application properties are the properties associated with each application in the stream. When the application is deployed, the application properties are applied to the application via
  command line arguments or environment variables based on the underlying deployment implementation.
  
  ==== Passing application properties when creating a stream
  
  The following stream
  
  [source,bash]
  ----
  dataflow:> stream create --definition "time | log" --name ticktock
  ----
  
  can have application properties defined at the time of stream creation.
  
  The shell command `app info` displays the white-listed application properties for the application.
  For more info on the property white listing refer to <<spring-cloud-dataflow-stream-app-whitelisting>>
  
  Below are the white listed properties for the app `time`:
  
  [source,bash]
  ----
  dataflow:> app info source:time
  ╔══════════════════════════════╤══════════════════════════════╤══════════════════════════════╤══════════════════════════════╗
  ║         Option Name          │         Description          │           Default            │             Type             ║
  ╠══════════════════════════════╪══════════════════════════════╪══════════════════════════════╪══════════════════════════════╣
  ║trigger.time-unit             │The TimeUnit to apply to delay│<none>                        │java.util.concurrent.TimeUnit ║
  ║                              │values.                       │                              │                              ║
  ║trigger.fixed-delay           │Fixed delay for periodic      │1                             │java.lang.Integer             ║
  ║                              │triggers.                     │                              │                              ║
  ║trigger.cron                  │Cron expression value for the │<none>                        │java.lang.String              ║
  ║                              │Cron Trigger.                 │                              │                              ║
  ║trigger.initial-delay         │Initial delay for periodic    │0                             │java.lang.Integer             ║
  ║                              │triggers.                     │                              │                              ║
  ║trigger.max-messages          │Maximum messages per poll, -1 │1                             │java.lang.Long                ║
  ║                              │means infinity.               │                              │                              ║
  ║trigger.date-format           │Format for the date value.    │<none>                        │java.lang.String              ║
  ╚══════════════════════════════╧══════════════════════════════╧══════════════════════════════╧══════════════════════════════╝
  ----
  
  Below are the white listed properties for the app `log`:
  
  [source,bash]
  ----
  dataflow:> app info sink:log
  ╔══════════════════════════════╤══════════════════════════════╤══════════════════════════════╤══════════════════════════════╗
  ║         Option Name          │         Description          │           Default            │             Type             ║
  ╠══════════════════════════════╪══════════════════════════════╪══════════════════════════════╪══════════════════════════════╣
  ║log.name                      │The name of the logger to use.│<none>                        │java.lang.String              ║
  ║log.level                     │The level at which to log     │<none>                        │org.springframework.integratio║
  ║                              │messages.                     │                              │n.handler.LoggingHandler$Level║
  ║log.expression                │A SpEL expression (against the│payload                       │java.lang.String              ║
  ║                              │incoming message) to evaluate │                              │                              ║
  ║                              │as the logged message.        │                              │                              ║
  ╚══════════════════════════════╧══════════════════════════════╧══════════════════════════════╧══════════════════════════════╝
  ----
  
  The application properties for the `time` and `log` apps can be specified at the time of `stream` creation as follows:
  
  [source,bash]
  ----
  dataflow:> stream create --definition "time --fixed-delay=5 | log --level=WARN" --name ticktock
  ----
  
  Note that the properties `fixed-delay` and `level` defined above for the apps `time` and `log` are the 'short-form' property names provided by the shell completion.
  These 'short-form' property names are applicable only for the white-listed properties and in all other cases, only _fully qualified_ property names should be used.
  
  
  ==== Passing application properties when deploying a stream
  
  The application properties can also be specified when deploying a stream. When specified during deployment, these application properties can either be specified as
   'short-form' property names (applicable for white-listed properties) or _fully qualified_ property names. The application properties should have the prefix "app.<appName/label>".
  
  For example, the stream
  
  [source,bash]
  ----
  dataflow:> stream create --definition "time | log" --name ticktock
  ----
  
  can be deployed with application properties using the 'short-form' property names:
  
  [source,bash]
  ----
  dataflow:>stream deploy ticktock --properties "app.time.fixed-delay=5,app.log.level=ERROR"
  ----
  
  When using the app label,
  
  [source,bash]
  ----
  stream create ticktock --definition "a: time | b: log"
  ----
  
  the application properties can be defined as:
  
  [source,bash]
  ----
  stream deploy ticktock --properties "app.a.fixed-delay=4,app.b.level=ERROR"
  ----
  
  ==== Passing stream partition properties during stream deployment
  A common pattern in stream processing is to partition the data as it is streamed.
  This entails deploying multiple instances of a message consuming app and using
  content-based routing so that messages with a given key (as determined at runtime)
  are always routed to the same app instance. You can pass the partition properties during
  stream deployment to declaratively configure a partitioning strategy to route each
  message to a specific consumer instance.
  
  See below for examples of deploying partitioned streams:
  
  