fix: typos

Author: mitsuhiko

minijinja/src/environment.rs

@@ -46,9 +46,9 @@ fn default_formatter() -> Arc<FormatterFunc> {
 }
 
 /// The maximum recursion in the VM.  Normally each stack frame
-/// adds one to this counter (eg: every time a frame is added).
+/// adds one to this counter (e.g., every time a frame is added).
 /// However in some situations more depth is pushed if the cost
-/// of the stack frame is higher.  Raising this above this limit
+/// of the stack frame is higher.  Raising this limit
 /// requires enabling the `stacker` feature.
 const MAX_RECURSION: usize = 500;
 
@@ -192,8 +192,9 @@ impl<'source> Environment<'source> {
     /// env.add_template_owned("index.html".to_string(), "Hello {{ name }}!".to_string()).unwrap();
     /// ```
     ///
-    /// **Note**: the name is a bit of a misnomer as this API also allows to borrow too as
-    /// the parameters are actually [`Cow`].  This method fails if the template has a syntax error.
+    /// **Note**: the name is a bit of a misnomer as this API also allows borrowing,
+    /// as the parameters are actually [`Cow`].  This method fails if the template
+    /// has a syntax error.
     pub fn add_template_owned<N, S>(&mut self, name: N, source: S) -> Result<(), Error>
     where
         N: Into<Cow<'source, str>>,
@@ -407,8 +408,7 @@ impl<'source> Environment<'source> {
 
     /// Loads a template from a string.
     ///
-    /// In some cases you really only need to work with (eg: render) a template to be
-    /// rendered once only.
+    /// In some cases you only need to work with (e.g., render) a template once.
     ///
     /// ```
     /// # use minijinja::{Environment, context};
@@ -492,7 +492,7 @@ impl<'source> Environment<'source> {
     /// invoked with the name of the template and can make an initial auto
     /// escaping decision based on that.  The default implementation
     /// ([`default_auto_escape_callback`](defaults::default_auto_escape_callback))
-    /// turn on escaping depending on the file extension.
+    /// turns on escaping depending on the file extension.
     ///
     /// ```
     /// # use minijinja::{Environment, AutoEscape};
@@ -675,9 +675,9 @@ impl<'source> Environment<'source> {
 
     /// Compiles an expression.
     ///
-    /// This lets one compile an expression in the template language and
-    /// receive the output.  This lets one use the expressions of the language
-    /// be used as a minimal scripting language.  For more information and an
+    /// This lets you compile an expression in the template language and evaluate it.
+    /// This makes it possible to use the language's expressions as a minimal
+    /// scripting language.  For more information and an
     /// example see [`Expression`].
     pub fn compile_expression(&self, expr: &'source str) -> Result<Expression<'_, 'source>, Error> {
         self._compile_expression(expr)

minijinja/src/filters.rs

@@ -1002,7 +1002,7 @@ mod builtins {
     /// This filter is only available if the `json` feature is enabled.  The resulting
     /// value is safe to use in HTML as well as it will not contain any special HTML
     /// characters.  The optional parameter to the filter can be set to `true` to enable
-    /// pretty printing.  Not that the `"` character is left unchanged as it's the
+    /// pretty printing.  Note that the `"` character is left unchanged as it's the
     /// JSON string delimiter.  If you want to pass JSON serialized this way into an
     /// HTTP attribute use single quoted HTML attributes:
     ///
@@ -1068,13 +1068,13 @@ mod builtins {
         })
     }
 
-    /// Indents Value with spaces
+    /// Indents a value with spaces.
     ///
     /// The first optional parameter to the filter can be set to `true` to
     /// indent the first line. The parameter defaults to false.
-    /// the second optional parameter to the filter can be set to `true`
+    /// The second optional parameter to the filter can be set to `true`
     /// to indent blank lines. The parameter defaults to false.
-    /// This filter is useful, if you want to template yaml-files
+    /// This filter is useful if you want to template YAML files.
     ///
     /// ```jinja
     /// example:

minijinja/src/template.rs

@@ -321,8 +321,8 @@ impl<'env, 'source> Template<'env, 'source> {
 
     /// Renders the template into an [`io::Write`].
     ///
-    /// This works exactly like [`render`](Self::render) but instead writes the template
-    /// as it's evaluating into an [`io::Write`].
+    /// This works exactly like [`render`](Self::render), but writes the template
+    /// into an [`io::Write`] as it is evaluated.
     ///
     /// ```
     /// # use minijinja::{Environment, context};
@@ -402,7 +402,7 @@ impl<'env, 'source> Template<'env, 'source> {
     /// Returns a set of all undeclared variables in the template.
     ///
     /// This returns a set of all variables that might be looked up
-    /// at runtime by the template.  Since this is runs a static
+    /// at runtime by the template.  Since this runs a static
     /// analysis, the actual control flow is not considered.  This
     /// also cannot take into account what happens due to includes,
     /// imports or extending.  If `nested` is set to `true`, then also

minijinja/src/vm/state.rs

@@ -332,7 +332,7 @@ impl<'template, 'env> State<'template, 'env> {
     /// Temps are similar to context values but the engine never looks them up
     /// on their own and they are not scoped.  The lifetime of temps is limited
     /// to the rendering process of a template.  Temps are useful so that
-    /// filters and other things can temporary stash away state without having
+    /// filters and other things can temporarily stash away state without having
     /// to resort to thread locals which are hard to manage.  Unlike context
     /// variables, temps can also be modified during evaluation by filters and
     /// functions.
@@ -370,7 +370,7 @@ impl<'template, 'env> State<'template, 'env> {
 
     /// Shortcut for registering an object as a temp.
     ///
-    /// If the value is already there, it's returned as object, if it's
+    /// If the value is already there, it's returned as an object. If it's
     /// not there yet, the function is invoked to create it.
     ///
     /// # Example
@@ -394,7 +394,7 @@ impl<'template, 'env> State<'template, 'env> {
     ///
     /// # Panics
     ///
-    /// This will panick if the value registered under that name is not
+    /// This will panic if the value registered under that name is not
     /// the object expected.
     pub fn get_or_set_temp_object<O, F>(&self, name: &str, f: F) -> Arc<O>
     where
@@ -449,7 +449,7 @@ impl<'a> ArgType<'a> for &State<'_, '_> {
     }
 }
 
-/// Tracks a block and it's parents for super.
+/// Tracks a block and its parents for super.
 #[derive(Default)]
 pub(crate) struct BlockStack<'template, 'env> {
     instructions: Vec<&'template Instructions<'env>>,