i18n-inflector 2.2.0 → 2.3.0

data/docs/USAGE

@@ -0,0 +1,939 @@
+= Usage of the I18n Inflector
+
+The {I18n::Inflector I18n Inflector} contains inflection classes
+and modules for enabling the inflection support in I18n translations.
+It is also used by the module called {I18n::Backend::Inflector}
+that overwrites the translate method from the Simple backend
+so it will interpolate additional inflection data present
+in translations. That data may appear in *patterns*
+enclosed within <tt>@{</tt> and <tt>}</tt> symbols. Each pattern
+consist of *tokens* and respective *values*. One of the value will
+be used depending on additional data passed to the translate method.
+That additional data is called <b>inflection options</b>.
+
+== Usage
+  require 'i18-inflector'
+  
+  i18n.translate('welcome', :gender => :f)
+  # => Dear Madam
+  
+  i18n.inflector.kinds
+  # => [:gender]
+
+  i18n.inflector.true_tokens.keys
+  # => [:f, :m, :n]
+
+See the {file:EXAMPLES} for more information about real-life
+usage of Inflector.
+
+== Inflection pattern
+An example inflection pattern stored under a translation key looks like:
+  welcome: "Dear @{f:Madam|m:Sir|n:You|All}"
+
+The +f+, +m+ and +n+ are inflection *tokens* and +Madam+, +Sir+, +You+ and
++All+ are *values*. Only one value is going to replace the whole
+pattern. To select which one an additional option is used. That option
+must be passed to the translate method.
+
+There are also so called <b>named patterns</b> that will be explained
+later.
+
+== Configuration
+To recognize tokens present in patterns keys grouped
+in the scope called +inflections+ for the given locale are used.
+For instance (YAML format):
+  en:
+    i18n:
+      inflections:
+        gender:
+          f:      "female"
+          m:      "male"
+          n:      "neuter"
+          man:    @m
+          woman:  @f
+          default: n
+
+Elements in the example above are:
+* +en+: language
+* +i18n+: configuration scope
+* +inflections+: inflections configuration scope
+* +gender+: kind scope
+* +f+, +m+, +n+: inflection tokens
+* <tt>"male"</tt>, <tt>"female"</tt>, <tt>"neuter"</tt>: tokens' descriptions
+* +woman+, +man+: inflection aliases
+* <tt>@f</tt>, <tt>@m</tt>: pointers to real tokens 
+* +default+: default token for a kind +gender+
+
+=== Kind
+Note the fourth scope selector in the example above (+gender+). It's called
+the *kind* and contains *tokens*. We have the kind
++gender+ to which the inflection tokens +f+, +m+ and +n+ are
+assigned.
+
+You cannot assign the same token to more than one kind.
+Trying to do that will raise {I18n::DuplicatedInflectionToken} exception.
+This is required in order to keep patterns simple and tokens interpolation
+fast.
+
+Kind is also used to instruct {I18n::Backend::Inflector#translate} method which
+token it should pick. This is done through options and
+will be explained later.
+
+There is also a class of kind called <b>strict kind</b> used by
+named patterns; that will be explained later.
+
+=== Tokens
+The token is an element of a pattern. Any pattern may have many tokens
+of the same kind separated by vertical bars. Optionally tokens might
+be groupped using commas (these are token groups; that will be explained
+later). Each token name (or a group of tokens) used in a pattern should
+end with colon sign. After this colon a value should appear (or an empty
+string).
+
+Tokens also appear in a configuration data. They are assigned to kinds.
+Token names must be unique across all kinds, since it would be impossible
+for interpolation routine to guess a kind of a token present in a pattern.
+There is however a class of kinds called strict kinds, for which tokens
+must be unique only within a kind. The named patterns that are using
+strict kinds will be explained later.
+
+=== Aliases
+Aliases are special tokens that point to other tokens. By default they
+cannot appear in inflection patterns but they are fully recognized
+in options that are be passed to the translation method.
+
+Aliases might be helpful in multilingual applications that are using
+a fixed set of values passed through options to describe some properties
+of messages, e.g. +masculine+ and +feminine+ for a grammatical gender.
+Translators will then use their own tokens (like +f+ and +m+ for English)
+to produce pretty and intuitive patterns.
+
+For example: if some application uses database with gender assigned
+to a user which may be +male+, +female+ or +none+, then a translator
+may find it useful to map impersonal token (<tt>none</tt>)
+to the +neuter+ token, since in translations for his language the
+neuter gender is in use.
+
+Here is the example of such situation:
+
+  en:
+    i18n:
+      inflections:
+        gender:
+          male:     "male"
+          female:   "female"
+          none:     "impersonal form"
+          default:  none 
+  
+  pl:
+    i18n:
+      inflections:
+        gender:
+          k:        "female"
+          m:        "male"
+          n:        "neuter"
+          male:     @k
+          female:   @m
+          none:     @n
+          default:  none
+
+In the case above Polish translator decided to use neuter
+instead of impersonal form when +none+ token will be passed
+through the option +:gender+ to the translate method. He
+also decided that he will use +k+, +m+ or +n+ in patterns,
+because the names are short and correspond to gender names in
+Polish language: +k+ for 'kobieta' (woman), +m+ for 'mężczyzna' (man),
++n+ for 'nijaki' (neuter).
+
+Aliases may point to other aliases. While loading inflections they
+will be internally shortened and they will always point to real tokens,
+not other aliases.
+
+=== Default token
+There is a special token called the +default+, which points
+to a token that should be used if the interpolation routine cannot deduce
+which one it should use because a proper option was not given.
+
+Default tokens may point to aliases and may use aliases' syntax, e.g.:
+  default: @man
+
+=== Descriptions
+The values of keys in the example (+female+, +male+ and +neuter+)
+are *descriptions* which usually are not used by the interpolation routine
+but might be helpful (e.g. in UI). For obvious reasons you cannot
+describe aliases.
+
+== Interpolation
+The value of each token present in a pattern is to be picked by the interpolation
+routine and will replace the whole pattern, when a token name from that
+pattern matches the given value of an option passed to the {I18n.translate} method.
+
+=== Inflection option
+The mentioned option is called the <b>inflection option</b>. Its name should be
+the same as a *kind* of tokens used within a pattern. The first token in a pattern
+determines the kind of all tokens used in that pattern. You can pass
+many inflection options, each one designated for transporting a token of a
+different kind.
+
+==== Examples
+
+*YAML:*
+
+Let's assume that the translation data in YAML format listed
+below is used in any later example, unless other inflections
+are given.
+  en:
+    i18n:
+      inflections:
+        gender:
+          m:       "male"
+          f:       "female"
+          n:       "neuter"
+          default: n
+  
+    welcome:  "Dear @{f:Madam|m:Sir|n:You|All}"
+
+*Code:*
+
+  I18n.translate('welcome', :gender => :m)
+  # => "Dear Sir"
+  
+  I18n.translate('welcome', :gender => :unknown)
+  # => "Dear All"
+  
+  I18n.translate('welcome')
+  # => "Dear You"
+
+In the second example the <b>fallback value</b> +All+ was interpolated
+because the routine had been unable to find the token called +:unknown+.
+That differs from the latest example, in which there was no option given,
+so the default token for a kind had been applied (in this case +n+).
+
+==== Inflection options as Methods or Procs
+The inflection option may contain an object that is a kind of Method or
+a Proc. The token will be obtained by calling the given method or a block when
+interpolation routine will need it.
+
+The passed method or a block should return an object that is a kind of
+Symbol. It will be used as an inflection token.
+
+Optionally the inflection method may make use of a block that is passed
+to it. Currently two parameters can be obtained using the keyword +yield+.
+Fist is the currenty parsed kind (including +@+ character in case of
+a strict kind) and second is the locale; both are the kind of Symbol. Example:
+
+  def get_gender
+    kind, locale = yield  # optional
+    :n                    # return token n
+  end
+  
+  translate('welcome', :gender => method(:get_gender))
+  
+In case of Proc, the arguments are passed in a more comprehensive way,
+as parameters passed to a block. Such a block must handle exactly
+two arguments:
+
+  p = lambda{ |kind, locale| :m }
+  translate('welcome', :gender => p)
+
+Note that if there will be any error that causes exception to be
+raised by such a method or a block then it will be raised regardless
+of +:inflector_raises+ option.
+
+=== Local fallbacks (free text)
+The fallback value will be used when none of the tokens contained
+within a pattern can be interpolated.
+
+Be aware that enabling extended error reporting makes it unable
+to use fallback values in most cases. Local fallbacks will then be
+applied only when the given option contains a proper value for some
+kind but it's just not present in a pattern, for example:
+
+*YAML:*
+
+  en:
+    i18n:
+      inflections:
+        gender:
+          n:    'neuter'
+          o:    'other'
+      
+    welcome:    "Dear @{n:You|All}"
+
+*Code:*
+
+  I18n.translate('welcome', :gender => :o, :inflector_raises => true)
+  # => "Dear All"
+  # since the token :o was configured but not used in the pattern
+
+=== Bad and empty tokens in options
+If an option containing token is not present at all then the interpolation
+routine will try the default token for a processed kind, if the default
+token is present in a pattern. The same thing will happend if the option
+is present but its value is malformed, unknown, empty or +nil+.
+If the default token is not present in a pattern or is not defined in
+a configuration data then the processing of a pattern will result
+in an empty string or in a local fallback value if there is
+a free text placed in a pattern.
+
+You can change this default behavior and force inflector
+not to use a default token when a value of an option for
+a kind is malformed, unknown, empty or +nil+ but only when
+it's not present. To do that you should set option +:inflector_unknown_defaults+
+to +false+ and pass it to the translate method. Other way is to set this
+switch globally using the {I18n::Inflector::InflectionOptions#unknown_defaults}.
+
+=== Unmatched tokens in options
+It might happend that there will be a default token present in a pattern
+but the given inflection option will cause some other token to be picked up,
+which however won't be present in this pattern (although it will be
+correct and assigned to the currently processed kind). In such
+case the given free text or an empty string will be generated.
+You may change that behavior by passing +:inflector_excluded_defaults+
+option set to +true+ or by setting the global option called
+{I18n::Inflector::InflectionOptions#excluded_defaults}. If this
+option is set then any unmatched (excluded but correct) token
+given in an inflection option will cause the default token's value
+to be picked up (of course if a default token will be present
+in a pattern).
+
+=== Mixing inflection and standard interpolation patterns
+The Inflector allows you to include standard <tt>%{}</tt>
+patterns inside of inflection patterns. The value of a standard
+interpolation variable will be evaluated and interpolated *before*
+processing an inflection pattern. For example:
+
+*YAML:*
+
+Note: <em>Uses inflection configuration given in the first example.</em> 
+  en:
+    hi:   "Dear @{f:Lady|m:%{test}}!"
+
+*Code:*
+  I18n.t('hi', :gender => :m, :locale => :xx, :test => "Dude")
+  # => Dear Dude!
+
+=== Token groups
+It is possible to assign some value to more than one token in a patterns.
+You can create group of tokens by separating them using commas.
+The comma has the meaning of logical OR.
+
+*YAML:*
+
+Note: <em>Uses inflection configuration given in the first example.</em> 
+  en:
+    welcome:  "Hello @{m,f:Ladies and Gentlemen|n:You}!"
+
+*Code:*
+  I18n.t('welcome', :gender => :f)
+  # => Hello Ladies and Gentlemen!
+
+=== Inversed matching of tokens
+You can place exclamation mark before a token that should be
+matched negatively. Its value will be used for a pattern
+<b>if the given inflection option contains other token</b>.
+You can use inversed matching of tokens in token groups but
+note that putting more than one inversed token to a group
+will cause the expression to mach every time.
+
+*YAML:*
+
+Note: <em>Uses inflection configuration given in the first example.</em> 
+  en:
+    welcome:  "Hello @{!m:Ladies|n:You}!"
+
+*Code:*
+
+  I18n.t('welcome', :gender => :n)
+  # => Hello Ladies!
+  
+  I18n.t('welcome', :gender => :f)
+  # => Hello Ladies!
+  
+  I18n.t('welcome', :gender => :m)
+  # => Hello !
+  
+=== Wildcard tokens
+You may use the wildcard character, a star (+*+), in place of token
+group to create a virtual token that matches any token of a parsed kind.
+For example:
+
+*YAML:*
+
+Note: <em>Uses inflection configuration given in the first example.</em> 
+
+  en:
+    welcome:  "Hello @{n:you|*:ladies and gentlemen}!"
+
+*Code:*
+
+  I18n.t('welcome', :gender => :n)
+  # => Hello you!
+  
+  I18n.t('welcome', :gender => :f)
+  # => Hello ladies and gentlemen!
+
+Note that for simple patterns you can use free text instead, which works
+almost the same way with one significant difference: free text will be
+evaluated as the last expression, regardless of its placement.
+On the contrary a wildcard token will be evaluated as any other
+token group and may not be used if any previously tested token
+will match (like +n+ in the example above).
+
+While a wildcard token is processed then the interpolation routine
+will validate if the required inflection option exists and if it contains
+a proper token. Using wildcard token is like using a token group
+for any other token group containing all possible true tokens in it.
+
+In case of regular patterns containing just a wildcard token alone
+there is no way to easily decide which kind the expression
+refers to. To deduce it the first valid inflection option will
+be used. In order to work it must contain some valid token
+identifier. If the token identifier is invalid and there are more
+inflection options then they are tried.
+
+Wildcard tokens are useful in so called complex patterns which
+will be explained later.
+
+=== Loud tokens
+Sometimes there might be a need to use descriptions of
+matching tokens instead of some given values. Use <b>loud tokens</b>
+to achieve that. Any matching token in a pattern that has tilde symbol (+~+)
+set as its value will be replaced by its description. In case of
+undescribed aliases, the description from a target token will be used.
+
+*YAML:*
+
+Note: <em>Uses inflection configuration given in the first example.</em> 
+  en:
+    welcome:  "Hello @{m:~|n:~}!"
+
+*Code:*
+
+  I18n.t('welcome', :gender => :n)
+  # => Hello neuter!
+  
+  I18n.t('welcome', :gender => :f)
+  # => Hello female!
+
+To use tilde symbol as the only value of a token you may esape it
+by putting a backslash in front of the symbol.
+
+Using loud token with wildcard token will result in a description
+of first matching token.
+
+=== Aliases in a pattern
+Normally it is possible to use in  patterns only true tokens, not aliases.
+However, if you feel lucky and you're not affraid of messy patterns
+you can use the switch {I18n::Inflector::InflectionOptions#aliased_patterns}
+or pass corresponding +:inflector_aliased_patterns+ option to the translate
+method.
+
+=== Escaping a pattern
+If there is a need to translate something that accidentally matches
+an inflection pattern then the escape symbols can be used to
+disable the interpolation. These symbols are <tt>\\</tt> and +@+
+and they should be placed just before a pattern that should
+be left untouched. For instance:
+
+*YAML:*
+
+Note: <em>Uses inflection configuration given in the first example.</em> 
+  en:
+    welcome:  "This is the @@{pattern}!"
+
+*Code:*
+
+  I18n.t('welcome', :gender => :m, :locale => :xx)
+  # => This is the @{pattern}!
+
+=== More about applying aliases
+It may seem very easy and attractive to use aliases
+in environments where inflection option's value comes from a user.
+In such cases aliases may be used as database that translates common
+words to inflection tokens that have meanings. For example a user may
+enter a gender in some text field and it will be used as value of inflection
+option. To map different names (e.g. male, boy, sir, female, girl, lady)
+to exact inflection tokens the aliases would be used.
+
+Note hovewer, that you can make use of <tt>I18n.inflector.true_token</tt>
+method (see {I18n::Inflector::API#true_token}) that will resolve any alias,
+and then use that data to feed an inflection option (e.g. +:gender+).
+In such scenario you don't have to rely on resolving aliases
+any time translation is performed and you will gain some speed.
+
+== Named patterns
+
+A named pattern is a pattern that contains name of a kind
+that tokens from a pattern are assigned to. It looks like:
+
+  welcome: "Dear @gender{f:Madam|m:Sir|n:You|All}"
+
+=== Configuring named patterns
+To recognize tokens present in named patterns,
+inflector uses keys grouped in the scope called +inflections+
+for the given locale. For instance (YAML format):
+  en:
+    i18n:
+      inflections:
+        @gender:
+          f:      "female"
+          woman:  @f
+          default: f
+
+Elements in the example above are:
+* +en+: language
+* +i18n+: configuration scope
+* +inflections+: inflections configuration scope
+* +gender+: <bb>strict kind</bb> scope
+* +f+: inflection token
+* <tt>"female"</tt>: token's description
+* +woman+: inflection alias
+* <tt>@f</tt>: pointer to real token
+* +default+: default token for a strict kind +gender+
+
+=== Strict kinds
+
+In order to handle named patterns properly a new data structure
+is used. It is called the <b>strict kind</b>. Strict kinds are defined
+in a configuration in a similar way the regular kinds are but
+tokens assigned to them may have the same names across a whole
+configuration. (Note that tokens of the same strict kind should still
+be unique.) That implies a requirement of passing the
+identifier of a kind in patterns when referring to such tokens.
+
+Here is the example configuration using strict kinds:
+
+  en:
+    i18n:
+      inflections:
+        @gender:
+          f:      "female"
+          m:      "male"
+          n:      "neuter"
+          man:    @m
+          woman:  @f
+          default: n
+        @title:
+          s:      "sir"
+          l:      "lady"
+          u:      "you"
+          m:      @s
+          f:      @l
+          default: u
+
+The only thing that syntactically distinguishes strict kinds
+from regular kinds is a presence of the +@+ symbol.
+
+You can mix regular and strict kinds having the same names in
+one translation entry, but not in one inflection pattern.
+The proper class of kind will be picked up by interpolation
+method easily, since the first mentioned class uses
+patterns that are not named, and the second uses named patterns.
+
+==== Strict kinds in inflection options
+The interpolation routine recognizes strict kinds passed as names of
+inflection options in almost the same way that it does for regular
+kinds. The only difference is that you can override usage
+of a regular kind inflection option (if there is any) by
+putting a strict kind option with the same name but prefixed by +@+ symbol.
+The inflection options starting with this symbol have
+precedence over inflection options without it;
+that is of course only true for strict kinds and has any effect
+only when both options describing kinds of the same name are present.
+
+In other words: interpolation routine is looking for
+strict kinds in inflection options using their names
+with +@+ in front. When that fails it falls back to
+an option named like the strict kind but without
+the +@+ symbol. Examples:
+
+ I18n.translate(welcome, :gender => :m, :@gender => :f)
+ # the :f will be picked for the strict kind gender
+ 
+ I18n.translate(welcome, :@gender => :f)
+ # the :f will be picked for the strict kind gender
+ 
+ I18n.translate(welcome, :gender => :f)
+ # the :f will be picked for the strict kind gender
+
+In the example above we assume that +welcome+ is defined
+like that:
+
+  welcome: "Dear @gender{f:Madam|m:Sir|n:You|All}"
+
+Note that for regular kinds the option named +:@gender+
+will have no meaning.
+
+==== Note for developers
+
+Strict kinds that are used to handle named patterns
+are internally stored in a different database and handled by
+similar but different API methods than regular kinds. However
+most of the {I18n::Inflector::API} methods are also aware of strict kinds
+and will call proper methods oprating on strict inflections
+data when the +@+ symbol is detected at the beginning of
+the identifier of a kind passed as an argument. For example:
+
+  I18n.inflector.has_token?(:m, :@gender)
+
+will effectively call:
+
+ I18n.inflector.strict.has_token?(:m, :gender)
+
+As you can see above, to access {API_Strict} methods for strict kinds
+(and strict kinds data) only, associated with default I18n backend,
+use:
+
+  I18n.inflector.strict
+
+== Multiple patterns
+You can make use of some syntactic sugar when having more than
+one pattern (regular or named) in your string. To not repeat
+a kind identifier(s) you may join pattern contents as in the
+following example:
+
+  welcome: "You are @gender{f:pretty|m,n:handsome}{ }{f:lady|m:sir|n:human}"
+
+As you can see there should be no spaces or any other characters
+between successive patterns. That's why in this example an
+empty pattern content is used. This is in fact a pattern
+containing no tokens but just a free text consisting
+of single space character.
+
+== Complex patterns
+A <bb>complex pattern</bb> is a named pattern that uses more than
+one inflection kind and sets of a respective tokens. The given identifiers
+of kinds should be separated by the plus sign and instead of single
+tokens there should be token sets (a tokens separated by the plus
+sign too).
+
+Example:
+
+  welcome:  "Dear @gender+number{f+s:Lady|f+p:Ladies|m+s:Sir|m+p:Gentlemen|All}"
+
+In the example above the complex pattern uses +gender+ and +number+
+inflection kinds and a token set (e.g. <tt>f+s</tt>) matches when
+both tokens match interpolation options (e.g. <tt>:gender => :f</tt>,
+<tt>:number => :s</tt>). The order of tokens in sets has meaning
+and should reflect the order of declared kinds.
+
+Note, that the count of tokens in each set should reflect the count
+of kinds that are used. Otherwise the interpolation routine will
+interpolate a free text (if given) or an empty string. If the switch
+{InflectionOptions#raises} is on then the {I18n::ComplexPatternMalformed}
+exception will be raised.
+
+The inflection tokens used in sets may make use of any features mentioned
+before (defaults, excluded defaults, negative matching, token groups,
+aliases, aliased patterns, loud tokens, wildcards).
+
+=== Loud tokens in complex patterns
+In case of loud tokens (having values taken from their
+descriptions), the complex pattern will be replaced by
+the descriptions of matching tokens joined with a single space
+character. So, for instance, when the translation data looks like:
+
+  i18n:
+    inflections:
+      @person:
+        i: 'I'
+        u: 'You'
+      @tense:
+        now:  'am'
+        past: 'were'
+  welcome: "@person+tense{i+now:~|u+past:~}"
+
+the translate method will give the following results:
+
+  I18n.translate('welcome', :person => :i, :tense => :now)
+  # => "I am"
+
+  I18n.translate('welcome', :person => :you, :tense => :past)
+  # => "You were"
+
+This example is abstract, since the combination of +:i+
+and +:past+ will result in <tt>i were</tt> string, which is
+probably something unexpected. To achieve that kind of logic
+simply use combined patterns with the given values instead
+of loud tokens.
+
+=== Wildcard tokens in complex patterns
+The wildcard tokens might be extremely helpful in complex
+patterns since there is one shared free text for a whole pattern
+yet there might be a need to match any token for some subkind.
+For example:
+
+  welcome: @person+tense{i+present:am|u+present:are|*+present:is}
+
+Note that in the example above +*+ matches 'i', 'you', 'he', 'she' and 'it'
+but 'i' and 'u' are effectively matched before. The equivalent pattern without
+a wildcard token would look like:
+
+  welcome: @person+tense{i+present:am|u+present:are|i,u,he,she,it+present:is}
+
+== Inflection keys
+There is a way of storing inflected strings in keys instead
+of patterns. To use it you should simply assign subkeys to
+some translation key instead of string containing a pattern.
+The key-based inflection group is contained within a key
+which name begins with the +@+ symbol.
+
+The translation key containing a pattern:
+
+  welcome:  "Dear @{f:Lady|m:Sir|n:You|All}!"
+
+Can be easily written as:
+
+  @welcome:
+    f:        "Lady"
+    m:        "Sir"
+    n:        "You"
+    @free:    "All"
+    @prefix:  "Dear "
+    @suffix:  "!"
+ 
+You can also use strict kind or even the inflection sets, token
+groups, etc.:
+
+  welcome:  "@gender+tense{f+past:She was|m+present:He is|n+future:You will be}"
+
+Can be written as:
+
+  @welcome:
+    f+past:     "She was"
+    m+present:  "He is"
+    n+future:   "You will be"
+    @kind:      "gender+tense"
+
+There are special, optional subkeys that may give you
+more control over inflection process. These are:
+
+* +@kind+: a kind or kinds in case of strict kinds
+* +@prefix+: a prefix to be put before the interpolated data
+* +@suffix+: a suffix to be put after the interpolated data
+* +@free+: a free text that is to be used when no token will match
+
+=== Limitations
+
+Inflection keys look compact and clean but obviously
+you cannot use the key-based inflection to simply replace
+a string containing more than one inflection pattern.
+
+Also, <b>you have to be very careful when using this method
+with Ruby 1.8</b> because the order of processed token sets
+may change. That may break the logic in case of inflection
+sets where order has meaning (e.g. tokens with inverted
+matching).
+
+== Errors
+By default the module will silently ignore non-critical interpolation
+errors. You can turn off this default behavior by passing +:inflector_raises+
+option set to +true+. Note that most errors is reported because of
+wrong data in patterns or in configuration. In case of inflection
+options only malformed, empty or +nil+ values are reported
+when the mentioned switch is turned on. For inflection options
+containing unknown tokens no errors are generated.
+
+=== Usage of +:inflector_raises+ option
+
+*YAML:*
+
+Note: <em>Uses inflection configuration given in the first example.</em> 
+  en:
+    welcome:  "Dear @{m:Sir|f:Madam|Fallback}"
+
+*Code:*
+
+  I18n.t('welcome', :inflector_raises => true)
+  # => I18n::InflectionOptionNotFound: en.welcome:
+  #      @{m:Sir|f:Madam|Fallback}" - required option :gender was not found
+
+=== Exception meanings
+Here are the exceptions that may be raised when the option +:inflector_raises+
+is set to +true+:
+
+* {I18n::InvalidInflectionToken I18n::InvalidInflectionToken}
+* {I18n::InvalidInflectionKind I18n::InvalidInflectionKind}
+* {I18n::InvalidInflectionOption I18n::InvalidInflectionOption}
+* {I18n::MisplacedInflectionToken I18n::MisplacedInflectionToken}
+* {I18n::InflectionOptionNotFound I18n::InflectionOptionNotFound}
+* {I18n::InflectionOptionIncorrect I18n::InflectionOptionIncorrect}
+* {I18n::ComplexPatternMalformed I18n::ComplexPatternMalformed}
+
+There are also exceptions that are raised regardless of :+inflector_raises+
+presence or value.
+These are usually caused by critical errors encountered during processing
+inflection data or exceptions raised by I18n. Note that the pure I18n's
+exceptions are not described here.
+
+* {I18n::ArgumentError I18n::ArgumentError}
+* {I18n::InvalidLocale I18n::InvalidLocale}
+* {I18n::DuplicatedInflectionToken I18n::DuplicatedInflectionToken}
+* {I18n::BadInflectionKind I18n::BadInflectionKind}
+* {I18n::BadInflectionToken I18n::BadInflectionToken}
+* {I18n::BadInflectionAlias I18n::BadInflectionAlias}
+
+=== Exception hierarchy
+  I18n::ArgumentError
+  |
+  `-- I18n::InvalidLocale
+  |
+  `-- I18n::InflectionException
+      |
+      `-- I18n::InflectionPatternException
+      |   |
+      |   |-- I18n::InvalidInflectionToken
+      |   |-- I18n::InvalidInflectionKind
+      |   |-- I18n::MisplacedInflectionToken
+      |   |-- I18n::ComplexPatternMalformed
+      |   `-- I18n::InvalidOptionForKind
+      |       |-- I18n::InflectionOptionNotFound
+      |       `-- I18n::InflectionOptionIncorrect
+      |
+      `-- I18n::InflectionConfigurationException
+          |
+          |-- I18n::DuplicatedInflectionToken
+          |-- I18n::BadInflectionAlias
+          |-- I18n::BadInflectionToken
+          `-- I18n::BadInflectionKind
+
+== Reserved names and characters
+Some strings cannot be used as names and/or identifiers of
+kinds and tokens. There are also some reserved characters
+that cannot be used within them.
+
+=== Reserved keys
+Reserved keys, that cannot be used as names of inflection
+options and as names of kinds in the configuration
+are available after issuing:
+
+  I18n::Inflector::Config::Reserved::KEYS.to_a
+
+Here is the current list: <tt>:scope, :default, :separator,
+:resolve, :object, :fallback, :format, :cascade,
+:raise, :rescue_format, :inflector_cache_aware,
+:inflector_raises, :inflector_aliased_patterns,
+:inflector_unknown_defaults, :inflector_excluded_defaults</tt>.
+
+Additionally all Symbols or Strings beginning with
++inflector_+ are prohibited, since they are reserved as
+controlling options.
+
+=== Reserved characters
+All characters that have special meaning (operators and
+markers) are not allowed in patterns, in configuration
+and in options.
+
+==== Reserved characters in kinds
+===== Passed as inflection options
+
+* *Constant:* {I18n::Inflector::Config::Reserved::Kinds::OPTION}
+
+* *List:* <tt>+ | : ! { }</tt> and <tt>,</tt> (comma).
+
+===== Given in a configuration
+
+* *Constant:* {I18n::Inflector::Config::Reserved::Kinds::DB}
+
+* *List:* <tt>+ | : ! { }</tt> and <tt>,</tt> (comma).
+
+===== Placed in patterns
+
+* *Constant:* {I18n::Inflector::Config::Reserved::Kinds::PATTERN}
+
+* *List:* <tt>+ | : , ! @ { }</tt> and <tt>,</tt> (comma).
+
+==== Reserved characters in tokens
+===== Passed as values of inflection options
+
+* *Constant:* {I18n::Inflector::Config::Reserved::Tokens::OPTION}
+
+* *List:* <tt>* + | : ! @ { }</tt> and <tt>,</tt> (comma).
+
+===== Given in a configuration
+
+* *Constant:* {I18n::Inflector::Config::Reserved::Tokens::DB}
+
+* *List:* <tt>* + | : ! @ { }</tt> and <tt>,</tt> (comma).
+
+===== Placed in patterns
+
+* *Constant:* {I18n::Inflector::Config::Reserved::Tokens::PATTERN}
+
+* *List:* <tt>+ | : ! @ { }</tt> and <tt>,</tt> (comma).
+
+== Operators and markers
+Here is more formal definition of operators and markers used in patterns.
+
+=== Pattern
+  @[kind][+kind ...]{token_set[|token_set ...][|free_text]}
+
+* +@+ is the pattern marker
+* +{+ and +}+ are pattern delimiters
+* +free_text+ is an optional free text value
+* +kind+ is a kind identifier
+* <tt>+</tt> is the +AND+ operator that joins kinds (produces complex kinds)
+
+==== +token_set+
+  *|token_group[+token_group ...]:value
+
+* +:+ is the +ASSIGNMENT+ operator
+* +value+ is a value to be picked up then a token set matches; value may also
+  be the loud marker (+~+)
+* <tt>+</tt> is the +AND+ operator that joins many token groups into a set
+* +*+ is the +WILDCARD+ operator
+
+===== +token_group+
+  [!]token[,[!]token ...]
+
+* +token+ is a token identifier
+* +!+ is the +NOT+ operator
+* +,+ is the +OR+ operator
+
+=== Operator precedence
+
+* Single token level
+  * +NOT+ operators for inversed matching of tokens (<tt>!</tt>)
+  * +OR+ operators for joining tokens into token groups (<tt>,</tt>)
+* Token group level
+  * +WILDCARD+ operators for matching any token (<tt>*</tt>)
+  * +AND+ operators for joining token groups into sets (<tt>+</tt>)
+* Token set level
+  * +ASSIGNMENT+ operators for assigning values to token sets (<tt>:</tt>)
+  * +OR+ operators for separating token sets and/or free texts (<tt>|</tt>)
+* Pattern name level
+  * +AND+ operators for kind identifiers (<tt>+</tt>)
+* Pattern level
+  * Pattern marker and pattern delimiters
+
+== Classes and relations
+
+=== Library contents
+
+* Module {I18n::Inflector} containing everything
+* Class {I18n::Inflector::API} used to create inflector object attached to I18n backend (handles regular and strict kinds)
+* Class {I18n::Inflector::API_Strict} which instance is attached to {I18n::Inflector::API} and handles strict kinds
+* Class {I18n::Inflector::InflectionData} used to store inflection data for regular kinds and tokens
+* Class {I18n::Inflector::InflectionData_Strict} used to store inflection data for strict kinds and tokens
+* Class {I18n::Inflector::InflectionOptions} used for keeping switches and options
+* Class {I18n::Inflector::LazyHashEnumerator} used to manage lazy evaluation of internal data
+* Module {I18n::Backend::Inflector} used to alter methods of {I18n::Backend::Simple}
+* Several classes for error reporting
+
+=== Relations
+
+* {I18n.backend} is the currently used backend and the instance of {I18n::Backend::Simple}
+* {I18n.backend.inflector} is the instance of {I18n::Inflector::API} attached to backend
+* {I18n.inflector} is the proxy module method that calls inflector for currently used backend {I18n.backend.inflector}
+* {I18n.backend.inflector.options} is the instance of {I18n::Inflector::InflectionOptions} and
+  mainly it controls a behavior of interpolation method
+* {I18n.backend.inflector.strict} is the instance of {I18n::Inflector::API_Strict} and handles strict kinds
+* {I18n.backend.inflector} uses {I18n.backend.inflector.strict} to access strict kinds when it's needed
+* {I18n::Inflector::API} has an instance variable @idb that contains database of inflections indexed by locale
+* {I18n::Inflector::API_Strict} has an instance variable @idb that contains database of inflections indexed by locale
+* Translation databases are kind of {I18n::Inflector::InflectionData} and {I18n::Inflector::InflectionData_Strict}
+* When initializing translations a method from {I18n::Backend::Simple} (altered by {I18n::Backend::Inflector})
+  takes the loaded data, processes their <tt>i18n.inflections</tt> scope for each locale and creates database
+  objects which are kind of {I18n::Inflector::InflectionData} and {I18n::Inflector::InflectionData_Strict}. That
+  objects are then attached to instances of {I18n::Inflector::API} and {I18n::Inflector::API_Strict}.