friendly_id 5.0.0.alpha.1 → 5.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 44f9c1a8ef2afb5bda90485d0df78b67da83e73d
-  data.tar.gz: 722909dc863dd55275aa403ee4321c99af1ea118
+  metadata.gz: 3a7d80631aa03de549650e0cc84c04108204af5c
+  data.tar.gz: c868670182414c4846e8c4a94aa34d680f78c1a7
 SHA512:
-  metadata.gz: d0949ad9c3d10238bbc4f6f350bd4d8b7101485679f3d55ef78c902b1a0f280d738b89f5753bd467d593ab8ec91ca7bc412323083114140f1fea5a061c27755f
-  data.tar.gz: d561df0002650904d1b087185f9d5a94ad6e191ab88925fe9e0974894affaafa55e92db2774cc3fe364ead7fef85dd6cade495f7f47feeeda54efe5b04b2681e
+  metadata.gz: 203a56c05ef6d18ab3ba8b9de406749a55689d25fb3776b744986c753bcd0a174ffe8f364521f5cca9255b7f196feea76f5fd94bde48c63d8bc4fb2e9a3f8ce9
+  data.tar.gz: 195f31cb8264650bb0b9922dc436575fa3ba33c4c0ecb8f4f2efb2c62033131f11e93d9ba9fff3c710b67bcd0dd96c5601e06a6b5cb9678e72b8abab6b985d2a

data/.yardopts

@@ -1,4 +1,5 @@
---files=WhatsNew.md,Changelog.md,Guide.rdoc
+--files=Changelog.md,Guide.md
 --private
 --protected
 --exclude lib/friendly_id/migration
+--markup=markdown

data/CONTRIBUTING.md

@@ -0,0 +1,36 @@
+# FriendlyId
+
+## Getting Help
+
+Before opening a new issue, please search the existing issues to see if your
+question has been answered before.
+
+Please also take a look at the extensive documentation, especially the Guide.
+
+## FAQ
+
+Here are the answers to some common questions.
+
+### I'm using Rails 4...
+
+Then you **must** use FriendlyId 5, which is currently available in the master
+branch of the repository, and will be released to Rubygems soon.
+
+### How do I set up my routes for FriendlyId?
+
+Exactly like in any other Rails app. FriendlyId doesn't change any routing
+functionality, it only changes the ids that are shown in your routes.
+
+TIP: Make your app work the way you want to with numeric id's. Then add
+FriendlyId later.
+
+### I'm seeing `undefined method `friendly_id'`
+
+You probably just added the friendly_id gem. Run `bundle` and restart your
+Rails app.
+
+### I'm seeing `uninitialized constant FriendlyId`
+
+You probably just added the friendly_id gem. Run `bundle` and restart your
+Rails app.
+

data/Changelog.md

@@ -3,16 +3,23 @@
 We would like to think our many {file:Contributors contributors} for
 suggestions, ideas and improvements to FriendlyId.
 
-* Table of Contents
-{:toc}
+## 5.0.0.beta1 (2013-08-10)
 
-## 4.1.0.beta.1 (2013-01-09)
+* Support for Rails 4.
+* Made the :scoped and :history modules compatible with each other (Andre Duffeck).
+* Removed class-level finders in favor of `friendly` scope (Norman Clarke).
+* Implemented "candidates" support (Norman Clarke).
+* Slug "sequences" are now GUIDs rather than numbers (Norman Clarke).
+* `find` no longer falls back to super unless id is fully numeric string (Norman Clarke).
+* Default sequence separator is now '-' rather than '--'.
+* Support for Globalize has been removed until Globalize supports Rails 4.
+* Removed upport for Ruby < 1.9.3 and Rails < 4.0.
 
-Made the :scoped and :history modules compatible with each other (Andre Duffeck)
 
-## 4.0.10 (NOT RELEASED YET)
+## 4.0.10 (2013-08-10)
 
-* Fixed table prefixes/suffixes being ignored (Jesse Farless)
+* Fixed table prefixes/suffixes being ignored (Jesse Farless).
+* Fixed sequence generation for slugs containing numbers (Adam Carroll).
 
 ## 4.0.9 (2012-10-31)
 
@@ -38,7 +45,7 @@ Made the :scoped and :history modules compatible with each other (Andre Duffeck)
 
 ## 4.0.7 (2012-06-06)
 
-* to_param just calls super when no friendly_id is present, to keep the model's
+* to_param just calls super when no friendly id is present, to keep the model's
   default behavior. (Andrew White)
 
 * FriendlyId can now properly sequence slugs that end in numbers even when a

data/{Guide.rdoc → Guide.md}

@@ -1,7 +1,6 @@
-#encoding: utf-8
 
 
-== About FriendlyId
+## About FriendlyId
 
 FriendlyId is an add-on to Ruby's Active Record that allows you to replace ids
 in your URLs with strings:
@@ -15,28 +14,27 @@ in your URLs with strings:
 It requires few changes to your application code and offers flexibility,
 performance and a well-documented codebase.
 
-=== Core Concepts
+### Core Concepts
 
-==== Slugs
+#### Slugs
 
-The concept of "slugs[http://en.wikipedia.org/wiki/Slug_(web_publishing)]" is at
-the heart of FriendlyId.
+The concept of *slugs* is at the heart of FriendlyId.
 
 A slug is the part of a URL which identifies a page using human-readable
 keywords, rather than an opaque identifier such as a numeric id. This can make
 your application more friendly both for users and search engine.
 
-==== Finders: Slugs Act Like Numeric IDs
+#### Finders: Slugs Act Like Numeric IDs
 
 To the extent possible, FriendlyId lets you treat text-based identifiers like
 normal IDs. This means that you can perform finds with slugs just like you do
 with numeric ids:
 
     Person.find(82542335)
-    Person.find("joe")
+    Person.friendly.find("joe")
 
 
-== Setting Up FriendlyId in Your Model
+## Setting Up FriendlyId in Your Model
 
 To use FriendlyId in your ActiveRecord models, you must first either extend or
 include the FriendlyId module (it makes no difference), then invoke the
@@ -53,7 +51,7 @@ addons it should use. See the documentation for this method for a list of all
 available addons, or skim through the rest of the docs to get a high-level
 overview.
 
-=== The Default Setup: Simple Models
+### The Default Setup: Simple Models
 
 The simplest way to use FriendlyId is with a model that has a uniquely indexed
 column with no spaces or special characters, and that is seldom or never
@@ -65,9 +63,9 @@ updated. The most common example of this is a user name:
       validates_format_of :login, :with => /\A[a-z0-9]+\z/i
     end
 
-    @user = User.find "joe"   # the old User.find(1) still works, too
-    @user.to_param            # returns "joe"
-    redirect_to @user         # the URL will be /users/joe
+    @user = User.friendly.find "joe"   # the old User.find(1) still works, too
+    @user.to_param                     # returns "joe"
+    redirect_to @user                  # the URL will be /users/joe
 
 In this case, FriendlyId assumes you want to use the column as-is; it will never
 modify the value of the column, and your application should ensure that the
@@ -78,7 +76,7 @@ value is unique and admissible in a URL:
       friendly_id :name
     end
 
-    @city.find "Viña del Mar"
+    @city.friendly.find "Viña del Mar"
     redirect_to @city # the URL will be /cities/Viña%20del%20Mar
 
 Writing the code to process an arbitrary string into a good identifier for use
@@ -86,7 +84,7 @@ in a URL can be repetitive and surprisingly tricky, so for this reason it's
 often better and easier to use {FriendlyId::Slugged slugs}.
 
 
-== Slugged Models
+## Slugged Models
 
 FriendlyId can use a separate column to store slugs for models which require
 some text processing.
@@ -111,13 +109,13 @@ To activate the slugging functionality, use the {FriendlyId::Slugged} module.
 
 FriendlyId will generate slugs from a method or column that you specify, and
 store them in a field in your model. By default, this field must be named
-+:slug+, though you may change this using the
+`:slug`, though you may change this using the
 {FriendlyId::Slugged::Configuration#slug_column slug_column} configuration
 option. You should add an index to this column, and in most cases, make it
 unique. You may also wish to constrain it to NOT NULL, but this depends on your
 app's behavior and requirements.
 
-=== Example Setup
+### Example Setup
 
     # your model
     class Post < ActiveRecord::Base
@@ -143,119 +141,144 @@ app's behavior and requirements.
       end
     end
 
-=== Working With Slugs
+### Working With Slugs
 
-==== Formatting
+#### Formatting
 
 By default, FriendlyId uses Active Support's
-paramaterize[http://api.rubyonrails.org/classes/ActiveSupport/Inflector.html#method-i-parameterize]
+[paramaterize](http://api.rubyonrails.org/classes/ActiveSupport/Inflector.html#method-i-parameterize)
 method to create slugs. This method will intelligently replace spaces with
 dashes, and Unicode Latin characters with ASCII approximations:
 
-  movie = Movie.create! :title => "Der Preis fürs Überleben"
-  movie.slug #=> "der-preis-furs-uberleben"
+    movie = Movie.create! :title => "Der Preis fürs Überleben"
+    movie.slug #=> "der-preis-furs-uberleben"
 
-==== Uniqueness
+#### Column or Method?
 
-When you try to insert a record that would generate a duplicate friendly id,
-FriendlyId will append a sequence to the generated slug to ensure uniqueness:
+FriendlyId always uses a method as the basis of the slug text - not a column. It
+first glance, this may sound confusing, but remember that Active Record provides
+methods for each column in a model's associated table, and that's what
+FriendlyId uses.
 
-  car = Car.create :title => "Peugot 206"
-  car2 = Car.create :title => "Peugot 206"
+Here's an example of a class that uses a custom method to generate the slug:
 
-  car.friendly_id #=> "peugot-206"
-  car2.friendly_id #=> "peugot-206-f9f3789a-daec-4156-af1d-fab81aa16ee5"
+    class Person < ActiveRecord::Base
+      friendly_id :name_and_location
+      def name_and_location
+        "#{name} from #{location}"
+      end
+    end
 
-==== Sequence Separator - The Two Dashes
+    bob = Person.create! :name => "Bob Smith", :location => "New York City"
+    bob.friendly_id #=> "bob-smith-from-new-york-city"
 
-By default, FriendlyId uses a dash to separate the slug from a sequence.
+FriendlyId refers to this internally as the "base" method.
 
-You can change this with the {FriendlyId::Slugged::Configuration#sequence_separator
-sequence_separator} configuration option.
+#### Uniqueness
 
-==== Column or Method?
+When you try to insert a record that would generate a duplicate friendly id,
+FriendlyId will append a UUID to the generated slug to ensure uniqueness:
 
-FriendlyId always uses a method as the basis of the slug text - not a column. It
-first glance, this may sound confusing, but remember that Active Record provides
-methods for each column in a model's associated table, and that's what
-FriendlyId uses.
+    car = Car.create :title => "Peugot 206"
+    car2 = Car.create :title => "Peugot 206"
 
-Here's an example of a class that uses a custom method to generate the slug:
+    car.friendly_id #=> "peugot-206"
+    car2.friendly_id #=> "peugot-206-f9f3789a-daec-4156-af1d-fab81aa16ee5"
 
-  class Person < ActiveRecord::Base
-    friendly_id :name_and_location
-    def name_and_location
-      "#{name} from #{location}"
+Previous versions of FriendlyId appended a numeric sequence a to make slugs
+unique, but this was removed to simplify using FriendlyId in concurrent code.
+
+#### Candidates
+
+Since UUIDs are ugly, FriendlyId provides a "slug candidates" functionality to
+let you specify alternate slugs to use in the event the one you want to use is
+already taken. For example:
+
+    class Restaurant < ActiveRecord::Base
+      extend FriendlyId
+      friendly_id :slug_candidates, use: :slugged
+
+      # Try building a slug based on the following fields in
+      # increasing order of specificity.
+      def slug_candidates
+        [
+          :name,
+          [:name, :city],
+          [:name, :street, :city],
+          [:name, :street_number, :street, :city]
+        ]
+      end
     end
-  end
 
-  bob = Person.create! :name => "Bob Smith", :location => "New York City"
-  bob.friendly_id #=> "bob-smith-from-new-york-city"
+    r1 = Restaurant.create! name: 'Plaza Diner', city: 'New Paltz'
+    r2 = Restaurant.create! name: 'Plaza Diner', city: 'Kingston'
 
-==== Providing Your Own Slug Processing Method
+    r1.friendly_id  #=> 'plaza-diner'
+    r2.friendly_id  #=> 'plaza-diner-kingston'
 
-You can override {FriendlyId::Slugged#normalize_friendly_id} in your model for
-total control over the slug format.
+To use candidates, make your FriendlyId base method return an array. The
+method need not be named `slug_candidates`; it can be anything you want. The
+array may contain any combination of symbols, strings, procs or lambdas and
+will be evaluated lazily and in order. If you include symbols, FriendlyId will
+invoke a method on your model class with the same name. Strings will be
+interpreted literally. Procs and lambdas will be called and their return values
+used as the basis of the friendly id. If none of the candidates can generate a
+unique slug, then FriendlyId will append a UUID to the first candidate as a
+last resort.
 
-==== Deciding When to Generate New Slugs
+#### Sequence Separator
 
-Overriding {FriendlyId::Slugged#should_generate_new_friendly_id?} lets you
-control whether new friendly ids are created when a model is updated. For
-example, if you only want to generate slugs once and then treat them as
-read-only:
+By default, FriendlyId uses a dash to separate the slug from a sequence.
 
-  class Post < ActiveRecord::Base
-    extend FriendlyId
-    friendly_id :title, :use => :slugged
+You can change this with the {FriendlyId::Slugged::Configuration#sequence_separator
+sequence_separator} configuration option.
 
-    def should_generate_new_friendly_id?
-      new_record?
-    end
-  end
+#### Providing Your Own Slug Processing Method
 
-  post = Post.create!(:title => "Hello world!")
-  post.slug #=> "hello-world"
-  post.title = "Hello there, world!"
-  post.save!
-  post.slug #=> "hello-world"
+You can override {FriendlyId::Slugged#normalize_friendly_id} in your model for
+total control over the slug format. It will be invoked for any generated slug,
+whether for a single slug or for slug candidates.
 
-==== Locale-specific Transliterations
+#### Deciding When to Generate New Slugs
 
-Active Support's +parameterize+ uses
-transliterate[http://api.rubyonrails.org/classes/ActiveSupport/Inflector.html#method-i-transliterate],
-which in turn can use I18n's transliteration rules to consider the current
-locale when replacing Latin characters:
+Previous versions of FriendlyId provided a method named
+`should_generate_new_friendly_id?` which you could override to control when new
+slugs were generated.
 
-  # config/locales/de.yml
-  de:
-    i18n:
-      transliterate:
-        rule:
-          ü: "ue"
-          ö: "oe"
-          etc...
+As of FriendlyId 5.0, slugs are only generated when the `slug` field is nil. If
+you want a slug to be regenerated, you must explicity set the field to nil:
 
-  movie = Movie.create! :title => "Der Preis fürs Überleben"
-  movie.slug #=> "der-preis-fuers-ueberleben"
+    restaurant.friendly_id # joes-diner
+    restaurant.name = "The Plaza Diner"
+    restaurant.save!
+    restaurant.friendly_id # joes-diner
+    restaurant.slug = nil
+    restaurant.save!
+    restaurant.friendly_id # the-plaza-diner
 
-This functionality was in fact taken from earlier versions of FriendlyId.
 
-==== Gotchas: Common Problems
+#### Locale-specific Transliterations
 
-===== Slugs That Begin With Numbers
+Active Support's `parameterize` uses
+[transliterate](http://api.rubyonrails.org/classes/ActiveSupport/Inflector.html#method-i-transliterate),
+which in turn can use I18n's transliteration rules to consider the current
+locale when replacing Latin characters:
 
-Ruby's `to_i` function casts strings to integers in such a way that +23abc.to_i+
-returns 23. Because FriendlyId falls back to finding by numeric id, this means
-that if you attempt to find a record with a non-existant slug, and that slug
-begins with a number, your find will probably return the wrong record.
+    # config/locales/de.yml
+    de:
+      i18n:
+        transliterate:
+          rule:
+            ü: "ue"
+            ö: "oe"
+            etc...
 
-There are two fairly simple ways to avoid this:
+    movie = Movie.create! :title => "Der Preis fürs Überleben"
+    movie.slug #=> "der-preis-fuers-ueberleben"
 
-* Use validations to ensure that slugs don't begin with numbers.
-* Use explicit finders like +find_by_id+ to always find by the numeric id, or
-  +find_by_slug+ to always find using the friendly id.
+This functionality was in fact taken from earlier versions of FriendlyId.
 
-===== Concurrency Issues
+#### Gotchas: Common Problems
 
 FriendlyId uses a before_validation callback to generate and set the slug. This
 means that if you create two model instances before saving them, it's possible
@@ -266,15 +289,11 @@ attributes creates more than one record for a model that uses friendly_id. The
 second, in concurrent code, either in threads or multiple processes.
 
 To solve the nested attributes issue, I recommend simply avoiding them when
-creating more than one nested record for a model that uses FriendlyId. See {this
-Github issue}[https://github.com/FriendlyId/friendly_id/issues/185] for discussion.
-
-To solve the concurrency issue, I recommend locking the model's table against
-inserts while when saving the record. See {this Github
-issue}[https://github.com/FriendlyId/friendly_id/issues/180] for discussion.
+creating more than one nested record for a model that uses FriendlyId. See [this
+Github issue](https://github.com/norman/friendly_id/issues/185) for discussion.
 
 
-== History: Avoiding 404's When Slugs Change
+## History: Avoiding 404's When Slugs Change
 
 FriendlyId's {FriendlyId::History History} module adds the ability to store a
 log of a model's slugs, so that when its friendly id changes, it's still
@@ -282,26 +301,24 @@ possible to perform finds by the old id.
 
 The primary use case for this is avoiding broken URLs.
 
-=== Setup
+### Setup
 
 In order to use this module, you must add a table to your database schema to
 store the slug records. FriendlyId provides a generator for this purpose:
 
-  rails generate friendly_id
-  rake db:migrate
+    rails generate friendly_id
+    rake db:migrate
 
-This will add a table named +friendly_id_slugs+, used by the {FriendlyId::Slug}
+This will add a table named `friendly_id_slugs`, used by the {FriendlyId::Slug}
 model.
 
-=== Considerations
-
-This module is incompatible with the +:scoped+ module.
+### Considerations
 
 Because recording slug history requires creating additional database records,
-this module has an impact on the performance of the associated model's +create+
+this module has an impact on the performance of the associated model's `create`
 method.
 
-=== Example
+### Example
 
     class Post < ActiveRecord::Base
       extend FriendlyId
@@ -327,13 +344,13 @@ method.
     end
 
 
-== Unique Slugs by Scope
+## Unique Slugs by Scope
 
 The {FriendlyId::Scoped} module allows FriendlyId to generate unique slugs
 within a scope.
 
 This allows, for example, two restaurants in different cities to have the slug
-+joes-diner+:
+`joes-diner`:
 
     class Restaurant < ActiveRecord::Base
       extend FriendlyId
@@ -347,16 +364,16 @@ This allows, for example, two restaurants in different cities to have the slug
       friendly_id :name, :use => :slugged
     end
 
-    City.find("seattle").restaurants.find("joes-diner")
-    City.find("chicago").restaurants.find("joes-diner")
+    City.friendly.find("seattle").restaurants.friendly.find("joes-diner")
+    City.friendly.find("chicago").restaurants.friendly.find("joes-diner")
 
 Without :scoped in this case, one of the restaurants would have the slug
-+joes-diner+ and the other would have +joes-diner-f9f3789a-daec-4156-af1d-fab81aa16ee5+.
+`joes-diner` and the other would have `joes-diner-f9f3789a-daec-4156-af1d-fab81aa16ee5`.
 
-The value for the +:scope+ option can be the name of a +belongs_to+ relation, or
+The value for the `:scope` option can be the name of a `belongs_to` relation, or
 a column.
 
-Additionally, the +:scope+ option can receive an array of scope values:
+Additionally, the `:scope` option can receive an array of scope values:
 
     class Cuisine < ActiveRecord::Base
       extend FriendlyId
@@ -378,30 +395,30 @@ Additionally, the +:scope+ option can receive an array of scope values:
 
 All supplied values will be used to determine scope.
 
-=== Finding Records by Friendly ID
+### Finding Records by Friendly ID
 
 If you are using scopes your friendly ids may not be unique, so a simple find
 like
 
-    Restaurant.find("joes-diner")
+    Restaurant.friendly.find("joes-diner")
 
 may return the wrong record. In these cases it's best to query through the
 relation:
 
-    @city.restaurants.find("joes-diner")
+    @city.restaurants.friendly.find("joes-diner")
 
 Alternatively, you could pass the scope value as a query parameter:
 
-    Restaurant.find("joes-diner").where(:city_id => @city.id)
+    Restaurant.friendly.find("joes-diner").where(:city_id => @city.id)
 
 
-=== Finding All Records That Match a Scoped ID
+### Finding All Records That Match a Scoped ID
 
 Query the slug column directly:
 
-    Restaurant.find_all_by_slug("joes-diner")
+    Restaurant.where(:slug => "joes-diner")
 
-=== Routes for Scoped Models
+### Routes for Scoped Models
 
 Recall that FriendlyId is a database-centric library, and does not set up any
 routes for scoped models. You must do this yourself in your application. Here's
@@ -416,15 +433,15 @@ an example of one way to set this up:
     <%= link_to 'Show', [@city, @restaurant] %>
 
     # in controllers
-    @city = City.find(params[:city_id])
-    @restaurant = @city.restaurants.find(params[:id])
+    @city = City.friendly.find(params[:city_id])
+    @restaurant = @city.restaurants.friendly.find(params[:id])
 
     # URLs:
     http://example.org/cities/seattle/restaurants/joes-diner
     http://example.org/cities/chicago/restaurants/joes-diner
 
 
-== Translating Slugs Using Simple I18n
+## Translating Slugs Using Simple I18n
 
 The {FriendlyId::SimpleI18n SimpleI18n} module adds very basic i18n support to
 FriendlyId.
@@ -432,64 +449,64 @@ FriendlyId.
 In order to use this module, your model must have a slug column for each locale.
 By default FriendlyId looks for columns named, for example, "slug_en",
 "slug_es", etc. The first part of the name can be configured by passing the
-+:slug_column+ option if you choose. Note that the column for the default locale
+`:slug_column` option if you choose. Note that the column for the default locale
 must also include the locale in its name.
 
 This module is most suitable to applications that need to support few locales.
 If you need to support two or more locales, you may wish to use the
 friendly_id_globalize gem instead.
 
-=== Example migration
+### Example migration
 
-  def self.up
-    create_table :posts do |t|
-      t.string :title
-      t.string :slug_en
-      t.string :slug_es
-      t.text   :body
+    def self.up
+      create_table :posts do |t|
+        t.string :title
+        t.string :slug_en
+        t.string :slug_es
+        t.text   :body
+      end
+      add_index :posts, :slug_en
+      add_index :posts, :slug_es
     end
-    add_index :posts, :slug_en
-    add_index :posts, :slug_es
-  end
 
-=== Finds
+### Finds
 
 Finds will take into consideration the current locale:
 
-  I18n.locale = :es
-  Post.find("la-guerra-de-las-galaxas")
-  I18n.locale = :en
-  Post.find("star-wars")
+    I18n.locale = :es
+    Post.find("la-guerra-de-las-galaxas")
+    I18n.locale = :en
+    Post.find("star-wars")
 
 To find a slug by an explicit locale, perform the find inside a block
-passed to I18n's +with_locale+ method:
+passed to I18n's `with_locale` method:
 
-  I18n.with_locale(:es) do
-    Post.find("la-guerra-de-las-galaxas")
-  end
+    I18n.with_locale(:es) do
+      Post.find("la-guerra-de-las-galaxas")
+    end
 
-=== Creating Records
+### Creating Records
 
 When new records are created, the slug is generated for the current locale only.
 
-=== Translating Slugs
+### Translating Slugs
 
 To translate an existing record's friendly_id, use
 {FriendlyId::SimpleI18n::Model#set_friendly_id}. This will ensure that the slug
 you add is properly escaped, transliterated and sequenced:
 
-  post = Post.create :name => "Star Wars"
-  post.set_friendly_id("La guerra de las galaxas", :es)
+    post = Post.create :name => "Star Wars"
+    post.set_friendly_id("La guerra de las galaxas", :es)
 
 If you don't pass in a locale argument, FriendlyId::SimpleI18n will just use the
 current locale:
 
-  I18n.with_locale(:es) do
-    post.set_friendly_id("La guerra de las galaxas")
-  end
+    I18n.with_locale(:es) do
+      post.set_friendly_id("La guerra de las galaxas")
+    end
 
 
-== Reserved Words
+## Reserved Words
 
 The {FriendlyId::Reserved Reserved} module adds the ability to exlude a list of
 words from use as FriendlyId slugs.
@@ -504,7 +521,7 @@ FriendlyId.defaults}:
     config.reserved_words = %w(new edit nueva nuevo editar)
   end
 
-Note that the error message will appear on the field +:friendly_id+. If you are
+Note that the error message will appear on the field `:friendly_id`. If you are
 using Rails's scaffolded form errors display, then it will have no field to
 highlight. If you'd like to change this so that scaffolding works as expected,
 one way to accomplish this is to move the error message to a different field.