some words should be bold instead of code

mojolicious · Mar 14, 2014 · 4e09068 · 4e09068
1 parent 2868bb5
commit 4e09068
Show file tree

Hide file tree

Showing 5 changed files with 26 additions and 26 deletions.
diff --git a/lib/Mojolicious/Guides/Cookbook.pod b/lib/Mojolicious/Guides/Cookbook.pod
@@ -912,7 +912,7 @@ L<Mojo::UserAgent::Transactor/"tx">.
 
 When downloading large files with L<Mojo::UserAgent> you don't have to worry
 about memory usage at all, because it will automatically stream everything
-above C<250KB> into a temporary file, which can then be moved into a permanent
+above 250KB into a temporary file, which can then be moved into a permanent
 file with L<Mojo::Asset::File/"move_to">.
 
   use Mojo::UserAgent;
@@ -922,8 +922,8 @@ file with L<Mojo::Asset::File/"move_to">.
   my $tx = $ua->get('latest.mojolicio.us');
   $tx->res->content->asset->move_to('mojo.tar.gz');
 
-To protect you from excessively large files there is also a limit of C<10MB>
-by default, which you can tweak with the MOJO_MAX_MESSAGE_SIZE environment
+To protect you from excessively large files there is also a limit of 10MB by
+default, which you can tweak with the MOJO_MAX_MESSAGE_SIZE environment
 variable.
 
   # Increase limit to 1GB
@@ -1303,7 +1303,7 @@ CPAN module.
   $ make manifest
   $ make dist
 
-And if you have a C<PAUSE> account (which can be requested at
+And if you have a PAUSE account (which can be requested at
 L<http://pause.perl.org>) even upload it.
 
   $ mojo cpanify -u USER -p PASS MyApp-0.01.tar.gz

diff --git a/lib/Mojolicious/Guides/FAQ.pod b/lib/Mojolicious/Guides/FAQ.pod
@@ -16,7 +16,7 @@ L<Mojolicious>.
 
 The short answer is "it doesn't", because we interpret the words
 "web framework" much more literally than others. With the emergence of the
-C<real-time web> and new technologies such as C<WebSockets>, we are facing new
+B<real-time web> and new technologies such as B<WebSockets>, we are facing new
 challenges that go way beyond what commonly used modules like L<LWP> were
 designed for. Because of this, L<Mojolicious> contains a whole new HTTP
 client/server stack called L<Mojo>, which was heavily inspired by the original
@@ -71,13 +71,13 @@ optimize for it, this is currently 5.10.1.
 
 =head2 What is the difference between blocking and non-blocking operations?
 
-A C<blocking> operation is a subroutine that blocks the execution of the
+A B<blocking> operation is a subroutine that blocks the execution of the
 calling subroutine until the subroutine is finished.
 
   my $result = blocking_subroutine();
   ...
 
-A C<non-blocking> operation on the other hand lets the calling subroutine
+A B<non-blocking> operation on the other hand lets the calling subroutine
 continue execution even though the subroutine is not yet finished. Instead of
 waiting, the calling subroutine passes along a callback to be executed once
 the subroutine is finished, this is called continuation-passing style.
@@ -124,7 +124,7 @@ In L<Mojolicious> this event loop is L<Mojo::IOLoop>.
 To protect your applications from excessively large requests and responses,
 our HTTP parser has a cap after which it will automatically stop accepting new
 data, and in most cases force the connection to be closed. This limit is
-around C<10MB> by default, you can use the attribute
+around 10MB by default, you can use the attribute
 L<Mojo::Message/"max_message_size"> or MOJO_MAX_MESSAGE_SIZE environment
 variable to change this value.
 
@@ -133,8 +133,8 @@ variable to change this value.
 This is a very similar protection mechanism to the one described in the
 previous answer, but a little more specific. It limits the maximum length of
 any C<\x0d\x0a> terminated part of a HTTP message, such as request line,
-status line and headers. This limit is around C<10KB> by default, you can use
-the attributes L<Mojo::Message/"max_line_size"> and
+status line and headers. This limit is around 10KB by default, you can use the
+attributes L<Mojo::Message/"max_line_size"> and
 L<Mojo::Headers/"max_line_size"> or MOJO_MAX_LINE_SIZE environment variable to
 change this value.
 
@@ -143,7 +143,7 @@ change this value.
 This protection mechanism is very similar to those mentioned in the two
 previous answers. It limits how much content the HTTP parser is allowed to
 buffer when parsing chunked, compressed and multipart messages. This limit is
-around C<256KB> by default, you can use the attribute
+around 256KB by default, you can use the attribute
 L<Mojo::Content/"max_buffer_size"> or MOJO_MAX_BUFFER_SIZE environment
 variable to change this value.
 

diff --git a/lib/Mojolicious/Guides/Growing.pod b/lib/Mojolicious/Guides/Growing.pod
@@ -26,7 +26,7 @@ presentation and input.
            +------------+    +-------+    +------+
 
 A slightly modified version of the pattern moving some application logic into
-the C<controller> is the foundation of pretty much every web framework these
+the B<controller> is the foundation of pretty much every web framework these
 days, including L<Mojolicious>.
 
               +----------------+     +-------+
@@ -37,9 +37,9 @@ days, including L<Mojolicious>.
   Response <- |                | <-> | View  |
               +----------------+     +-------+
 
-The C<controller> receives a request from a user, passes incoming data to the
-C<model> and retrieves data from it, which then gets turned into an actual
-response by the C<view>. But note that this pattern is just a guideline that
+The B<controller> receives a request from a user, passes incoming data to the
+B<model> and retrieves data from it, which then gets turned into an actual
+response by the B<view>. But note that this pattern is just a guideline that
 most of the time results in cleaner more maintainable code, not a rule that
 should be followed at all costs.
 
@@ -48,9 +48,9 @@ should be followed at all costs.
 REST is a software architectural style for distributed hypermedia systems such
 as the web. While it can be applied to many protocols it is most commonly used
 with HTTP these days. In REST terms, when you are opening a URL like
-C<http://mojolicio.us/foo> with your browser, you are basically asking the web
-server for the HTML C<representation> of the C<http://mojolicio.us/foo>
-C<resource>.
+B<http://mojolicio.us/foo> with your browser, you are basically asking the web
+server for the HTML B<representation> of the B<http://mojolicio.us/foo>
+B<resource>.
 
   +--------+                                +--------+
   |        | -> http://mojolicio.us/foo  -> |        |
@@ -80,7 +80,7 @@ all session state is kept client-side.
   +---------+                        +------------+
 
 While HTTP methods such as PUT, GET and DELETE are not directly part of REST
-they go very well with it and are commonly used to manipulate C<resources>.
+they go very well with it and are commonly used to manipulate B<resources>.
 
 =head2 Sessions
 
@@ -237,8 +237,8 @@ logic related to matching usernames and passwords.
   1;
 
 A simple helper can be registered with the function
-L<Mojolicious::Lite/"helper"> to make our C<model> available to all actions
-and templates.
+L<Mojolicious::Lite/"helper"> to make our model available to all actions and
+templates.
 
   #!/usr/bin/env perl
   use Mojolicious::Lite;

diff --git a/lib/Mojolicious/Guides/Rendering.pod b/lib/Mojolicious/Guides/Rendering.pod
@@ -316,7 +316,7 @@ Since everything is just Perl normal control structures just work.
 =head2 Content negotiation
 
 For resources with different representations and that require truly
-C<RESTful> content negotiation you can also use
+RESTful content negotiation you can also use
 L<Mojolicious::Controller/"respond_to"> instead of
 L<Mojolicious::Controller/"render">.
 

diff --git a/lib/Mojolicious/Lite.pm b/lib/Mojolicious/Lite.pm
@@ -669,7 +669,7 @@ Or you can just disable format detection.
 
 =head2 Content negotiation
 
-For resources with different representations and that require truly C<RESTful>
+For resources with different representations and that require truly RESTful
 content negotiation you can also use L<Mojolicious::Controller/"respond_to">.
 
   use Mojolicious::Lite;
@@ -795,7 +795,7 @@ cookies really secure.
 
 All files uploaded via C<multipart/form-data> request are automatically
 available as L<Mojo::Upload> objects. And you don't have to worry about memory
-usage, because all files above C<250KB> will be automatically streamed into a
+usage, because all files above 250KB will be automatically streamed into a
 temporary file.
 
   use Mojolicious::Lite;
@@ -834,8 +834,8 @@ temporary file.
     </body>
   </html>
 
-To protect you from excessively large files there is also a limit of C<10MB>
-by default, which you can tweak with the MOJO_MAX_MESSAGE_SIZE environment
+To protect you from excessively large files there is also a limit of 10MB by
+default, which you can tweak with the MOJO_MAX_MESSAGE_SIZE environment
 variable.
 
   # Increase limit to 1GB