Once again, fixing the code blocks in the readme file

Author: tjackiw

Diff for: README.md

@@ -6,21 +6,21 @@ Obscenity is a profanity filter gem for Ruby, Rails (through ActiveModel), and R
 
 Add this line to your application's Gemfile:
 
-    ```ruby
-    gem 'obscenity'
-    ```
+```ruby
+gem 'obscenity'
+```
 
 And then execute:
 
-    ```ruby
-    bundle install
-    ```
+```ruby
+bundle install
+```
 
 Or install it yourself as:
 
-    ```ruby
-    gem install obscenity
-    ```
+```ruby
+gem install obscenity
+```
 
 ## Compatibility
 
@@ -56,107 +56,107 @@ The following methods are available to use with Obscenity:
 
 Example:
 
-    ```ruby
-    Obscenity.configure do |config|
-      config.blacklist   = "path/to/blacklist/file.yml"
-      config.whitelist   = ["safe", "word"]
-      config.replacement = :stars
-    end
-    ```
+```ruby
+Obscenity.configure do |config|
+  config.blacklist   = "path/to/blacklist/file.yml"
+  config.whitelist   = ["safe", "word"]
+  config.replacement = :stars
+end
+```
 
 ### Basic Usage
 
 `Obscenity.profane?(text)` analyses the content and returns `true` or `false` based on its profanity:
 
-    ```ruby
-    Obscenity.profane?("simple text")
-    => false
-    
-    Obscenity.profane?("text with shit")
-    => true
-    ```
+```ruby
+Obscenity.profane?("simple text")
+=> false
+
+Obscenity.profane?("text with shit")
+=> true
+```
 
 `Obscenity.sanitize(text)` sanities the content and returns a new sanitized content (if profane) or the original content (if not profane):
 
-    ```ruby
-    Obscenity.sanitize("simple text")
-    => "simple text"
-    
-    Obscenity.sanitize("text with shit")
-    => "text with $@!#%"
-    ```
+```ruby
+Obscenity.sanitize("simple text")
+=> "simple text"
+
+Obscenity.sanitize("text with shit")
+=> "text with $@!#%"
+```
 
 `Obscenity.replacement(style).sanitize(text)` allows you to pass the replacement method to be used when sanitizing the given content. Available replacement values are `:default`, `:garbled`, `:stars`, `:vowels`, and a custom string.
 
-    ```ruby
-    Obscenity.replacement(:default).sanitize("text with shit")
-    => "text with $@!#%"
+```ruby
+Obscenity.replacement(:default).sanitize("text with shit")
+=> "text with $@!#%"
 
-    Obscenity.replacement(:garbled).sanitize("text with shit")
-    => "text with $@!#%"
-    
-    Obscenity.replacement(:stars).sanitize("text with shit")
-    => "text with ****"
+Obscenity.replacement(:garbled).sanitize("text with shit")
+=> "text with $@!#%"
+
+Obscenity.replacement(:stars).sanitize("text with shit")
+=> "text with ****"
 
-    Obscenity.replacement(:vowels).sanitize("text with shit")
-    => "text with sh*t"
+Obscenity.replacement(:vowels).sanitize("text with shit")
+=> "text with sh*t"
 
-    Obscenity.replacement("[censored]").sanitize("text with shit")
-    => "text with [censored]"
-    ```
+Obscenity.replacement("[censored]").sanitize("text with shit")
+=> "text with [censored]"
+```
 
 `Obscenity.offensive(text)` returns an array of profane words in the given content:
 
-    ```ruby
-    Obscenity.offensive("simple text")
-    => []
-    
-    Obscenity.offensive("text with shit and another biatch")
-    => ["shit", "biatch"]
-    ```
+```ruby
+Obscenity.offensive("simple text")
+=> []
+
+Obscenity.offensive("text with shit and another biatch")
+=> ["shit", "biatch"]
+```
 
 ### ActiveModel
 
 The ActiveModel component provides easy profanity validation for your models.
 
 First, you need to explicitly require the ActiveModel component: 
 
-    ```ruby
-    require 'obscenity/active_model'
-    ```
+```ruby
+require 'obscenity/active_model'
+```
 
 Then you can use it in your models as such:
 
-    ```ruby
-    # ActiveRecord example
-    class Post < ActiveRecord::Base
-      
-      validates :title, obscenity: true
-      validates :body,  obscenity: { sanitize: true, replacement: "[censored]" }
-    end
+```ruby
+# ActiveRecord example
+class Post < ActiveRecord::Base
+  
+  validates :title, obscenity: true
+  validates :body,  obscenity: { sanitize: true, replacement: "[censored]" }
+end
 
-    # MongoMapper example
-    class Book
-      include MongoMapper::Document
+# MongoMapper example
+class Book
+  include MongoMapper::Document
 
-      key :title, String
-      key :body,  String
+  key :title, String
+  key :body,  String
 
-      validates :title, obscenity: true
-      validates :body,  obscenity: { sanitize: true, replacement: :vowels }
-    end
-    
-    # Mongoid example
-    class Page
-      include Mongoid::Document
+  validates :title, obscenity: true
+  validates :body,  obscenity: { sanitize: true, replacement: :vowels }
+end
+
+# Mongoid example
+class Page
+  include Mongoid::Document
 
-      field :title, type: String
-      field :body,  type: String
+  field :title, type: String
+  field :body,  type: String
 
-      validates :title, obscenity: true
-      validates :body,  obscenity: { sanitize: true, replacement: :garbled }
-    end
-    ```
+  validates :title, obscenity: true
+  validates :body,  obscenity: { sanitize: true, replacement: :garbled }
+end
+```
 
 The following usage is available:
 
@@ -172,14 +172,15 @@ You can use Obscenity as a Rack middleware to automatically reject requests that
 
 First you need to explicitly require the Rack middleware:
 
-    ```ruby
-    require 'obscenity/rack'
-    ```
+```ruby
+require 'obscenity/rack'
+```
+
 And to use the middleware, the basic syntax is:
 
-    ```ruby
-    use Rack::Obscenity, {} # options Hash
-    ```
+```ruby
+use Rack::Obscenity, {} # options Hash
+```
 
 You need to use the options below inside the options Hash (above)
 
@@ -189,73 +190,75 @@ Any of the following options can be used to reject a request.
 
 `reject: true` : will reject a request if any parameter value contains profanity.
 
-    ```ruby
-    use Rack::Obscenity, reject: true
-    ```
+```ruby
+use Rack::Obscenity, reject: true
+```
+
 `reject: { params: [] }` : will analyze the selected parameters and reject the request if their values contain profanity.
 
-    ```ruby
-    use Rack::Obscenity, reject: { params: [:foo, :bar] }
-    ```
+```ruby
+use Rack::Obscenity, reject: { params: [:foo, :bar] }
+```
 
 `reject: { message: 'Custom message' }` : will reject a request and display the custom message if any parameter value contains profanity
 
-    ```ruby
-    use Rack::Obscenity, reject: { message: "We don't allow profanity!" }
-    ```
+```ruby
+use Rack::Obscenity, reject: { message: "We don't allow profanity!" }
+```
 
 `reject: { path: 'path/to/file' }` :  will reject a request and render the custom file if any parameter value contains profanity
 
-    ```ruby
-    use Rack::Obscenity, reject: { path: 'public/no_profanity.html' }
-    ```
+```ruby
+use Rack::Obscenity, reject: { path: 'public/no_profanity.html' }
+```
 
 More usage example:
 
-    ```ruby
-    # Rejects the request for all params and renders a file
-    use Rack::Obscenity, reject: { params: :all, path: 'public/no_profanity.html' }
+```ruby
+# Rejects the request for all params and renders a file
+use Rack::Obscenity, reject: { params: :all, path: 'public/no_profanity.html' }
 
-    # Rejects the request based on the selected params and renders a file
-    use Rack::Obscenity, reject: { params: [:foo, :bar], path: 'public/no_profanity.html' }
+# Rejects the request based on the selected params and renders a file
+use Rack::Obscenity, reject: { params: [:foo, :bar], path: 'public/no_profanity.html' }
 
-    # Rejects the request based on the selected params and displays a message
-    use Rack::Obscenity, reject: { params: [:foo, :bar], message: "Profanity is not allowed!" }
-    ```
+# Rejects the request based on the selected params and displays a message
+use Rack::Obscenity, reject: { params: [:foo, :bar], message: "Profanity is not allowed!" }
+```
 
 #### Sanitizing Requests:
 
 Any of the following options can be used to sanitize a request.
 
 `sanitize: true` : will sanitize all parameter values if they contain profanity.
 
-    ```ruby
-    use Rack::Obscenity, sanitize: true
-    ```
+```ruby
+use Rack::Obscenity, sanitize: true
+```
+
 `sanitize: { params: [] }` : will analyze the selected parameters and sanitize them if their values contain profanity.
 
-    ```ruby
-    use Rack::Obscenity, sanitize: { params: [:foo, :bar] }
-    ```
+```ruby
+use Rack::Obscenity, sanitize: { params: [:foo, :bar] }
+```
 
 `sanitize: { replacement: (:default | :garbled | :stars | :vowels | 'custom') }` : will use this replacement method when sanitizing parameter values
 
-    ```ruby
-    use Rack::Obscenity, sanitize: { replacement: :vowels }
-    ```
+```ruby
+use Rack::Obscenity, sanitize: { replacement: :vowels }
+```
 
 More usage example:
 
-    ```ruby
-    # Sanitizes all params and replaces their values using :stars
-    use Rack::Obscenity, sanitize: { params: :all, replacement: :stars }
+```ruby
+# Sanitizes all params and replaces their values using :stars
+use Rack::Obscenity, sanitize: { params: :all, replacement: :stars }
 
-    # Sanitizes the given params and replaces their values using a custom word
-    use Rack::Obscenity, sanitize: { params: [:foo, :bar], replacement: "[censored]" }
+# Sanitizes the given params and replaces their values using a custom word
+use Rack::Obscenity, sanitize: { params: [:foo, :bar], replacement: "[censored]" }
 
-    # Sanitizes all params and replaces their values using :garbled
-    use Rack::Obscenity, sanitize: { replacement: :garbled }
-    ```
+# Sanitizes all params and replaces their values using :garbled
+use Rack::Obscenity, sanitize: { replacement: :garbled }
+```
 
 ## Contributing to obscenity