friendly_id 3.1.3 → 3.1.4

data/Changelog.md

@@ -6,6 +6,11 @@ suggestions, ideas and improvements to FriendlyId.
 * Table of Contents
 {:toc}
 
+## 3.1.4 (2010-08-30)
+
+* Significantly improve performance of queries using slugs with no cache on AR3.
+* Fix callbacks being invoked after setting cached slugs.
+
 ## 3.1.3 (2010-08-11)
 
 * Reverted approach to read-only fix from previous release.

data/Guide.md

@@ -5,9 +5,9 @@
 
 ## Overview
 
-FriendlyId is a Ruby gem which allows you to work with human-friendly strings
-as if they were numeric ids for Active Record models. This facilitates replacing
-"unfriendly" URL's like
+FriendlyId is an ORM-centric Ruby library that lets you work with human-friendly
+strings as if they were numeric ids. Among other things, this facilitates
+replacing "unfriendly" URL's like:
 
     http://example.com/states/4323454
 
@@ -15,6 +15,10 @@ with "friendly" ones such as:
 
     http://example.com/states/washington
 
+FriendlyId is typically used with Rails and Active Record, but can also be used in
+non-Rails applications, and with [Sequel](http://github.com/norman/friendly_id_sequel) and
+[DataMapper](http://github.com/myabc/friendly_id_datamapper).
+
 ## Simple Models
 
 The simplest way to use FriendlyId is with a model that has a uniquely indexed
@@ -30,9 +34,9 @@ updated. The most common example of this is a user name or login column:
     @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; FriendlyId
-will never modify the value of the column, and your application must ensure
-that the value is admissible in a URL:
+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 value
+is admissible in a URL:
 
     class City < ActiveRecord::Base
       has_friendly_id :name
@@ -60,8 +64,8 @@ wish to modify to make them more suitable for use in URL's.
     redirect_to @post   # the URL will be /posts/this-is-the-first-post
 
 If you are unsure whether to use slugs, then your best bet is to use them,
-because FriendlyId provides many useful features that only work with slugs.
-These features are explained in detail {file:Guide.md#features below}.
+because FriendlyId provides many useful features that only work with this
+feature. These features are explained in detail {file:Guide.md#features below}.
 
 ## Installation
 
@@ -76,13 +80,13 @@ with Rails 2.3.x. and 3.0.
 
 After installing the gem, add an entry in environment.rb:
 
-    config.gem "friendly_id", :version => "~> 2.3"
+    config.gem "friendly_id", :version => "~> 3.1"
 
 ### Rails 3.0
 
 After installing the gem, add an entry in the Gemfile:
 
-    gem "friendly_id", "~> 3.0"
+    gem "friendly_id", "~> 3.1"
 
 ### As a Plugin
 
@@ -94,17 +98,24 @@ However, installing as a gem offers simpler version control than plugin
 installation. Whenever possible, install as a gem instead. Plugin support may
 eventually be removed in a future version.
 
+### Future Compatibility
+
+FriendlyId will always remain compatible with the current release of Rails, and
+at least one stable release behind. That means that support for 2.3.x will not be
+dropped until a stable release of 3.1 is out, or possibly longer.
+
 ### Setup
 
 After installing either as a gem or plugin, run:
 
-    ./script/generate friendly_id
+
+    rails generate friendly_id
     rake db:migrate
 
 This will install the Rake tasks and slug migration for FriendlyId. If you are
-not going to use slugs, you can do:
+not going to use slugs, you can use the `skip-migration` option:
 
-    ./script/generate friendly_id --skip-migration
+    rails generate friendly_id --skip-migration
 
 FriendlyId is now set up and ready for you to use.
 
@@ -147,7 +158,7 @@ dashes, and non-word characters other than "-" are removed.
 
 ### Replacing Accented Characters
 
-If your strings use Western characters, you can use the `:approximate_ascii` option to remove
+If your strings use Latin characters, you can use the `:approximate_ascii` option to remove
 accents and other diacritics:
 
     class City < ActiveRecord::Base
@@ -169,7 +180,7 @@ There are special options for some languages:
 
 FriendlyId supports whatever languages are supported by
 [Babosa](https://github.com/norman/babosa); at the time of writing, this
-includes German, Spanish and Serbian.
+includes Danish, German, Serbian and Spanish.
 
 ### Unicode Slugs
 
@@ -289,8 +300,8 @@ unique if necessary:
     ...
     etc.
 
-Note that the number is preceded by "--" to distinguish it from the
-rest of the slug. This is important to enable having slugs like:
+Note that the number is preceded by "--" rather than "-" to distinguish it from
+the rest of the slug. This is important to enable having slugs like:
 
     /cars/peugeot-206
     /cars/peugeot-206--2
@@ -298,7 +309,7 @@ rest of the slug. This is important to enable having slugs like:
 You can configure the separator string used by your model by setting the
 `:sequence_separator` option in `has_friendly_id`:
 
-    has_friendly_id :title, :use_slug => true, :sequence_separator => ";"
+    has_friendly_id :title, :use_slug => true, :sequence_separator => ":"
 
 You can also override the default used in
 {FriendlyId::Configuration::DEFAULTS} to set the value for any model using
@@ -334,13 +345,12 @@ Checking the slugs table all the time has an impact on performance, so as of
 ### Automatic setup
 
 To enable slug caching, simply add a column named "cached_slug" to your model.
-Is also advised to index this column for performance reason.
 FriendlyId will automatically use this column if it detects it:
 
     class AddCachedSlugToUsers < ActiveRecord::Migration
       def self.up
         add_column :users, :cached_slug, :string
-        add_index  :users, :cached_slug
+        add_index  :users, :cached_slug, :unique => true
       end
 
       def self.down
@@ -353,8 +363,7 @@ Then, redo the slugs:
     rake friendly_id:redo_slugs MODEL=User
 
 FriendlyId will automatically query against the cache column if it's available,
-which significantly improves the performance of many queries, particularly when
-passing an array of friendly ids to #find.
+which will <a href="#some_benchmarks">improve the performance</a> of many queries.
 
 A few warnings when using this feature:
 
@@ -376,6 +385,8 @@ You can also use a different name for the column if you choose, via the
       has_friendly_id :name, :use_slug => true, :cache_column => 'my_cached_slug'
     end
 
+Don't use "slug" or "slugs" because FriendlyId needs those names for its own
+purposes.
 
 ## Nil slugs and skipping validations
 
@@ -504,10 +515,10 @@ Or even better, unless you're using a custom primary key:
 because sorting by a unique integer column is faster than sorting by a date
 column.
 
-## MySQL 5.0 or less
+## MySQL MyISAM tables
 
-Currently, the default FriendlyId migration will not work with MySQL 5.0 or less
-because it creates and index that's too large. The easiest way to work around
+Currently, the default FriendlyId migration will not work with MyISAM tables
+because it creates an index that's too large. The easiest way to work around
 this is to change the generated migration to add limits on some column lengths.
 Please see [this issue](http://github.com/norman/friendly_id/issues#issue/50) in
 the FriendlyId issue tracker for more information.
@@ -537,29 +548,31 @@ enabled. But if it is, then your patches would be very welcome!
 
 
     activerecord (2.3.8)
-    ruby 1.9.2dev (2010-07-06 revision 28549) [x86_64-darwin10.4.0]
-    friendly_id (3.1.0)
+    ruby 1.9.2p0 (2010-08-18 revision 29036) [x86_64-darwin10.4.0]
+    friendly_id (3.1.4)
+    sqlite3-ruby (1.3.1)
     sqlite3 3.6.12 in-memory database
 
                                                        | DEFAULT | NO_SLUG |    SLUG | CACHED_SLUG |
     ------------------------------------------------------------------------------------------------
-    find model by id                             x1000 |   0.340 |   0.468 |   0.877 |       0.534 |
-    find model using array of ids                x1000 |   0.551 |   0.592 |   0.989 |       0.893 |
-    find model using id, then to_param           x1000 |   0.340 |   0.487 |   1.310 |       0.551 |
+    find model by id                             x1000 |   0.370 |   0.503 |   0.940 |       0.562 |
+    find model using array of ids                x1000 |   0.612 |   0.615 |   1.054 |       0.957 |
+    find model using id, then to_param           x1000 |   0.374 |   0.535 |   1.396 |       0.567 |
     ================================================================================================
-    Total                                              |   1.231 |   1.547 |   3.176 |       1.979 |
-
+    Total                                              |   1.356 |   1.653 |   3.390 |       2.086 |
 
 
-    activerecord (3.0.0.beta4)
-    ruby 1.9.2dev (2010-07-06 revision 28549) [x86_64-darwin10.4.0]
-    friendly_id (3.1.0)
+    activerecord (3.0.0)
+    ruby 1.9.2p0 (2010-08-18 revision 29036) [x86_64-darwin10.4.0]
+    friendly_id (3.1.4)
+    sqlite3-ruby (1.3.1)
     sqlite3 3.6.12 in-memory database
 
                                                        | DEFAULT | NO_SLUG |    SLUG | CACHED_SLUG |
     ------------------------------------------------------------------------------------------------
-    find model by id                             x1000 |   0.495 |   0.608 |   1.519 |       0.641 |
-    find model using array of ids                x1000 |   0.708 |   0.722 |   6.483 |       0.782 |
-    find model using id, then to_param           x1000 |   0.506 |   0.645 |   2.644 |       0.637 |
+    find model by id                             x1000 |   0.286 |   0.365 |   0.518 |       0.393 |
+    find model using array of ids                x1000 |   0.329 |   0.441 |   0.709 |       0.475 |
+    find model using id, then to_param           x1000 |   0.321 |   0.332 |   0.976 |       0.399 |
     ================================================================================================
-    Total                                              |   1.709 |   1.976 |  10.645 |       2.061 |
+    Total                                              |   0.936 |   1.138 |   2.203 |       1.266 |
+

data/README.md

@@ -19,13 +19,21 @@ versioning, scoped slugs, reserved words, custom slug generators, and
 excellent Unicode support. For complete information on using FriendlyId,
 please see the [FriendlyId Guide](http://norman.github.com/friendly_id/file.Guide.html).
 
-FriendlyId is compatible with Active Record 2.3.x and 3.0.
+FriendlyId is compatible with Active Record **2.3.x** and **3.0**.
+
+## Docs, Info and Support
+
+* [FriendlyId Guide](http://norman.github.com/friendly_id/file.Guide.html)
+* [API Docs](http://norman.github.com/friendly_id)
+* [Google Group](http://groups.google.com/group/friendly_id)
+* [Source Code](http://github.com/norman/friendly_id/)
+* [Issue Tracker](http://github.com/norman/friendly_id/issues)
 
 ## Rails Quickstart
 
     gem install friendly_id
 
-    rails my_app
+    rails new my_app
 
     cd my_app
 
@@ -44,7 +52,7 @@ FriendlyId is compatible with Active Record 2.3.x and 3.0.
 
     User.create! :name => "Joe Schmoe"
 
-    ./script/server
+    rails server
 
     GET http://0.0.0.0:3000/users/joe-schmoe
 
@@ -56,15 +64,7 @@ in progress. To find out more, check out the Github projects:
 * [http://github.com/norman/friendly_id_sequel](http://github.com/norman/friendly_id_sequel)
 * [http://github.com/myabc/friendly_id_datamapper](http://github.com/myabc/friendly_id_datamapper)
 
-## Docs, Info and Support
-
-* [FriendlyId Guide](http://norman.github.com/friendly_id/file.Guide.html)
-* [API Docs](http://norman.github.com/friendly_id)
-* [Google Group](http://groups.google.com/group/friendly_id)
-* [Source Code](http://github.com/norman/friendly_id/)
-* [Issue Tracker](http://github.com/norman/friendly_id/issues)
-
-## Bugs:
+## Bugs
 
 Please report them on the [Github issue tracker](http://github.com/norman/friendly_id/issues)
 for this project.
@@ -79,7 +79,7 @@ If you have a bug to report, please include the following information:
 If you are able to, it helps even more if you can fork FriendlyId on Github,
 and add a test that reproduces the error you are experiencing.
 
-## Credits:
+## Credits
 
 FriendlyId was created by Norman Clarke, Adrian Mugnolo, and Emilio Tagua.
 

data/Rakefile

@@ -1,3 +1,5 @@
+require "rubygems"
+require "bundler/setup"
 require "rake"
 require "rake/testtask"
 require "rake/gempackagetask"

data/extras/bench.rb

@@ -37,4 +37,4 @@ RBench.run(TIMES) do
 
   summary 'Total'
 
-end
+end

data/lib/friendly_id/active_record_adapter/finders.rb

@@ -26,8 +26,8 @@ module FriendlyId
         end
 
         def find_one
-          return find_one_using_cached_slug if cache_column?
-          return find_one_using_slug if use_slugs?
+          return find_one_with_cached_slug if cache_column?
+          return find_one_with_slug if use_slugs?
           @result = scoped(:conditions => ["#{table_name}.#{fc.column} = ?", id]).first(options)
           assign_status
         end
@@ -56,12 +56,12 @@ module FriendlyId
 
         private
 
-        def find_one_using_cached_slug
+        def find_one_with_cached_slug
           @result = scoped(:conditions => ["#{table_name}.#{cache_column} = ?", id]).first(options)
-          assign_status or find_one_using_slug
+          assign_status or find_one_with_slug
         end
 
-        def find_one_using_slug
+        def find_one_with_slug
           name, seq = id.to_s.parse_friendly_id
           scope = scoped(:joins => :slugs, :conditions => {:slugs => {:name => name, :sequence => seq}})
           scope = scope.scoped(:conditions => {:slugs => {:scope => scope_val}}) if fc.scope?

data/lib/friendly_id/active_record_adapter/relation.rb

@@ -2,128 +2,170 @@ module FriendlyId
   module ActiveRecordAdapter
     module Relation
 
-      attr :friendly_id_scope
+      class Find
+        extend Forwardable
 
-      # This method overrides Active Record's default in order to allow the :scope option to
-      # be passed to finds.
-      def apply_finder_options(options)
-        @friendly_id_scope = options.delete(:scope)
-        @friendly_id_scope = @friendly_id_scope.to_param if @friendly_id_scope.respond_to?(:to_param)
-        super
-      end
+        attr :relation
+        attr :ids
+        alias id ids
 
-      protected
+        def_delegators :relation, :arel, :arel_table, :friendly_id_scope,
+                       :klass, :limit_value, :offset_value, :where
+        def_delegators :klass, :connection, :friendly_id_config
+        alias fc friendly_id_config
 
-      def find_one(id)
-        begin
-          return super if !@klass.uses_friendly_id? or id.unfriendly_id?
-          return find_one_using_cached_slug(id) if friendly_id_config.cache_column?
-          return find_one_using_slug(id) if friendly_id_config.use_slugs?
-          record = where(friendly_id_config.column => id).first
-          if record
-            record.friendly_id_status.name = name
-            record
+        def initialize(relation, ids)
+          @relation = relation
+          @ids = ids
+        end
+
+        def find_one
+          if fc.cache_column?
+            find_one_with_cached_slug
+          elsif fc.use_slugs?
+            find_one_with_slug
           else
-            super
+            find_one_without_slug
           end
-        rescue ActiveRecord::RecordNotFound => error
-          uses_friendly_id? && friendly_id_config.scope? ? raise_scoped_error(error) : raise(error)
         end
-      end
 
-      def find_some(ids)
-        return super unless @klass.uses_friendly_id?
-        ids = ids.compact.uniq.map {|id| id.respond_to?(:friendly_id_config) ? id.id.to_i : id}
-        records = friendly_records(*ids.partition {|id| id.friendly_id?}).each do |record|
-          record.friendly_id_status.name = ids
+        def find_some
+          ids = @ids.compact.uniq.map {|id| id.respond_to?(:friendly_id_config) ? id.id.to_i : id}
+          friendly_ids, unfriendly_ids = ids.partition {|id| id.friendly_id?}
+          return if friendly_ids.empty?
+          records = friendly_records(friendly_ids, unfriendly_ids).each do |record|
+            record.friendly_id_status.name = ids
+          end
+          validate_expected_size!(ids, records)
         end
-        validate_expected_size!(ids, records)
-      end
 
-      private
-
-      def find_one_using_slug(id)
-        name, seq = id.to_s.parse_friendly_id
-        slug = Slug.where(:name => name, :sequence => seq, :scope => friendly_id_scope,
-                          :sluggable_type => @klass.base_class.to_s).first
-        if slug
-          record = find_one(slug.sluggable_id.to_i)
-          record.friendly_id_status.name = name
-          record.friendly_id_status.sequence = seq
-          record.friendly_id_status.slug = slug
-          record
-        else
-          find_one_without_friendly(id)
+        def raise_error(error)
+          raise(error) unless fc.scope
+          scope_message = friendly_id_scope || "expected, but none given"
+          message = "%s, scope: %s" % [error.message, scope_message]
+          raise ActiveRecord::RecordNotFound, message
         end
-      end
 
-      def find_one_using_cached_slug(id)
-        record = where(friendly_id_config.cache_column => id).first
-        if record
+        private
+
+        def assign_status
+          return unless @result
           name, seq = id.to_s.parse_friendly_id
-          record.friendly_id_status.name = name
-          record.friendly_id_status.sequence = seq
-          record
-        else
-          find_one_using_slug(id)
+          @result.friendly_id_status.name = name
+          @result.friendly_id_status.sequence = seq if fc.use_slugs?
+          @result
         end
-      end
 
-      def raise_scoped_error(error)
-        scope_message = friendly_id_scope || "expected, but none given"
-        message = "%s, scope: %s" % [error.message, scope_message]
-        raise ActiveRecord::RecordNotFound, message
-      end
+        def find_one_without_slug
+          @result = where(fc.column => id).first
+          assign_status
+        end
 
-      def friendly_records(friendly_ids, unfriendly_ids)
-        use_slugs  = friendly_id_config.use_slugs? && !friendly_id_config.cache_column?
-        column     = friendly_id_config.cache_column || friendly_id_config.column
-        friendly   = use_slugs ? slugged_conditions(friendly_ids) : arel_table[column].in(friendly_ids)
-        unfriendly = arel_table[primary_key].in unfriendly_ids
-        if friendly_ids.present? && unfriendly_ids.present?
-          clause = friendly.or(unfriendly)
-        elsif friendly_ids.present?
-          clause = friendly
-        elsif unfriendly_ids.present?
-          clause = unfriendly
+        def find_one_with_cached_slug
+          @result = where(fc.cache_column => id).first
+          assign_status or find_one_with_slug
         end
-        use_slugs ? includes(:slugs).where(clause) : where(clause)
-      end
 
-      def slugged_conditions(ids)
-        return if ids.empty?
-        slugs = Slug.arel_table
-        conditions = lambda do |id|
-          name, seq = id.parse_friendly_id
-          slugs[:name].eq(name).and(slugs[:sequence].eq(seq)).and(slugs[:scope].eq(friendly_id_scope))
+        def find_one_with_slug
+          sluggable_id = sluggable_ids_for([id]).first
+          if sluggable_id
+            name, seq = id.to_s.parse_friendly_id
+            record = relation.send(:find_one_without_friendly, sluggable_id)
+            record.friendly_id_status.name     = name
+            record.friendly_id_status.sequence = seq
+            record
+          else
+            relation.send(:find_one_without_friendly, id)
+          end
         end
-        ids.inject(nil) {|clause, id| clause ? clause.or(conditions.call(id)) : conditions.call(id) }
-      end
 
-      def validate_expected_size!(ids, result)
-        expected_size =
-          if @limit_value && ids.size > @limit_value
-            @limit_value
+        def friendly_records(friendly_ids, unfriendly_ids)
+          use_slugs_table =  fc.use_slugs? && (friendly_id_scope || !fc.cache_column?)
+          return find_some_using_slug(friendly_ids, unfriendly_ids) if use_slugs_table
+          column     = fc.cache_column || fc.column
+          friendly   = arel_table[column].in(friendly_ids)
+          unfriendly = arel_table[relation.primary_key].in unfriendly_ids
+          if friendly_ids.present? && unfriendly_ids.present?
+            where(friendly.or(unfriendly))
           else
-            ids.size
+            where(friendly)
+          end
+        end
+
+        def find_some_using_slug(friendly_ids, unfriendly_ids)
+          ids = [unfriendly_ids + sluggable_ids_for(friendly_ids)].flatten.uniq
+          where(arel_table[relation.primary_key].in(ids))
+        end
+
+        def sluggable_ids_for(ids)
+          return [] if ids.empty?
+          fragment = "(slugs.name = %s AND slugs.sequence = %d)"
+          conditions = ids.inject(nil) do |clause, id|
+            name, seq = id.parse_friendly_id
+            string = fragment % [connection.quote(name), seq]
+            clause ? clause + " OR #{string}" : string
           end
+          if fc.scope?
+            scope = connection.quote(friendly_id_scope)
+            conditions = "slugs.scope = %s AND (%s)" % [scope, conditions]
+          end
+          connection.select_values "SELECT sluggable_id FROM slugs WHERE (%s)" % conditions
+        end
 
-        # 11 ids with limit 3, offset 9 should give 2 results.
-        if @offset_value && (ids.size - @offset_value < expected_size)
-          expected_size = ids.size - @offset_value
+        def validate_expected_size!(ids, result)
+          expected_size =
+            if limit_value && ids.size > limit_value
+              limit_value
+            else
+              ids.size
+            end
+
+          # 11 ids with limit 3, offset 9 should give 2 results.
+          if offset_value && (ids.size - offset_value < expected_size)
+            expected_size = ids.size - offset_value
+          end
+
+          if result.size == expected_size
+            result
+          else
+            conditions = arel.send(:where_clauses).join(', ')
+            conditions = " [WHERE #{conditions}]" if conditions.present?
+            error = "Couldn't find all #{klass.name.pluralize} with IDs "
+            error << "(#{ids.join(", ")})#{conditions} (found #{result.size} results, but was looking for #{expected_size})"
+            raise ActiveRecord::RecordNotFound, error
+          end
         end
+      end
+
+      attr :friendly_id_scope
+
+      # This method overrides Active Record's default in order to allow the :scope option to
+      # be passed to finds.
+      def apply_finder_options(options)
+        @friendly_id_scope = options.delete(:scope)
+        @friendly_id_scope = @friendly_id_scope.to_param if @friendly_id_scope.respond_to?(:to_param)
+        super
+      end
 
-        if result.size == expected_size
-          result
-        else
-          conditions = arel.send(:where_clauses).join(', ')
-          conditions = " [WHERE #{conditions}]" if conditions.present?
+      protected
 
-          error = "Couldn't find all #{@klass.name.pluralize} with IDs "
-          error << "(#{ids.join(", ")})#{conditions} (found #{result.size} results, but was looking for #{expected_size})"
-          raise ActiveRecord::RecordNotFound, error
+      def find_one(id)
+        begin
+          return super if !klass.uses_friendly_id? or id.unfriendly_id?
+          find = Find.new(self, id)
+          find.find_one or super
+        rescue ActiveRecord::RecordNotFound => error
+          find ? find.raise_error(error) : raise(error)
         end
       end
+
+      def find_some(ids)
+        return super unless klass.uses_friendly_id?
+        Find.new(self, ids).find_some or super
+      rescue ActiveRecord::RecordNotFound => error
+        find ? find.raise_error(error) : raise(error)
+      end
+
     end
   end
 end

data/lib/friendly_id/active_record_adapter/slugged_model.rb

@@ -101,10 +101,11 @@ module FriendlyId
       # This method was removed in ActiveRecord 3.0.
       if !ActiveRecord::Base.private_method_defined? :update_without_callbacks
         def update_without_callbacks
-          save :callbacks => false
+          attributes_with_values = arel_attributes_values(false, false, attribute_names)
+          return false if attributes_with_values.empty?
+          self.class.unscoped.where(self.class.arel_table[self.class.primary_key].eq(id)).arel.update(attributes_with_values)
         end
       end
-
     end
   end
-end
+end

data/lib/friendly_id/configuration.rb

@@ -85,6 +85,14 @@ module FriendlyId
       yield self if block_given?
     end
 
+    def cache_column=(value)
+      @cache_column = value.to_s.strip.to_sym
+      if [:slug, :slugs, :""].include?(@cache_column)
+        raise ArgumentError, "FriendlyId cache column can not be named '#{value}'"
+      end
+      @cache_column
+    end
+
     # This should be overridden by adapters that implement caching.
     def cache_column?
       false
@@ -107,6 +115,13 @@ module FriendlyId
       @scope = scope
     end
 
+    def sequence_separator=(string)
+      if string == "-" || string =~ /\s/
+        raise ArgumentError, "FriendlyId sequence_separator can not be '#{string}'"
+      end
+      @sequence_separator = string
+    end
+
     # This will be set if FriendlyId's scope feature is used in any model. It is here
     # to provide a way to avoid invoking costly scope lookup methods when the scoped
     # slug feature is not being used by any models.
@@ -121,7 +136,7 @@ module FriendlyId
     end
 
     %w[approximate_ascii scope strip_non_ascii use_slug].each do |method|
-      class_eval(<<-EOM)
+      class_eval(<<-EOM, __FILE__, __LINE__ +1)
         def #{method}?
           !! #{method}
         end
@@ -130,6 +145,13 @@ module FriendlyId
 
     alias :use_slugs? :use_slug?
 
+    def babosa_options
+      {
+        :to_ascii         => strip_non_ascii?,
+        :transliterate    => approximate_ascii?,
+        :transliterations => ascii_approximation_options,
+        :max_length       => max_length
+      }
+    end
   end
-
 end

data/lib/friendly_id/slug_string.rb

@@ -1,14 +1,12 @@
 # encoding: utf-8
 module FriendlyId
 
-  class SlugString < Babosa::SlugString
+  class SlugString < Babosa::Identifier
     # Normalize the string for a given {FriendlyId::Configuration}.
     # @param config [FriendlyId::Configuration]
     # @return String
     def normalize_for!(config)
-      approximate_ascii!(config.ascii_approximation_options) if config.approximate_ascii?
-      to_ascii! if config.strip_non_ascii?
-      normalize!
+      normalize!(config.babosa_options)
     end
 
     # Validate that the slug string is not blank or reserved, and truncate

data/lib/friendly_id/test.rb

@@ -94,12 +94,6 @@ module FriendlyId
         assert_equal instance, klass.send(find_method, "206")
       end
 
-      test "failing finds with unfriendly_id should raise errors normally" do
-        assert_raise ActiveRecord::RecordNotFound do
-          klass.send(find_method, 0)
-        end
-      end
-
       test "creation should raise an error if the friendly_id text is reserved" do
         assert_validation_error do
           klass.send(create_method, :name => "new")

data/lib/friendly_id/version.rb

@@ -2,7 +2,7 @@ module FriendlyId
   module Version
     MAJOR = 3
     MINOR = 1
-    TINY = 3
+    TINY = 4
     BUILD = nil
     STRING = [MAJOR, MINOR, TINY, BUILD].compact.join('.')
   end

data/test/active_record_adapter/ar_test_helper.rb

@@ -35,6 +35,11 @@ CreateSupportModels.up
 # A model that uses the automagically configured "cached_slug" column
 class District < ActiveRecord::Base
   has_friendly_id :name, :use_slug => true
+  before_save :say_hello
+
+  def say_hello
+    @said_hello = true
+  end
 end
 
 # A model with optimistic locking enabled

data/test/active_record_adapter/cached_slug_test.rb

@@ -64,6 +64,11 @@ module FriendlyId
           instance.friendly_id(true)
         end
 
+        test "should not fire callbacks when updating slug cache" do
+          instance.expects(:say_hello).once
+          instance.update_attributes(:name => "new name")
+          assert_equal instance.slug.to_friendly_id, cached_slug
+        end
       end
     end
   end

data/test/active_record_adapter/core.rb

@@ -114,6 +114,12 @@ module FriendlyId
           end
         end
 
+        test "failing finds with unfriendly_id should raise errors normally" do
+          assert_raise ActiveRecord::RecordNotFound do
+            klass.send(find_method, 0)
+          end
+        end
+
         test "instances found by a single id should not be read-only" do
           i = klass.find(instance.friendly_id)
           assert !i.readonly?, "expected instance not to be readonly"

data/test/active_record_adapter/scoped_model_test.rb

@@ -5,20 +5,15 @@ module FriendlyId
 
     class ScopedModelTest < ::Test::Unit::TestCase
 
-      include FriendlyId::Test::Generic
-      include FriendlyId::Test::Slugged
-      include FriendlyId::Test::ActiveRecordAdapter::Slugged
-      include FriendlyId::Test::ActiveRecordAdapter::Core
-
       def setup
-        @user = User.create!(:name => "john")
-        @house = House.create!(:name => "123 Main", :user => @user)
-        @usa = Country.create!(:name => "USA")
-        @canada = Country.create!(:name => "Canada")
-        @resident = Resident.create!(:name => "John Smith", :country => @usa)
+        @user      = User.create!(:name => "john")
+        @house     = House.create!(:name => "123 Main", :user => @user)
+        @usa       = Country.create!(:name => "USA")
+        @canada    = Country.create!(:name => "Canada")
+        @resident  = Resident.create!(:name => "John Smith", :country => @usa)
         @resident2 = Resident.create!(:name => "John Smith", :country => @canada)
-        @owner = Company.create!(:name => "Acme Events")
-        @site = Site.create!(:name => "Downtown Venue", :owner => @owner)
+        @owner     = Company.create!(:name => "Acme Events")
+        @site      = Site.create!(:name => "Downtown Venue", :owner => @owner)
       end
 
       def teardown
@@ -77,13 +72,21 @@ module FriendlyId
       end
 
       test "should find a single scoped record with a scope as a string" do
-        assert Resident.find(@resident.friendly_id, :scope => @resident.country)
+        assert Resident.find(@resident.friendly_id, :scope => @resident.country.to_param)
       end
 
       test "should find a single scoped record with a scope" do
         assert Resident.find(@resident.friendly_id, :scope => @resident.country)
       end
 
+      test "should find a multiple scoped records with a scope" do
+        r1 = Resident.create!(:name => "John Smith", :country => @usa)
+        r2 = Resident.create!(:name => "Jane Smith", :country => @usa)
+        result = Resident.find([r1, r2].map(&:friendly_id), :scope => @resident.country)
+        assert_equal 2, result.size
+      end
+
+
       test "should raise an error when finding a single scoped record with no scope" do
         assert_raises ActiveRecord::RecordNotFound do
           Resident.find(@resident.friendly_id)
@@ -123,4 +126,4 @@ module FriendlyId
       end
     end
   end
-end
+end

data/test/friendly_id_test.rb

@@ -1,7 +1,52 @@
+# encoding: utf-8
 require File.expand_path('../test_helper', __FILE__)
 
 module FriendlyId
   module Test
+
+    class ConfigurationTest < ::Test::Unit::TestCase
+      test "should validate sequence separator name" do
+        ["-", " ", "\n", "\t"].each do |string|
+          assert_raise ArgumentError do
+            Configuration.new(NilClass, :hello, :sequence_separator => string)
+          end
+        end
+      end
+
+      test "should validate cached slug name" do
+        ["slug", "slugs", " "].each do |string|
+          assert_raise ArgumentError do
+            Configuration.new(NilClass, :hello, :cache_column => string)
+          end
+        end
+      end
+    end
+
+    class SlugStringTest < ::Test::Unit::TestCase
+      test "should not transliterate by default" do
+        s = SlugString.new("über")
+        assert_equal "über", s.normalize_for!(Configuration.new(nil, :name))
+      end
+
+      test "should transliterate if specified" do
+        s = SlugString.new("über")
+        options = {:approximate_ascii => true}
+        assert_equal "uber", s.normalize_for!(Configuration.new(nil, :name, options))
+      end
+
+      test "should strip non-ascii if specified" do
+        s = SlugString.new("über")
+        options = {:strip_non_ascii => true}
+        assert_equal "ber", s.normalize_for!(Configuration.new(nil, :name, options))
+      end
+
+      test "should use transliterations if given" do
+        s = SlugString.new("über")
+        options = {:approximate_ascii => true, :ascii_approximation_options => :german}
+        assert_equal "ueber", s.normalize_for!(Configuration.new(nil, :name, options))
+      end
+    end
+
     class FriendlyIdTest < ::Test::Unit::TestCase
       test "should parse a friendly_id name and sequence" do
         assert_equal ["test", 2], "test--2".parse_friendly_id
@@ -48,4 +93,4 @@ module FriendlyId
       end
     end
   end
-end
+end

data/test/test_helper.rb

@@ -5,11 +5,9 @@ $:.uniq!
 $KCODE = "UTF8" if RUBY_VERSION < "1.9"
 $VERBOSE = false
 require "rubygems"
-require "bundler"
-Bundler.setup
+require "bundler/setup"
 require "test/unit"
 require "mocha"
 require "active_support"
-# require "ruby-debug"
 require "friendly_id"
 require "friendly_id/test"

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 3
   - 1
-  - 3
-  version: 3.1.3
+  - 4
+  version: 3.1.4
 platform: ruby
 authors: 
 - Norman Clarke
@@ -16,23 +16,23 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-11 00:00:00 -03:00
+date: 2010-09-01 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: babosa
-  prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
         segments: 
         - 0
-        - 1
+        - 2
         - 0
-        version: 0.1.0
+        version: 0.2.0
   type: :runtime
+  prerelease: false
   version_requirements: *id001
 description: "    FriendlyId is the \"Swiss Army bulldozer\" of slugging and permalink plugins\n    for Ruby on Rails. It allows you to create pretty URL\xE2\x80\x99s and work with\n    human-friendly strings as if they were numeric ids for ActiveRecord models.\n"
 email: 
@@ -70,7 +70,7 @@ files:
 - Contributors.md
 - Guide.md
 - README.md
-- LICENSE
+- MIT-LICENSE
 - Rakefile
 - rails/init.rb
 - generators/friendly_id/friendly_id_generator.rb
@@ -92,7 +92,6 @@ files:
 - test/active_record_adapter/support/database.mysql.yml
 - test/active_record_adapter/support/database.postgres.yml
 - test/active_record_adapter/support/database.sqlite3.yml
-- test/active_record_adapter/support/database.yml
 - test/active_record_adapter/support/models.rb
 - test/active_record_adapter/tasks_test.rb
 - test/friendly_id_test.rb
@@ -117,6 +116,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 4295902025361844549
       segments: 
       - 0
       version: "0"
@@ -125,6 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 4295902025361844549
       segments: 
       - 0
       version: "0"

data/test/active_record_adapter/support/database.yml

@@ -1,6 +0,0 @@
-adapter: postgresql
-host: localhost
-port: 5432
-username: postgres
-database: friendly_id_test
-encoding: utf8