Updated more-conditions, print-items dependencies in options.asd

* options.asd (system options): added version 0.3 to system dependency
  on more-conditions; changed system dependency print-items ->
  utilities.print-items and added version 0.1
Improved {print,parse}-name in src/name.lisp, added tests

* src/name.lisp (defrule component/stringish): fixed eager parsing of
  wild component strings
  (print-name): colon? controls whether the empty name should be
  printed as "<root>"
* src/protocol.lisp (name-equal t t): call `name-component' on both
  names
  (merge-names eql nil t): use type of right name as result type
  (find-option t t): changed specializer list -> t
* src/package.lisp (package options): added exported symbol print-name
* test/name.lisp (%make-name): new function; helper function for
  creating names in tests
  (test wildcard-name.construction): new test; test constructing
  wildcard names
  (test name-matches.smoke): renamed name-matches{/ -> .}smoke; use
  `%make-name'
  (test name-<.smoke): new test; smoke test for `name-<'
  (test merge-names.smoke): new test; smoke test for `merge-names'
  (test parse-name.smoke): new test; smoke test for `parse-name'
  (test print-name.smoke): new test; smoke test for `print-name'
* test/package.lisp (package options.test): added import-from options
  symbols wild-name
Added make-name in src/{name,protocol}.lisp

* src/types.lisp (non-wild-name-component): new type; a non-wild name
  component is a string
  (wild-name-component): simplified
  (name-component): use `non-wild-name-component'
* src/name.lisp (make-name string): new method; construct a name from
  a string
  (make-name sequence): new method; construct a name from a sequence
  of components
  (make-name wildcard-name): new method; no-op
* src/protocol.lisp (make-name): new generic function; construct a
  name from a string, a sequence of components or an existing name
  (make-name t): new method; signal an error for invalid inputs
* src/mixins.lisp (named-mixin::name): removed initarg; added writer
  option-%name
  (shared-initialize :after named-mixin t): new method; apply
  `make-name' to received name
* src/package.lisp (package :options): added exported symbols
  non-wild-name-component and make-name
* test/name.lisp (%make-name): removed; tests use `make-name' instead
  (test wildcard-name.construction): use `make-name'; added some cases
  (test make-name.smoke): new test; smoke test for `make-name'
  (test name-matches.smoke): use `make-name'
  (test name-<.smoke): likewise
  (test merge-names.smoke): likewise
  (test parse-name.smoke): likewise
  (test print-name.smoke): likewise
* test/package.lisp (package options.test): added imported from
  options symbol name
Fixed corner case in name-matches in src/name.lisp

* src/name.lisp (name-matches wildcard-name t): fixed case when
  wild-inferiors in query matches entire name
* test/name.lisp (test name-matches.smoke): added test cases for above
  corner case; simplified syntax
Renamed, improved name< function in src/{protocol,name}.lisp

* src/protocol.lisp (name<): renamed name-< -> name<
  (method name< t t): renamed name-< -> name< changed to
  implementation which walks components as previously done for wild
  names; in addition, compares string components
* src/name.lisp (name-< wildcard-name wildcard-name): removed; now
  handled by (name< t t) method
  (name< sequence wildcard-name): renamed name-< -> name<; changed
  specializer list -> sequence; delegate wild name to next method
  (name< wildcard-name sequence): likewise
* src/mixins.lisp (setf find-option :after t t list-container-mixin):
  adapted to renamed `name<' function
* src/schema.lisp (find-option t standard-schema): likewise
  (setf find-child :after t t standard-schema): likewise
* src/package.lisp (package options): changed exported symbol name-<
  -> name<
* test/name.lisp (test name<.smoke): renamed name-<.smoke ->
  name<.smoke; adapted to new behavior; added tests cases; simplified
  syntax
Fixed, simplified test merge-names.smoke in test/name.lisp

* test/name.lisp (merge-names.smoke): use `name-equal' instead of
  `name-matches'; simplified syntax
Test tools, fixes in test/{package,sources/protocol,sources/package}.lisp

* test/package.lisp (package options.test): added exported symbol
  run-tests
  (mock-sink): new class; mock sink for tests
  (notify mock-sink t t t): new method; stores calls to mock-sink
* test/sources/protocol.lisp (in-suite options.sources): place tests
  in correct suite
* test/sources/package.lisp (package options.sources.test): added used
  packages alexandria, split-sequence, iterate and options.sources;
  added imported from options.test symbols mock-sink and sink calls
  (mock-syntax): new class; mock for syntax classes
  (register-provider/class syntax :mock): register mock syntax
  (shared-initialize :after mock-syntax t): new method; allow
  `mock-syntax' to accept source initarg
  (process-content mock-syntax stream t): new method; remember
  `notify' calls
  (make-random-string): new function; return a random string of
  specified length
  (with-environment-variable): new macro; execute code with specified
  environment variables set to specified values
  (with-file): new macro; execute code with a specified file created
  and populated with a specified content
  (with-files): new macro; like `with-file' for multiple files
  (with-source-and-sink): new macro; execute code with a source and
  sink instance
  (expecting-sink-calls): new macro; check actual calls to a
  `mock-sink' against expected ones
Added notification protocol in src/protocol.lisp

* src/conditions.lisp (notification-error): new condition class;
  signaled when notifying a sink fails
* src/protocol.lisp (notify): new generic function; notifies a sink of
  an option-related event
  (notify :around t t t t): new method; default behavior of the
  `notify' function
* src/package.lisp (package options): added exported symbols
  notification-error, notification-error-sink,
  notification-error-event, notification-error-name,
  notification-error-source and notify
* test/sources/protocol.lisp (test initialize.default-behavior): new
  test; test default behavior of `initialize' function
  (test notify.default-behavior): similar for `notify'
* test/package.lisp (package options.test): added imported-from
  options.sources symbol initialize
  (initialize mock-sink eql :intentional-error): new method; can be
  used to signal an error
  (notify mock-sink eql :intentional-error t t): likewise
Exported symbols and improved documentation in src/*.lisp

* src/conditions.lisp (option-condition): added documentation string
  (value-condition): likewise
  (option-value-error): likewise; fixed report
  (option-value-type-error): likewise
* src/mixins.lisp (named-mixin): added documentation string
* src/configuration (option-cell): likewise
* src/protocol.lisp (option-name): likewise
  (option-type): likewise
* src/package.lisp (package options): added exported symbols
  option-condition-option ,value-condition-value ,option-value-error
  option-value-type-error
* src/sources/protocol.lisp (define-service source): added
  documentation string
Fixes, tests for src/sources/source-environment-variables.lisp

* src/sources/source-environment-variables.lisp
  (process environment-variables t): use sink properly; downcase
  names; added restarts; some cosmetic changes
* test/sources/source-environment-variables.lisp: renamed
  test/sources/{ -> source-}environment-variables.lisp
  (test environment-variables-source.smoke): new test
* options.asd (system options-test): added file
  test/sources/source-environment-variables.lisp
Improved value validation protocol in src/{protocol,mixins}.lisp

* src/conditions.lisp (option-value-error): added superclass
  `chainable-condition'
* src/protocol.lisp (validate-value): added documentation string
  (validate-value-using-type): new generic function; validate value
  based on schema item type
  (validate-value :around t t): new method; implements the default
  behavior of the `validate-value' function
* src/mixins.lisp (type-based-validation-mixin): new class; perform
  value validation based on the type of the schema item
  (validate-value type-based-validation-mixin t): new method; dispatch
  to `validate-value-using-type'
  (validate-value-using-type type-based-validation-mixin t cons): new
  method; dispatch to eql-specialized methods
  (validate-value-using-type type-based-validation-mixin t t): new
  method; validate type using `typep'
  (validate-value-using-type type-based-validation-mixin t and): new
  method; validate `and' types
  (validate-value-using-type type-based-validation-mixin t or): new
  method; validate `or' types
* src/schema.lisp (schema-children): added superclass
  `type-based-validation-mixin'
  (validate-value standard-schema-item t): removed; now provided by
  `type-based-validation-mixin'
* src/package.lisp (package options): added exported symbol
  validate-value-using-type
* test/mixins.lisp: new file: contains tests for mixin classes
* test/package.lisp (package options.test): added imported from
  options symbol type-based-validation-mixin
* options.asd (system options-test): added file test/mixins.lisp
Improved value merging protocol in src/{protocol,mixins}.lisp

* src/protocol.lisp (merge-values): added documentation string
  (merge-values-using-type): likewise
* src/mixins.lisp (type-based-merging-mixin): added documentation
  string
  (merge-values type-based-merging-mixin sequence): adapted to changed
  protocol
* src/conversion.lisp
  (merge-values-using-type type-based-merging-mixin sequence eql list):
  fixed
* src/schema.lisp (merge-values standard-schema-item sequence):
  removed; now handled by `type-based-merging-mixin'
* src/package.lisp (package options): added exported symbols
  merge-values, merge-values-using-type
* test/mixins.lisp (test suite options.type-based-merging-mixin): new
  test suite; for `type-based-merging-mixin' class
  (test options.type-based-merging-mixin::smoke): new test; for
  `merge-values' and `merge-values-using-type' functions
* test/schema.lisp: removed; contained tests have been split into
  multiple finer-grained tests
* test/package.lisp (package options.test): added imported from
  options symbol type-based-merging-mixin
* options.asd (system options-test): removed file test/schema.lisp
Improved value<->string conversion protocol

* src/conditions.lisp (option-syntax-error): added type slot; added
  report; added documentation string
* src/protocol.lisp (value->string): added documentation string
  (string->value): likewise
  (value->string-using-type): likewise
  (string->value-using-type): likewise
  (string->value :around t t): new method; translate errors into
  `option-syntax-error's
  (string->value-using-type :around t t t): likewise
* src/mixins.lisp (type-based-conversion-mixin): added documentation
  string
  (value->string type-based-conversion-mixin t): changed specializer
  string -> t
* src/conversion.lisp
  (string->value-using-type type-based-conversion-mixin string eql boolean):
  removed "0" and "1" literals; adjusted error report
  (string->value-using-type type-based-conversion-mixin type eql
  member): adjusted error report
  (value->string-using-type type-based-conversion-mixin pathname eql pathname):
  new method; convert pathname
  (string->value-using-type type-based-conversion-mixin string eql pathname):
  similar
  (value->string-using-type type-based-conversion-mixin list eql list):
  fixed handling of inherit indicator
  (string->value-using-type type-based-conversion-mixin string eql list):
  likewise
  (value->string-using-type type-based-conversion-mixin t eql or):
  new method; handle unparsing of composite type
  (string->value-using-type type-based-conversion-mixin string eql or):
  likewise
  (value->string-using-type type-based-conversion-mixin t eql and):
  likewise
  (string->value-using-type type-based-conversion-mixin string eql and):
  likewise
* src/package.lisp (package options): added used package iterate;
  added exported symbols option-syntax-error and
  option-syntax-error-type
* test/mixins.lisp (test suite options.type-based-conversion-mixin):
  new test suite; for `type-based-conversion-mixin' class
  (mock-type-based-conversion-schema-item): new class; mock class for
  tests of `type-based-conversion-mixin' class
  (test options.type-based-conversion-mixin::smoke): new test; smoke
  test for `type-based-conversion-mixin' class
* test/package.lisp (package options.test): added :import-from options
  symbol type-based-conversion-mixin
Value, default protocols in src/{protocol,configuration,schema}.lisp

* src/conditions.lisp (no-such-value-error): new condition; signaled
  when a value is missing
* src/protocol.lisp (option-has-default?): removed; subsumed by
  `option-default'
  (option-default): added if-does-not-exist keyword parameter; added
  documentation string
  (option-default :around t): new method; default behavior of
  `option-default' function
  (option-value): added if-does-not-exist keyword parameter; added
  documentation string
  (option-value :around t): new method; default behavior of
  `option-value function
* src/schema.lisp (standard-schema-item::default): added documentation
  string
  (shared-initialize :after standard-schema-item t): new method; set
  default value when supplied
  (print-items append standard-schema-item): new method; return type
  and default value
  (option-default standard-schema-item): new method; return default
  value, if there is one
  (setf option-%default :before t standard-schema-item): new method;
  validate new default value
  (option-has-default? standard-schema-item): removed; no longer
  needed
* src/configuration.lisp (option-cell::value): removed initarg;
  renamed accessor option-{value -> %value}
  (shared-initialize :after option-cell t): new method; set value when
  supplied
  (option-default option-cell): new method; delegate to schema item
  (option-value option-cell): new method; return value, if there is
  one
  (print-items append option-cell): adapted to changed `option-value'
  mechanism
  (option-default standard-option): new method; delegate to cell
  (option-value standard-option): likewise
  (print-items append standard-option): delegate to `print-items' for
  the option-cell
* test/protocol.lisp (header): added one-line summary
  (define-value-function-test option-default): new test; test
  `option-default' function
  (define-value-function-test option-value): new test; test
  `option-value function
* test/package.lisp (package options): added exported symbols
  no-such-value-error and no-such-value-error-which; removed exported
  symbol option-has-default?
* options.asd (system options): added file src/conditions.lisp
Added option-values function in src/{protocol,configuration}.lisp

* src/protocol.lisp (option-values): new generic function; return the
  values from which the effective option value has been computed
* src/configuration.lisp (option-cell::values): new slot; stores the
  values from which the effective option value has been computed
  (define-delegation option-values t): new delegation method; delegate
  to cell
* src/package.lisp (package options): added exported symbol
  option-values
* src/sources/syntax-ini.lisp
  (parser.ini:add-child ini-syntax list list): adapted keyword
  arguments to `notify' to changed protocol
Added event hooks in src/{mixins,configuration}.lisp

* src/protocol.lisp (event-hook): new generic function; returns the
  event hook object of a given object
* src/mixins.lisp (event-hook-mixin): new class; mixin class for event
  emitting or relaying classes
  (event-hook event-hook-mixin): new method; return event hook of an
  object
  (list-container-mixin): added superclass `event-hook-mixin'
  (setf find-option :after t t list-container-mixin): call `run-hook'
  after adding the option
* src/configuration.lisp (option-cell): added superclass
  `event-hook-mixin'
  (setf option-value :after t option-cell): new method; call
  `run-hook' after setting the option value
  (standard-option): added superclass `event-hook-mixin'
* src/package.lisp (package options): added exported symbol event-hook
* options.asd (system options): added system dependency on cl-hooks
Fixed option-documentation in src/{protocol,mixins,schema,configuration}.lisp

* src/protocol.lisp (option-documentation): renamed option-description
  -> option-documentation
* src/mixins.lisp (documentation-mixin): new class; manages option
  documentation
  (documentation documentation-mixin eql t): new method; integrate
  option documentation into the CL documentation protocol
* src/schema.lisp (standard-schema): added superclass
  `documentation-mixin'
  (standard-schema-item): likewise
  (standard-schema-item::description): removed; no longer used
* src/configuration.lisp
  (option-documentation standard-configuration): new method; return
  documentation of the associated schema
  (documentation standard-configuration eql t): new method; return
  documentation of the configuration
  (define-delegation option-documentation): renamed option-description
  -> option-documentation
  (define-delegation option-documentation): renamed option-description
  -> option-documentation
  (documentation standard-option eql t): new method; return
  documentation for the option
* src/package.lisp (package options): changed exported symbol
  option-description -> option-documentation
* test/configuration.lisp: new file; contains smoke tests for
  `standard-configuration' and `standard-option' classes
* options.asd (system options-test): added file
  test/configuration.lisp
Minor fixes and improvements in {src,test}/**/*.lisp

* src/conditions.lisp: fixed package qualification with "::" in ~/.../
  directives in condition reports
* src/protocol.lisp (find-option :around t t): use
  `error-behavior-restart-case'
  (option-configuration): fixed documentation string
  (option-schema-item): added documentation string
* src/name.lisp (print-object wildcard-name t): fixed package
  qualification with "::" in ~/.../ directives
* src/mixins.lisp (print-items append named-mixin): fixed package
  qualification with "::" in ~/.../ directives
* src/macros.lisp (header): added one-line summary
* src/sources/conditions.lisp: fixed package qualification with "::"
  in ~/.../ directives in condition reports
* src/sources/source-commandline.lisp (header): whitespace fix in
  one-line summary
* src/sources/source-file.lisp (file-source::pathname): renamed writer
  %source-pathname -> source-%pathname
  (shared-initialize :after file-source t): adapted to renamed writer
  (print-items append file-source): whitespace fix
* test/macros.lisp (header): added one-line summary
Improved stream, file sources in {src,test}/sources/source-{stream,file}.lisp

* src/sources/source-stream.lisp (stream-source): added default
  initarg stream; extended documentation string
  (stream-source::stream): new slot; stores the stream form which
  configuration information should be read
  (stream-source::syntax): new slot; stores the syntax object
  according to which read information should be interpreted
  (shared-initialize :after stream-source t): new method; lookup and
  create the syntax object
  (process stream-source stream): removed; obsolete
  (process stream-source string): likewise
  (process stream-source t): new method; call `process-content' with
  syntax and stream
* src/sources/source-file.lisp (file-source): added default initarg
  stream
  (file-source::element-type): new slot stores desired element-type of
  the stream created for the file
  (process file-source t): new method; create a stream and let
  `stream-source' do the rest
* src/sources/package.lisp (package options.sources): added exported
  symbol process-content
* test/sources/source-stream.lisp: new file; tests for `stream-source'
  class
* test/sources/source-file.lisp: similar for `file-source' class
* options.asd (system options-test): added files
  test/sources/source-stream.lisp and test/sources/source-file.lisp
Added cascade sources in src/sources/source-cascade.lisp

* src/sources/protocol.lisp (source-sources): new generic function;
  return inferior sources of a source
  (source-sources t): new method; default behavior
* src/sources/source-cascade.lisp: new file; contains "cascade" source
  classes `cascade-source', `config-file-cascade-source' and
  `common-cascade-source'
* src/sources/package.lisp (package options.sources): added exported
  symbol source-sources
* test/sources/source-cascade.lisp: new file; contains tests for
  classes `cascade-source', `config-file-cascade-source' and
  `common-cascade-source'
* test/sources/source-file.lisp (test file-source.smoke): adapted to
  `mock-syntax' change; added documentation string
* test/sources/source-stream.lisp (test stream-source.smoke): adapted
  to `mock-syntax' change; added documentation string
* test/sources/package.lisp (process-content mock-syntax stream t):
  generate :added event
  (expecting-sink-calls): fixed use of `is'
* options.asd (system options): added file
  src/sources/source-cascade.lisp
  (system options-test): added file test/sources/source-cascade.lisp