slugalicious 2.0.0 → 2.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 79cad2b0eaf39ef1dfb8aff6d8ae448a64ff13e2
+  data.tar.gz: cc1b3ce56cb2a89e02534e47daeaafeea411cda7
+SHA512:
+  metadata.gz: de5185ea3c49a8a7d6bdc5dccf37c9d71f027b2dc24e28fa82733ee423e39fcc114875f7dfd9e9797e59901742bdc03356c7df5d0d5a91dbd066ab207cf625ff
+  data.tar.gz: 9996a8eda4f63d23bfa5c71a9f05d08c68871f91a0ba95d32ead34e6fa8698baa5bda5435ddbfc05d19f1ba8257c78e1bf36b0617c888a553c672a5f385af855

data/{README.textile → README.md}

@@ -1,23 +1,27 @@
-h1. Slugalicious -- Easy and powerful URL slugging for Rails 3
+Slugalicious -- Easy and powerful URL slugging for Rails 4
+==========================================================
 
-_*(no monkey-patching required)*_
+_(no monkey-patching required)_
 
-| *Author* | Tim Morgan |
-| *Version* | 2.0 (Jun 5, 2012) |
-| *License* | Released under the MIT license. |
+|             |                                 |
+|:------------|:--------------------------------|
+| **Author**  | Tim Morgan                      |
+| **Version** | 2.1 (Jul 9, 2013)               |
+| **License** | Released under the MIT license. |
 
-h3. Note about version 2.0
+### Note about version 2.0
 
 Version 2.0 is so-versioned because it breaks the API for previous versions.
 Previously, where you would have used
 {Slugalicious::ClassMethods#find_from_slug find_from_slug}, you would now use
 {Slugalicious::ClassMethods#find_from_slug! find_from_slug!}. The old method now
-returns @nil@ when an object is not found, rather than raising an exception.
+returns `nil` when an object is not found, rather than raising an exception.
 
-h2. About
+About
+-----
 
 Slugalicious is an easy-to-use slugging library that helps you generate pretty
-URLs for your ActiveRecord objects. It's built for Rails 3 and is cordoned off
+URLs for your ActiveRecord objects. It's built for Rails 4 and is cordoned off
 in a monkey patching-free zone.
 
 Slugalicious is easy to use and powerful enough to cover all of the most common
@@ -31,68 +35,70 @@ generates a unique slug. If all else fails, Slugalicious will fall back on a
 less pretty but guaranteed-unique backup slug generation strategy.
 
 Slugalicious works with the Stringex Ruby library, meaning you get meaningful
-slugs via the @String#to_url@ method. Below are two examples of how powerful
+slugs via the `String#to_url` method. Below are two examples of how powerful
 Stringex is:
 
-<pre><code>
+```` ruby
 "$6 Dollar Burger".to_url #=> "six-dollar-burger"
 "新年好".to_url #=> "xin-nian-hao"
-</code></pre>
+````
 
-h2. Installation
+Installation
+------------
 
-*Important Note:* Slugalicious is written for Rails 3.0 and Ruby 1.9 only.
+*Important Note:* Slugalicious is written for Rails 4.0 and Ruby 1.9 only.
 
-Firstly, add the gem to your Rails project's @Gemfile@:
+Firstly, add the gem to your Rails project's `Gemfile`:
 
-<pre><code>
+```` ruby
 gem 'slugalicious'
-</code></pre>
+````
 
-Next, use the generator to add the @Slug@ model and its migration to your
+Next, use the generator to add the `Slug` model and its migration to your
 project:
 
-<pre><code>
+```` sh
 rails generate slugalicious
-</code></pre>
+````
 
 Then run the migration to set up your database.
 
-h2. Usage
+Usage
+-----
 
-For any model you want to slug, include the @Slugalicious@ module and call
-@slugged@:
+For any model you want to slug, include the `Slugalicious` module and call
+`slugged`:
 
-<pre><code>
+```` ruby
 class User < ActiveRecord::Base
   include Slugalicious
   slugged ->(user) { "#{user.first_name} #{user.last_name}" }
 end
-</code></pre>
+````
 
-Doing this sets the @to_param@ method, so you can go ahead and start generating
-URLs using your models. You can use the @find_from_slug@ method to load a record
+Doing this sets the `to_param` method, so you can go ahead and start generating
+URLs using your models. You can use the `find_from_slug` method to load a record
 from a slug:
 
-<pre><code>
+```` ruby
 user = User.find_from_slug(params[:id])
-</code></pre>
+````
 
-h3. Multiple slug generators
+### Multiple slug generators
 
-The @slugged@ method takes a list of method names (as symbols) or @Procs@ that
+The `slugged` method takes a list of method names (as symbols) or `Procs` that
 each attempt to generate a slug. Each of these generators is tried in order
 until a unique slug is generated. (The output of each of these generators is run
 through the slugifier to convert it to a URL-safe string. The slugifier is by
-default @String#to_url@, provided by the Stringex gem.)
+default `String#to_url`, provided by the Stringex gem.)
 
-So, if we had our @User@ class, and we first wanted to slug by last name only,
+So, if we had our `User` class, and we first wanted to slug by last name only,
 but then add in the first name if two people share a last name, we'd call
-@slugged@ like so:
+`slugged` like so:
 
-<pre><code>
+```` ruby
 slugged :last_name, ->(user) { "#{user.first_name} #{user.last_name}" }
-</code></pre>
+````
 
 In the event that none of these generators manages to make a unique slug, a
 fallback generator is used. This generator prepends the ID of the record, making
@@ -102,20 +108,20 @@ another user with the same name, and that user will get the slug
 "sancho-sample;2". The semicolon is the default ID separator (and it can be
 overridden).
 
-h3. Scoped slugs
+### Scoped slugs
 
 Slugs must normally be unique for a single model type. Thus, if you have a
-@User@ named Hammer and a @Product@ named hammer, they can both share the
+`User` named Hammer and a `Product` named hammer, they can both share the
 "hammer" slug.
 
 If you want to decrease the uniqueness scope of a slug, you can do so with the
-@:scope@ option on the @slugged@ method. Let's say you wanted to limit the scope
-of a @Product@'s slug to its associated @Department@; that way you could have a
+`:scope` option on the `slugged` method. Let's say you wanted to limit the scope
+of a `Product`'s slug to its associated `Department`; that way you could have a
 product named "keyboard" in both the Computer Supplies and the Music Supplies
-departments. To do so, override the @:scope@ option with a method name (as
-symbol) or a @Proc@ that limits the scope of the uniqueness requirement:
+departments. To do so, override the `:scope` option with a method name (as
+symbol) or a `Proc` that limits the scope of the uniqueness requirement:
 
-<pre><code>
+```` ruby
 class Product < ActiveRecord::Base
   include Slugalicious
   belongs_to :department
@@ -127,7 +133,7 @@ class Product < ActiveRecord::Base
     department.name.to_url + "/"
   end
 end
-</code></pre>
+````
 
 Now, your computer keyboard's slug will be "computer-supplies/keyboard" and your
 piano keyboard's slug will be "music-supplies/keyboard". There's an important
@@ -135,30 +141,30 @@ thing to notice here: The method or proc you use to scope the slug must return a
 proper URL substring. That typically means you need to URL-escape it and add a
 slash at the end, as shown in the example above.
 
-When you call @to_param@ on your piano keyboard, instead of just "keyboard", you
+When you call `to_param` on your piano keyboard, instead of just "keyboard", you
 will get "music-supplies/keyboard". Likewise, you can use the
-@find_from_slug_path@ method to find a record from its full path, slug and scope
+`find_from_slug_path` method to find a record from its full path, slug and scope
 included. You would usually use this method in conjunction with route globbing.
-For example, we could set up our @routes.rb@ file like so:
+For example, we could set up our `routes.rb` file like so:
 
-<pre><code>
+```` ruby
 get '/products/*path', 'products#show', as: :products
-</code></pre>
+````
 
-Then, in our @ProductsController@, we load the product from the path slug like
+Then, in our `ProductsController`, we load the product from the path slug like
 so:
 
-<pre><code>
+```` ruby
 def find_product
   @product = Product.find_from_slug_path(params[:path])
 end
-</code></pre>
+````
 
-This is why it's very convenient to have your @:scope@ method/proc not only
+This is why it's very convenient to have your `:scope` method/proc not only
 return the uniqueness constraint, but also the scoped portion of the URL
 preceding the slug.
 
-h3. Altering and expiring slugs
+### Altering and expiring slugs
 
 When a model is created, it gets one slug, marked as the active slug (by
 default). This slug is the first generator that produces a unique slug string.
@@ -169,7 +175,7 @@ that slug is made the active slug. (Priority goes to the first slug generator
 that produces an existing slug [active or inactive]).
 
 If none of the slug generators generates a known, existing slug belonging to the
-object, then the first unique slug is used. A new @Slug@ instance is created and
+object, then the first unique slug is used. A new `Slug` instance is created and
 marked as active, and any other slugs belonging to the object are marked as
 inactive.
 
@@ -181,9 +187,9 @@ current.
 A common application of this is to have inactive slugs 301-redirect to the
 active slug, as a way of both updating search engines' indexes and ensuring that
 people know the URL has changed. As an example of how do this, we alter the
-@find_product@ method shown above to be like so:
+`find_product` method shown above to be like so:
 
-<pre><code>
+```` ruby
 def find_product
   @product = Product.find_from_slug_path(params[:path])
   unless @product.active_slug?(params[:path].split('/').last)
@@ -192,7 +198,7 @@ def find_product
   end
   return true
 end
-</code></pre>
+````
 
 The old URL will remain indefinitely, but users who hit it will be redirected to
 the new URL. Ideally, links to the old URL will be replaced over time with links
@@ -207,9 +213,9 @@ keyboard), you'd find its slug is "keyboard;2" or similar.
 To prevent the slug namespace from becoming more and more polluted over time,
 websites generally expire inactive slugs after a period of time. To do this in
 Slugalicious, write a task that periodically checks for and deletes old,
-inactive @Slug@ records. Such a task could be invoked through a cron job, for
+inactive `Slug` records. Such a task could be invoked through a cron job, for
 instance. An example:
 
-<pre><code>
+```` ruby
 Slug.inactive.where([ "created_at < ?", 30.days.ago ]).delete_all
-</code></pre>
+````

data/lib/slugalicious.rb

@@ -1,7 +1,7 @@
 require 'slugalicious_generator'
 require 'stringex'
 
-# Adds the @slugged@ method to an @ActiveRecord::Base@ subclass. You can then
+# Adds the `slugged` method to an `ActiveRecord::Base` subclass. You can then
 # call this method to add slugging support to your model. See the
 # {ClassMethods#slugged} method for more details.
 #
@@ -47,7 +47,7 @@ module Slugalicious
     #   not found.
 
     def find_from_slug(slug, scope=nil)
-      Slug.from_slug(self, scope, slug).first.try(:sluggable)
+      Slug.from_slug(self, scope, slug).first.try!(:sluggable)
     end
 
     # Locates a record from a given path, that consists of a slug and its scope,
@@ -67,17 +67,17 @@ module Slugalicious
     protected
     
     # Call this method to indicate that your model uses slugging. Pass a list of
-    # *slug generators*: either symbols (method names) or procs that return
+    # **slug generators**: either symbols (method names) or procs that return
     # strings. These strings will be used to generate the slug. You must pass at
     # least one generator. If you pass more than one, the first one that returns
     # a unique slug will be used.
     #
     # The generator does not need to sanitize or parameterize its output; the
-    # @:slugifier@ option can be used to override the default parameterization.
+    # `:slugifier` option can be used to override the default parameterization.
     #
     # In the event that no generator returns a unique slug, the slug returned by
     # the last generator will have the ID of the record appended to it. The ID
-    # and the slug will be separated by the @:id_separator@ option (semicolon by
+    # and the slug will be separated by the `:id_separator` option (semicolon by
     # default). _This_ slug is hopefully unique, because if not, an exception is
     # raised.
     #
@@ -86,28 +86,28 @@ module Slugalicious
     #
     # h2. Scopes
     #
-    # You can scope your slugs to certain URL subpaths using the @:scope@
-    # option. The @:scope:@ option takes a method name or a @Proc@ that, when
+    # You can scope your slugs to certain URL subpaths using the `:scope`
+    # option. The `:scope:` option takes a method name or a `Proc` that, when
     # run, returns a string that scopes the uniqueness constraint of a slug.
     # Rather than being globally unique, the slug must only be unique among
     # other slugs that share the same scope.
     #
-    # *Important note:* The method or @Proc@ that you use for the @:scope@
+    # **Important note:** The method or `Proc` that you use for the `:scope`
     # option should return the portion of the URL preceding the slug, _slash
-    # included_. Let's say you have slugged your @User@ model's @login@ field,
+    # included_. Let's say you have slugged your `User` model's `login` field,
     # and you have two scopes: customers and merchants. In that case, you would
-    # want the @:scope@ method/proc to return either "clients/" or "merchants/".
+    # want the `:scope` method/proc to return either "clients/" or "merchants/".
     #
-    # The string returned by the @:scope@ option will be used to build the full
-    # URL to an object. If you have a client @User@ with login "fancylad", a
-    # call to @to_param@ will return "clients/fancyland". The scope portion of
+    # The string returned by the `:scope` option will be used to build the full
+    # URL to an object. If you have a client `User` with login "fancylad", a
+    # call to `to_param` will return "clients/fancyland". The scope portion of
     # that URL path is used un-sanitized, un-escaped, and un-processed. It is
     # therefore up to _you_ to ensure your scopes are valid URL strings, using
-    # say @String#to_url@ (included as part of this gem).
+    # say `String#to_url` (included as part of this gem).
     #
     # @overload slugged(generator, ..., options={})
-    #   @param [Proc, Symbol] generator If it's a @Symbol@, indicates a method
-    #     that will be called that will return a @String@ to be used for the
+    #   @param [Proc, Symbol] generator If it's a `Symbol`, indicates a method
+    #     that will be called that will return a `String` to be used for the
     #     slug.
     #   @param [Hash] options Additonal options that control slug generation.
     #   @option options [Proc] :slugifier (&:to_url) A proc that, when given a
@@ -116,13 +116,13 @@ module Slugalicious
     #     the "last-resort" slug between the slug and the model ID. This should
     #     be an URL-safe character that would never be produced by your
     #     slugifier.
-    #   @option options [Symbol, Proc] :scope A method name or @Proc@ to run
+    #   @option options [Symbol, Proc] :scope A method name or `Proc` to run
     #     (receives the object being slugged) that returns a string. Slugs must
     #     be unique across all objects for which this method/proc returns the
     #     same value. If not provided, slugs must be globally unique for this
     #     model. The string returned should be equal to the portion of the URL
     #     path that precedes the slug.
-    #   @option options [Array<String>, String] :blacklist ([ 'new', 'edit', 'delete' ])
+    #   @option options [Array<String>, String] :blacklist ([ 'new', 'edit', 'delete', 'destroy' ])
     #     A list of slugs that are disallowed. You would use this to prevent
     #     slugs from sharing the same name as actions in your resource
     #     controller.
@@ -145,28 +145,28 @@ module Slugalicious
                          elsif options[:scope] then
                            raise ArgumentError, ":scope must be a symbol or proc"
                          end
-      self._slug_blacklist = Array.wrap(options[:blacklist] || %w( new edit delete ))
+      self._slug_blacklist = Array.wrap(options[:blacklist] || %w( new edit delete destroy ))
 
       after_save :make_slug
     end
   end
 
   def slug_object
-    slugs.loaded? ? slugs.detect(&:active) : slugs.active.first
+    slugs.loaded? ? slugs.detect(&:active?) : slugs.active.first
   end
   private :slug_object
 
-  # @return [String, nil] The slug for this object, or @nil@ if none has been
+  # @return [String, nil] The slug for this object, or `nil` if none has been
   #   assigned.
 
   def slug
     Rails.cache.fetch("Slug/#{self.class.to_s}/#{id}/slug") do
-      slug_object.try(:slug)
+      slug_object.try!(:slug)
     end
   end
 
   # @return [String, nil] The full slug and path for this object, with scope
-  #   included, or @nil@ if none has been assigned.
+  #   included, or `nil` if none has been assigned.
 
   def slug_with_path
     Rails.cache.fetch("Slug/#{self.class.to_s}/#{id}/slug_with_path") do
@@ -175,9 +175,9 @@ module Slugalicious
   end
 
   # @param [String] slug A slug for this object.
-  # @return [true, false, nil] @true@ if the slug is the currently active one
-  #   (should not redirect), @false@ if it's inactive (should redirect), and
-  #   @nil@ if it's not a known slug for the object (should 404).
+  # @return [true, false, nil] `true` if the slug is the currently active one
+  #   (should not redirect), `false` if it's inactive (should redirect), and
+  #   `nil` if it's not a known slug for the object (should 404).
 
   def active_slug?(slug)
     @active_slug ||= begin
@@ -200,7 +200,7 @@ module Slugalicious
     slugs_in_use = if slugs.loaded? then
                      slugs.map(&:slug)
                    else
-                     slugs.select(:slug).all.map(&:slug)
+                     slugs.select(:slug).map(&:slug)
                    end
 
     # grab a list of all potential slugs derived from the generators
@@ -232,7 +232,7 @@ module Slugalicious
       if self.class._slug_scope then
         scope = scope.where(scope: self.class._slug_scope[self])
       end
-      taken_slug_objects = scope.all
+      taken_slug_objects = scope
 
       # subtract them out from all the potential slugs to make the available slugs
       available_slugs = potential_slugs - taken_slug_objects.map(&:slug)
@@ -243,7 +243,8 @@ module Slugalicious
       Slug.create!(sluggable: self,
                    slug: available_slugs.first,
                    active: true,
-                   scope: self.class._slug_scope.try(:call, self))
+                   scope: self.class._slug_scope.try!(:call, self))
+      slugs(true)
     end
 
     @active_slug = nil

data/slugalicious.gemspec

@@ -5,20 +5,19 @@
 
 Gem::Specification.new do |s|
   s.name = "slugalicious"
-  s.version = "2.0.0"
+  s.version = "2.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Tim Morgan"]
-  s.date = "2012-06-06"
+  s.date = "2013-07-09"
   s.description = "Slugalicious adds simple and powerful slugging to your ActiveRecord models."
   s.email = "git@timothymorgan.info"
   s.extra_rdoc_files = [
     "LICENSE",
-    "README.textile"
+    "README.md"
   ]
   s.files = [
     "LICENSE",
-    "README.textile",
     "lib/slugalicious.rb",
     "lib/slugalicious_generator.rb",
     "slugalicious.gemspec",
@@ -28,37 +27,43 @@ Gem::Specification.new do |s|
   s.homepage = "http://github.com/riscfuture/slugalicious"
   s.require_paths = ["lib"]
   s.required_ruby_version = Gem::Requirement.new(">= 1.9")
-  s.rubygems_version = "1.8.24"
+  s.rubygems_version = "2.0.3"
   s.summary = "Easy-to-use and powerful slugging for Rails 3"
 
   if s.respond_to? :specification_version then
-    s.specification_version = 3
+    s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<rails>, [">= 3.1"])
+      s.add_runtime_dependency(%q<rails>, [">= 4.0"])
       s.add_runtime_dependency(%q<stringex>, [">= 0"])
       s.add_development_dependency(%q<jeweler>, [">= 0"])
       s.add_development_dependency(%q<yard>, [">= 0"])
+      s.add_development_dependency(%q<redcarpet>, [">= 0"])
       s.add_development_dependency(%q<RedCloth>, [">= 0"])
       s.add_development_dependency(%q<sqlite3>, [">= 0"])
       s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<factory_girl>, [">= 0"])
     else
-      s.add_dependency(%q<rails>, [">= 3.1"])
+      s.add_dependency(%q<rails>, [">= 4.0"])
       s.add_dependency(%q<stringex>, [">= 0"])
       s.add_dependency(%q<jeweler>, [">= 0"])
       s.add_dependency(%q<yard>, [">= 0"])
+      s.add_dependency(%q<redcarpet>, [">= 0"])
       s.add_dependency(%q<RedCloth>, [">= 0"])
       s.add_dependency(%q<sqlite3>, [">= 0"])
       s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<factory_girl>, [">= 0"])
     end
   else
-    s.add_dependency(%q<rails>, [">= 3.1"])
+    s.add_dependency(%q<rails>, [">= 4.0"])
     s.add_dependency(%q<stringex>, [">= 0"])
     s.add_dependency(%q<jeweler>, [">= 0"])
     s.add_dependency(%q<yard>, [">= 0"])
+    s.add_dependency(%q<redcarpet>, [">= 0"])
     s.add_dependency(%q<RedCloth>, [">= 0"])
     s.add_dependency(%q<sqlite3>, [">= 0"])
     s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<factory_girl>, [">= 0"])
   end
 end
 

data/templates/slug.rb

@@ -5,15 +5,21 @@
 # redirect purposes. Once a slug is old enough, it is deleted and its value can
 # be used for new records (no longer redirects).
 #
-# h2. Associations
+# Associations
+# ============
 #
-# | @sluggable@ | The record that this slug references. |
+# |             |                                       |
+# |:------------|:--------------------------------------|
+# | `sluggable` | The record that this slug references. |
 #
-# h2. Properties
+# Properties
+# ==========
 #
-# | @slug@ | The slug, lowercased and normalized. Slugs must be unique to their @sluggable_type@ and @scope@. |
-# | @active@ | Whether this is the most recently generated slug for the sluggable. |
-# | @scope@ | Freeform data scoping this slug to a certain subset of records within the model. |
+# |          |                                                                                                  |
+# |:---------|:-------------------------------------------------------------------------------------------------|
+# | `slug`   | The slug, lowercased and normalized. Slugs must be unique to their `sluggable_type` and `scope`. |
+# | `active` | Whether this is the most recently generated slug for the sluggable.                              |
+# | `scope`  | Freeform data scoping this slug to a certain subset of records within the model.                 |
 
 class Slug < ActiveRecord::Base
   belongs_to :sluggable, polymorphic: true
@@ -27,8 +33,8 @@ class Slug < ActiveRecord::Base
   scope :from_slug, ->(klass, scope, slug) {
     where(sluggable_type: klass.to_s, slug: slug, scope: scope)
   }
-  scope :active, where(active: true)
-  scope :inactive, where(active: false)
+  scope :active, -> { where(active: true) }
+  scope :inactive, -> { where(active: false) }
 
   validates :sluggable_type,
             presence: true
@@ -38,22 +44,22 @@ class Slug < ActiveRecord::Base
   validates :slug,
             presence: true,
             length: { maximum: 126 },
-            uniqueness: { case_sensitive: false, scope: [ :scope, :sluggable_type ] } #TODO validate scope case-insensitively
+            uniqueness: { case_sensitive: false, scope: [ :scope, :sluggable_type ] }
   validates :scope,
             length: { maximum: 126 },
-            allow_blank: true
+            allow_nil: true
   validate :one_active_slug_per_object
-  
+
   after_save :invalidate_cache
   after_destroy :invalidate_cache
-  
+
   # Marks a slug as active and deactivates all other slugs assigned to the
   # record.
 
   def activate!
     self.class.transaction do
       Slug.for(sluggable_type, sluggable_id).update_all(active: false)
-      update_attribute :active, true
+      update_column :active, true
     end
   end
 
@@ -63,7 +69,7 @@ class Slug < ActiveRecord::Base
     return unless new_record? or (active? and active_changed?)
     errors.add(:active, :one_per_sluggable) if active? and Slug.active.for(sluggable_type, sluggable_id).count > 0
   end
-  
+
   def invalidate_cache
     Rails.cache.delete "Slug/#{sluggable_type}/#{sluggable_id}/slug"
     Rails.cache.delete "Slug/#{sluggable_type}/#{sluggable_id}/slug_with_path"

metadata

@@ -1,126 +1,139 @@
 --- !ruby/object:Gem::Specification
 name: slugalicious
 version: !ruby/object:Gem::Version
-  version: 2.0.0
-  prerelease: 
+  version: 2.1.0
 platform: ruby
 authors:
 - Tim Morgan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-06 00:00:00.000000000 Z
+date: 2013-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: stringex
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: jeweler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: RedCloth
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: Slugalicious adds simple and powerful slugging to your ActiveRecord models.
@@ -129,37 +142,36 @@ executables: []
 extensions: []
 extra_rdoc_files:
 - LICENSE
-- README.textile
+- README.md
 files:
 - LICENSE
-- README.textile
 - lib/slugalicious.rb
 - lib/slugalicious_generator.rb
 - slugalicious.gemspec
 - templates/create_slugs.rb
 - templates/slug.rb
+- README.md
 homepage: http://github.com/riscfuture/slugalicious
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '1.9'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Easy-to-use and powerful slugging for Rails 3
 test_files: []