friendly_id 4.0.0.beta7 → 4.0.0.beta8

data/Changelog.md

@@ -178,11 +178,11 @@ fork, then this upgrade may causes issues.
 * New option to pass arguments to `FriendlyId::SlugString#approximate_ascii!`,
   allowing custom approximations specific to German or Spanish.
 * FriendlyId now queries against the cached_slug column, which improves performance.
-* {FriendlyId::SlugString} class added, allowing finer-grained control over
+* FriendlyId::SlugString class added, allowing finer-grained control over
   Unicode friendly_id strings.
-* {FriendlyId::Configuration} class added, offering more flexible/hackable
+* FriendlyId::Configuration class added, offering more flexible/hackable
   options.
-* FriendlyId now raises subclasses of {FriendlyId::SlugGenerationError}
+* FriendlyId now raises subclasses of FriendlyId::SlugGenerationError
   depending on the error context.
 * Simple models now correctly validate friendly_id length.
 * Passing block into FriendlyId deprecated in favor of overriding

data/README.md

@@ -24,8 +24,10 @@ FriendlyId is compatible with Active Record **3.0** and **3.1**.
 
 ## Version 4.x
 
-FriendlyId 4.x introduces many changes incompatible with 3.x. If you're upgrading,
-please read the docs to see what's new.
+FriendlyId 4.x introduces many changes incompatible with 3.x. If you're
+upgrading, please [read the
+docs](http://norman.github.com/friendly_id/file.WhatsNew.html) to see what's
+new.
 
 ## Rails Quickstart
 
@@ -35,7 +37,7 @@ please read the docs to see what's new.
 
     cd my_app
 
-    gem "friendly_id", "~> 4.0.0.beta7"
+    gem "friendly_id", "~> 4.0.0.beta8"
 
 
     rails generate scaffold user name:string slug:string
@@ -60,7 +62,7 @@ please read the docs to see what's new.
 ## Docs
 
 The current docs can be found
-[here](http://rdoc.info/github/norman/friendly_id/a4128af31d85ee29ad8f/frames).
+[here](http://norman.github.com/friendly_id/)
 
 ## Benchmarks
 

data/lib/friendly_id.rb

@@ -81,7 +81,7 @@ In general, use slugs by default unless you know for sure you don't need them.
 module FriendlyId
 
   # The current version.
-  VERSION = "4.0.0.beta7"
+  VERSION = "4.0.0.beta8"
 
   @mutex = Mutex.new
 

data/lib/generators/friendly_id_generator.rb

@@ -1,16 +1,16 @@
 require 'rails/generators'
 require 'rails/generators/migration'
 
+# This generator adds a migration for the {FriendlyId::History
+# FriendlyId::History} addon.
 class FriendlyIdGenerator < Rails::Generators::Base
-
   include Rails::Generators::Migration
 
-  source_root File.expand_path('../../../generators/friendly_id/templates', __FILE__)
-
-  class_option :"skip-migration", :type => :boolean, :desc => "Don't generate a migration for the slugs table"
+  source_root File.expand_path('../../friendly_id', __FILE__)
 
+  # Copies the migration template to db/migrate.
   def copy_files(*args)
-    migration_template 'create_slugs.rb', "db/migrate/create_slugs.rb" unless options["skip-migration"]
+    migration_template 'migration.rb', 'db/migrate/create_friendly_id_slugs.rb'
   end
 
   # Taken from ActiveRecord's migration generator
@@ -21,5 +21,4 @@ class FriendlyIdGenerator < Rails::Generators::Base
       "%.3d" % (current_migration_number(dirname) + 1)
     end
   end
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: friendly_id
 version: !ruby/object:Gem::Version
-  version: 4.0.0.beta7
+  version: 4.0.0.beta8
   prerelease: 6
 platform: ruby
 authors:
@@ -14,7 +14,7 @@ default_executable:
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &70318438630040 !ruby/object:Gem::Requirement
+  requirement: &70172556099120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -22,10 +22,10 @@ dependencies:
         version: '3.0'
   type: :development
   prerelease: false
-  version_requirements: *70318438630040
+  version_requirements: *70172556099120
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &70318438629540 !ruby/object:Gem::Requirement
+  requirement: &70172556098620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,10 +33,10 @@ dependencies:
         version: '1.3'
   type: :development
   prerelease: false
-  version_requirements: *70318438629540
+  version_requirements: *70172556098620
 - !ruby/object:Gem::Dependency
   name: minitest
-  requirement: &70318438629080 !ruby/object:Gem::Requirement
+  requirement: &70172556098140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -44,10 +44,10 @@ dependencies:
         version: 2.4.0
   type: :development
   prerelease: false
-  version_requirements: *70318438629080
+  version_requirements: *70172556098140
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &70318438628620 !ruby/object:Gem::Requirement
+  requirement: &70172556097640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -55,10 +55,10 @@ dependencies:
         version: 0.9.12
   type: :development
   prerelease: false
-  version_requirements: *70318438628620
+  version_requirements: *70172556097640
 - !ruby/object:Gem::Dependency
   name: ffaker
-  requirement: &70318438628120 !ruby/object:Gem::Requirement
+  requirement: &70172556097180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -66,10 +66,10 @@ dependencies:
         version: 1.8.0
   type: :development
   prerelease: false
-  version_requirements: *70318438628120
+  version_requirements: *70172556097180
 - !ruby/object:Gem::Dependency
   name: maruku
-  requirement: &70318438627560 !ruby/object:Gem::Requirement
+  requirement: &70172556096720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -77,10 +77,10 @@ dependencies:
         version: 0.6.0
   type: :development
   prerelease: false
-  version_requirements: *70318438627560
+  version_requirements: *70172556096720
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &70318438627040 !ruby/object:Gem::Requirement
+  requirement: &70172556096260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -88,7 +88,7 @@ dependencies:
         version: 0.7.2
   type: :development
   prerelease: false
-  version_requirements: *70318438627040
+  version_requirements: *70172556096260
 description: ! 'FriendlyId is the "Swiss Army bulldozer" of slugging and permalink
   plugins for
 
@@ -120,32 +120,18 @@ files:
 - gemfiles/Gemfile.rails-3.1.rb
 - gemfiles/Gemfile.rails-3.1.rb.lock
 - lib/friendly_id.rb
-- lib/friendly_id/active_record.rb
-- lib/friendly_id/active_record_adapter/configuration.rb
-- lib/friendly_id/active_record_adapter/relation.rb
-- lib/friendly_id/active_record_adapter/simple_model.rb
-- lib/friendly_id/active_record_adapter/slug.rb
-- lib/friendly_id/active_record_adapter/slugged_model.rb
-- lib/friendly_id/active_record_adapter/tasks.rb
 - lib/friendly_id/base.rb
 - lib/friendly_id/configuration.rb
-- lib/friendly_id/datamapper.rb
 - lib/friendly_id/finder_methods.rb
 - lib/friendly_id/history.rb
 - lib/friendly_id/migration.rb
 - lib/friendly_id/model.rb
 - lib/friendly_id/object_utils.rb
-- lib/friendly_id/railtie.rb
 - lib/friendly_id/reserved.rb
 - lib/friendly_id/scoped.rb
-- lib/friendly_id/sequel.rb
 - lib/friendly_id/slug.rb
 - lib/friendly_id/slug_sequencer.rb
-- lib/friendly_id/slug_string.rb
 - lib/friendly_id/slugged.rb
-- lib/friendly_id/status.rb
-- lib/friendly_id/test.rb
-- lib/friendly_id/version.rb
 - lib/generators/friendly_id_generator.rb
 - test/base_test.rb
 - test/configuration_test.rb

data/lib/friendly_id/active_record.rb

@@ -1,56 +0,0 @@
-module FriendlyId
-
-  module ActiveRecordAdapter
-
-    include FriendlyId::Base
-
-    def has_friendly_id(method, options = {})
-
-      class_attribute :friendly_id_config
-      self.friendly_id_config = Configuration.new(self, method, options)
-
-      if friendly_id_config.use_slug?
-        include SluggedModel
-      else
-        include SimpleModel
-      end
-    end
-
-    private
-
-    # Prevent the cached_slug column from being accidentally or maliciously
-    # overwritten. Note that +attr_protected+ is used to protect the cached_slug
-    # column, unless you have already invoked +attr_accessible+. So if you
-    # wish to use +attr_accessible+, you must invoke it BEFORE you invoke
-    # {#has_friendly_id} in your class.
-    def protect_friendly_id_attributes
-      # only protect the column if the class is not already using attr_accessible
-      unless accessible_attributes.present?
-        if friendly_id_config.custom_cache_column?
-          attr_protected friendly_id_config.cache_column
-        end
-        attr_protected :cached_slug
-      end
-    end
-
-  end
-end
-
-require "friendly_id/active_record_adapter/relation"
-require "friendly_id/active_record_adapter/configuration"
-require "friendly_id/active_record_adapter/simple_model"
-require "friendly_id/active_record_adapter/slugged_model"
-require "friendly_id/active_record_adapter/slug"
-require "friendly_id/active_record_adapter/tasks"
-
-module ActiveRecord
-  class Base
-    extend FriendlyId::ActiveRecordAdapter
-  end
-
-  class Relation
-    alias find_one_without_friendly  find_one
-    alias find_some_without_friendly find_some
-    include FriendlyId::ActiveRecordAdapter::Relation
-  end
-end

data/lib/friendly_id/active_record_adapter/configuration.rb

@@ -1,68 +0,0 @@
-module FriendlyId
-
-  module ActiveRecordAdapter
-
-    # Extends FriendlyId::Configuration with some implementation details and
-    # features specific to ActiveRecord.
-    class Configuration < FriendlyId::Configuration
-
-      # The column used to cache the friendly_id string. If no column is specified,
-      # FriendlyId will look for a column named +cached_slug+ and use it automatically
-      # if it exists. If for some reason you have a column named +cached_slug+
-      # but don't want FriendlyId to modify it, pass the option
-      # +:cache_column => false+ to {FriendlyId::ActiveRecordAdapter#has_friendly_id has_friendly_id}.
-      attr_accessor :cache_column
-
-      # An array of classes for which the configured class serves as a
-      # FriendlyId scope.
-      attr_reader :child_scopes
-
-      attr_reader :custom_cache_column
-
-      def cache_column
-        return @cache_column if defined?(@cache_column)
-        @cache_column = autodiscover_cache_column
-      end
-
-      def cache_column?
-        !! cache_column
-      end
-
-      def cache_column=(cache_column)
-        @cache_column = cache_column
-        @custom_cache_column = cache_column
-      end
-
-      def child_scopes
-        @child_scopes ||= associated_friendly_classes.select do |klass|
-          klass.friendly_id_config.scopes_over?(configured_class)
-        end
-      end
-
-      def custom_cache_column?
-        !! custom_cache_column
-      end
-
-      def scope_for(record)
-        return nil unless scope?
-        record.send(scope).nil? ? nil : record.send(scope).to_param 
-      end
-
-      def scopes_over?(klass)
-        scope? && scope == klass.to_s.underscore.to_sym
-      end
-
-      private
-
-      def autodiscover_cache_column
-        :cached_slug if configured_class.columns.any? { |column| column.name == 'cached_slug' }
-      end
-
-      def associated_friendly_classes
-        configured_class.reflect_on_all_associations.compact.select { |assoc|
-          !assoc.options[:polymorphic] && assoc.klass.respond_to?(:friendly_id_config)
-        }.map(&:klass)
-      end
-    end
-  end
-end

data/lib/friendly_id/active_record_adapter/relation.rb

@@ -1,173 +0,0 @@
-module FriendlyId
-  module ActiveRecordAdapter
-    module Relation
-
-      class Find
-        extend Forwardable
-
-        attr :relation
-        attr :ids
-        alias id ids
-
-        def_delegators :relation, :arel, :arel_table, :klass, :limit_value, :offset_value, :where
-        def_delegators :klass, :connection, :friendly_id_config
-        alias fc friendly_id_config
-
-        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
-            find_one_without_slug
-          end
-        end
-
-        def find_some
-          ids = @ids.compact.uniq.map {|id| id.respond_to?(:friendly_id_config) ? id.id : 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
-
-        private
-
-        def assign_status
-          return unless @result
-          name, seq = id.to_s.parse_friendly_id
-          @result.friendly_id_status.name = name
-          @result.friendly_id_status.sequence = seq if fc.use_slugs?
-          @result
-        end
-
-        def find_one_without_slug
-          @result = where(fc.column => id).first
-          assign_status
-        end
-
-        def find_one_with_cached_slug
-          @result = where(fc.cache_column => id).first
-          assign_status or find_one_with_slug
-        end
-
-        def find_one_with_slug
-          sluggable_ids = sluggable_ids_for([id])
-
-          if sluggable_ids.size > 1 && fc.scope?
-            return relation.where(primary_key_column.in(sluggable_ids)).first
-          end
-
-          sluggable_id = sluggable_ids.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
-
-        def friendly_records(friendly_ids, unfriendly_ids)
-          use_slugs_table =  fc.use_slugs? && (!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 = primary_key_column.in unfriendly_ids
-          if friendly_ids.present? && unfriendly_ids.present?
-            where(friendly.or(unfriendly))
-          else
-            where(friendly)
-          end
-        end
-
-        def find_some_using_slug(friendly_ids, unfriendly_ids)
-          ids = [unfriendly_ids + sluggable_ids_for(friendly_ids)].flatten.uniq
-          where(primary_key_column.in(ids))
-        end
-
-        def sluggable_ids_for(ids)
-          return [] if ids.empty?
-          fragment = "(slugs.sluggable_type = %s AND slugs.name = %s AND slugs.sequence = %d)"
-          conditions = ids.inject(nil) do |clause, id|
-            name, seq = id.parse_friendly_id
-            string = fragment % [connection.quote(klass.base_class.name), connection.quote(name), seq]
-            clause ? clause + " OR #{string}" : string
-          end
-          sql = "SELECT sluggable_id FROM slugs WHERE (%s)" % conditions
-          connection.select_values sql
-        end
-
-        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
-
-        def primary_key_column
-          if relation.primary_key.is_a?(String)
-            arel_table[relation.primary_key]
-          else
-            arel_table[relation.primary_key.name]
-          end
-        end
-      end
-
-      def apply_finder_options(options)
-        if options[:scope]
-          raise "The :scope finder option has been removed from FriendlyId 3.2.0 " +
-            "https://github.com/norman/friendly_id/issues#issue/88"
-        end
-        super
-      end
-
-      protected
-
-      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
-        end
-      end
-
-      def find_some(ids)
-        return super unless klass.uses_friendly_id?
-        Find.new(self, ids).find_some or begin
-          # A change in Arel 2.0.x causes find_some to fail with arrays of instances; not sure why.
-          # This is an emergency, temporary fix.
-          ids = ids.map {|id| (id.respond_to?(:friendly_id_config) ? id.id : id)}
-          super
-        end
-      end
-    end
-  end
-end

data/lib/friendly_id/active_record_adapter/simple_model.rb

@@ -1,62 +0,0 @@
-module FriendlyId
-  module ActiveRecordAdapter
-
-    module SimpleModel
-
-      def self.included(base)
-        base.class_eval do
-          column = friendly_id_config.column
-          validate :validate_friendly_id, :unless => :skip_friendly_id_validations
-          validates_presence_of column, :unless => :skip_friendly_id_validations
-          validates_length_of column, :maximum => friendly_id_config.max_length, :unless => :skip_friendly_id_validations
-          after_update :update_scopes
-        end
-      end
-
-      # Get the {FriendlyId::Status} after the find has been performed.
-      def friendly_id_status
-        @friendly_id_status ||= Status.new :record => self
-      end
-
-      # Returns the friendly_id.
-      def friendly_id
-        send friendly_id_config.column
-      end
-      alias best_id friendly_id
-
-      # Returns the friendly id, or if none is available, the numeric id.
-      def to_param
-        (friendly_id || id).to_s
-      end
-
-      private
-
-      # The old and new values for the friendly_id column.
-      def friendly_id_changes
-        changes[friendly_id_config.column.to_s]
-      end
-
-      # Update the slugs for any model that is using this model as its
-      # FriendlyId scope.
-      def update_scopes
-        if changes = friendly_id_changes
-          friendly_id_config.child_scopes.each do |klass|
-            Slug.update_all "scope = '#{changes[1]}'", ["sluggable_type = ? AND scope = ?", klass.to_s, changes[0]]
-          end
-        end
-      end
-
-      def skip_friendly_id_validations
-        friendly_id.nil? && friendly_id_config.allow_nil?
-      end
-
-      def validate_friendly_id
-        if result = friendly_id_config.reserved_error_message(friendly_id)
-          self.errors.add(*result)
-          return false
-        end
-      end
-
-    end
-  end
-end

data/lib/friendly_id/active_record_adapter/slug.rb

@@ -1,84 +0,0 @@
-# A Slug is a unique, human-friendly identifier for an ActiveRecord.
-class Slug < ::ActiveRecord::Base
-  attr_writer :sluggable
-  attr_accessible :name, :scope, :sluggable, :sequence
-  table_name = "slugs"
-  before_save :enable_name_reversion, :set_sequence
-  validate :validate_name
-  scope :similar_to, lambda {|slug| {:conditions => {
-        :name           => slug.name,
-        :scope          => slug.scope,
-        :sluggable_type => slug.sluggable_type
-      },
-      :order => "sequence ASC"
-    }
-  }
-
-  def sluggable
-    sluggable_id && !@sluggable and begin
-      klass = sluggable_type.constantize
-      klass.send(:with_exclusive_scope) do
-        @sluggable = klass.find(sluggable_id)
-      end
-    end
-    @sluggable
-  end
-
-  # Whether this slug is the most recent of its owner's slugs.
-  def current?
-    sluggable.slug == self
-  end
-
-  def outdated?
-    !current?
-  end
-
-  def to_friendly_id
-    sequence > 1 ? friendly_id_with_sequence : name
-  end
-
-  # Raise a FriendlyId::SlugGenerationError if the slug name is blank.
-  def validate_name
-    if name.blank?
-      raise FriendlyId::BlankError.new("slug.name can not be blank.")
-    end
-  end
-
-  def save(*args)
-    persisted? && !scope_changed? ? true : super
-  end
-
-  def save!(*args)
-    persisted? && !scope_changed? ? true : super
-  end
-
-  private
-
-  # If we're renaming back to a previously used friendly_id, delete the
-  # slug so that we can recycle the name without having to use a sequence.
-  def enable_name_reversion
-    sluggable.slugs.find_all_by_name_and_scope(name, scope).each { |slug| slug.destroy }
-  end
-
-  def friendly_id_with_sequence
-    "#{name}#{separator}#{sequence}"
-  end
-
-  def similar_to_other_slugs?
-    !similar_slugs.empty?
-  end
-
-  def similar_slugs
-    self.class.similar_to(self)
-  end
-
-  def separator
-    sluggable.friendly_id_config.sequence_separator
-  end
-
-  def set_sequence
-    return unless new_record?
-    self.sequence = similar_slugs.last.sequence.succ if similar_to_other_slugs?
-  end
-
-end

data/lib/friendly_id/active_record_adapter/slugged_model.rb

@@ -1,110 +0,0 @@
-module FriendlyId
-  module ActiveRecordAdapter
-    module SluggedModel
-
-      def self.included(base)
-        base.class_eval do
-          has_many :slugs, :order => 'id DESC', :as => :sluggable, :dependent => :destroy
-          has_one :slug, :order => 'id DESC', :as => :sluggable, :dependent => :nullify
-          before_save :build_a_slug
-          after_save :set_slug_cache
-          after_update :update_scope
-          after_update :update_dependent_scopes
-          protect_friendly_id_attributes
-        end
-      end
-
-      include FriendlyId::Slugged::Model
-
-      def find_slug(name, sequence)
-        slugs.find_by_name_and_sequence(name, sequence)
-      end
-
-      # Returns the friendly id, or if none is available, the numeric id. Note that this
-      # method will use the cached_slug value if present, unlike {#friendly_id}.
-      def to_param
-        friendly_id_config.cache_column ? to_param_from_cache : to_param_from_slug
-      end
-
-      private
-
-      def scope_changed?
-        friendly_id_config.scope? && send(friendly_id_config.scope).to_param != slug.scope
-      end
-
-      # Respond with the cached value if available.
-      def to_param_from_cache
-        read_attribute(friendly_id_config.cache_column) || id.to_s
-      end
-
-      # Respond with the slugged value if available.
-      def to_param_from_slug
-        slug? ? slug.to_friendly_id : id.to_s
-      end
-
-      # Build the new slug using the generated friendly id.
-      def build_a_slug
-        return unless new_slug_needed?
-        self.slug = slugs.build :name => slug_text.to_s, :scope => friendly_id_config.scope_for(self),
-          :sluggable => self
-        @new_friendly_id = self.slug.to_friendly_id
-      end
-
-      # Reset the cached friendly_id?
-      def new_cache_needed?
-        uses_slug_cache? && slug? && send(friendly_id_config.cache_column) != slug.to_friendly_id
-      end
-
-      # Reset the cached friendly_id.
-      def set_slug_cache
-        if new_cache_needed?
-          begin
-            send "#{friendly_id_config.cache_column}=", slug.to_friendly_id
-            update_without_callbacks
-          rescue ActiveRecord::StaleObjectError
-            reload
-            retry
-          end
-        end
-      end
-
-      def update_scope
-        return unless slug && scope_changed?
-        self.class.transaction do
-          slug.scope = send(friendly_id_config.scope).to_param
-          similar = Slug.similar_to(slug)
-          if !similar.empty?
-            slug.sequence = similar.first.sequence.succ
-          end
-          slug.save!
-        end
-      end
-
-      # Update the slugs for any model that is using this model as its
-      # FriendlyId scope.
-      def update_dependent_scopes
-        return unless friendly_id_config.class.scopes_used?
-        if slugs(true).size > 1 && @new_friendly_id
-          friendly_id_config.child_scopes.each do |klass|
-            Slug.update_all "scope = '#{@new_friendly_id}'", ["sluggable_type = ? AND scope = ?",
-              klass.to_s, slugs.second.to_friendly_id]
-          end
-        end
-      end
-
-      # Does the model use slug caching?
-      def uses_slug_cache?
-        friendly_id_config.cache_column?
-      end
-
-      # This method was removed in ActiveRecord 3.0.
-      if !ActiveRecord::Base.private_method_defined? :update_without_callbacks
-        def update_without_callbacks
-          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

data/lib/friendly_id/active_record_adapter/tasks.rb

@@ -1,72 +0,0 @@
-module FriendlyId
-  class TaskRunner
-
-    extend Forwardable
-
-    attr_accessor :days
-    attr_accessor :klass
-    attr_accessor :task_options
-
-    def_delegators :klass, :find, :friendly_id_config, :update_all
-
-    OLD_SLUG_DAYS = 45
-
-    def initialize(&block)
-      self.klass = ENV["MODEL"]
-      self.days  = ENV["DAYS"]
-    end
-
-    def days=(days)
-      @days ||= days.blank? ? OLD_SLUG_DAYS : days.to_i
-    end
-
-    def klass=(klass)
-      @klass ||= klass.to_s.classify.constantize unless klass.blank?
-    end
-
-    def make_slugs
-      validate_uses_slugs
-      options = {
-        :include => :slug,
-        :limit   => (ENV["LIMIT"] || 100).to_i,
-        :offset  => 0,
-        :order   => ENV["ORDER"] || "#{klass.table_name}.#{klass.primary_key} ASC",
-      }.merge(task_options || {})
-
-      while records = find(:all, options) do
-        break if records.size == 0
-        records.each do |record|
-          record.save(:validate => false) unless record.slug?
-          yield(record) if block_given?
-        end
-        options[:offset] += options[:limit]
-      end
-    end
-
-    def delete_slugs
-      validate_uses_slugs
-      Slug.destroy_all(["sluggable_type = ?", klass.to_s])
-      if column = friendly_id_config.cache_column
-        update_all("#{column} = NULL")
-      end
-    end
-
-    def delete_old_slugs
-      conditions = ["created_at < ?", DateTime.now - days]
-      if klass
-        conditions[0] << " AND sluggable_type = ?"
-        conditions << klass.to_s
-      end
-      Slug.all(:conditions => conditions).select(&:outdated?).map(&:destroy)
-    end
-
-    def validate_uses_slugs
-      (raise "You need to pass a MODEL=<model name> argument to rake") if klass.blank?
-      unless friendly_id_config.use_slug?
-        raise "Class '%s' doesn't use slugs" % klass.to_s
-      end
-    rescue NoMethodError
-      raise "Class '%s' doesn't use FriendlyId" % klass.to_s
-    end
-  end
-end

data/lib/friendly_id/datamapper.rb

@@ -1,5 +0,0 @@
-begin
-  require 'friendly_id_datamapper'
-rescue LoadError
-  raise "To use FriendlyId's DataMapper adapter, please `gem install friendly_id_datamapper`"
-end

data/lib/friendly_id/railtie.rb

@@ -1,22 +0,0 @@
-module FriendlyId
-  class Railtie < Rails::Railtie
-
-    initializer "friendly_id.configure_rails_initialization" do |app|
-      # Experimental Sequel support. See: http://github.com/norman/friendly_id_sequel
-      if app.config.generators.rails[:orm] == :sequel
-        require "friendly_id/sequel"
-      # Experimental DataMapper support. See: http://github.com/myabc/friendly_id_datamapper
-      elsif app.config.generators.rails[:orm] == :data_mapper
-        require 'friendly_id/datamapper'
-      else
-        # AR is the default.
-        require "friendly_id/active_record"
-      end
-    end
-
-    rake_tasks do
-      load "tasks/friendly_id.rake"
-    end
-
-  end
-end

data/lib/friendly_id/sequel.rb

@@ -1,5 +0,0 @@
-begin
-  require "friendly_id_sequel"
-rescue LoadError
-  raise "To use FriendlyId's Sequel adapter, please `gem install friendly_id_sequel`"
-end

data/lib/friendly_id/slug_string.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-module FriendlyId
-
-  class SlugString < Babosa::Identifier
-    # Normalize the string for a given {FriendlyId::Configuration}.
-    # @param config [FriendlyId::Configuration]
-    # @return String
-    def normalize_for!(config)
-      normalize!(config.babosa_options)
-    end
-
-    # Validate that the slug string is not blank or reserved, and truncate
-    # it to the max length if necessary.
-    # @param config [FriendlyId::Configuration]
-    # @return String
-    # @raise FriendlyId::BlankError
-    # @raise FriendlyId::ReservedError
-    def validate_for!(config)
-      truncate_bytes!(config.max_length)
-      raise FriendlyId::BlankError if empty?
-      raise FriendlyId::ReservedError if config.reserved?(self)
-      self
-    end
-  end
-end

data/lib/friendly_id/status.rb

@@ -1,35 +0,0 @@
-module FriendlyId
-
-  # FriendlyId::Status presents information about the status of the
-  # id that was used to find the model. This class can be useful for figuring
-  # out when to redirect to a new URL.
-  class Status
-
-    # The id or name used as the finder argument
-    attr_accessor :name
-
-    # The found result, if any
-    attr_accessor :record
-
-    def initialize(options={})
-      options.each {|key, value| self.send("#{key}=".to_sym, value)}
-    end
-
-    # Did the find operation use a friendly id?
-    def friendly?
-      !! name
-    end
-
-    # Did the find operation use a numeric id?
-    def numeric?
-      !friendly?
-    end
-
-    # Did the find operation use the best available id?
-    def best?
-      record.friendly_id ? friendly? : true
-    end
-
-  end
-
-end

data/lib/friendly_id/test.rb

@@ -1,364 +0,0 @@
-# encoding: utf-8
-Module.send :include, Module.new {
-  def test(name, &block)
-    define_method("test_#{name.gsub(/[^a-z0-9]/i, "_")}".to_sym, &block)
-  end
-  alias :should :test
-}
-
-module FriendlyId
-  module Test
-
-    # Tests for any model that implements FriendlyId. Any test that tests model
-    # features should include this module.
-    module Generic
-
-      def setup
-        klass.send delete_all_method
-      end
-
-      def teardown
-        klass.send delete_all_method
-      end
-
-      def instance
-        raise NotImplementedError
-      end
-
-      def klass
-        raise NotImplementedError
-      end
-
-      def other_class
-        raise NotImplementedError
-      end
-
-      def find_method
-        raise NotImplementedError
-      end
-
-      def create_method
-        raise NotImplementedError
-      end
-
-      def update_method
-        raise NotImplementedError
-      end
-
-      def validation_exceptions
-        return RuntimeError
-      end
-
-      def assert_validation_error
-        if validation_exceptions
-          assert_raise(*[validation_exceptions].flatten) do
-            yield
-          end
-        else  # DataMapper does not raise Validation Errors
-          i = yield
-          if i.kind_of?(TrueClass) || i.kind_of?(FalseClass)
-            assert !i
-          else
-            instance = i
-            assert !instance.errors.empty?
-          end
-        end
-      end
-
-      test "models should have a friendly id config" do
-        assert_not_nil klass.friendly_id_config
-      end
-
-      test "instances should have a friendly id by default" do
-        assert_not_nil instance.friendly_id
-      end
-
-      test "instances should have a friendly id status" do
-        assert_not_nil instance.friendly_id_status
-      end
-
-      test "instances should be findable by their friendly id" do
-        assert_equal instance, klass.send(find_method, instance.friendly_id)
-      end
-
-      test "instances should be findable by their numeric id as an integer" do
-        assert_equal instance, klass.send(find_method, instance.id.to_i)
-      end
-
-      test "instances should be findable by their numeric id as a string" do
-        assert_equal instance, klass.send(find_method, instance.id.to_s)
-      end
-
-      test "instances should be findable by a numeric friendly_id" do
-        instance = klass.send(create_method, :name => "206")
-        assert_equal instance, klass.send(find_method, "206")
-      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")
-        end
-      end
-
-      test "creation should raise an error if the friendly_id text is an empty string" do
-        assert_validation_error do
-          klass.send(create_method, :name => "")
-        end
-      end
-
-      test "creation should raise an error if the friendly_id text is a blank string" do
-        assert_validation_error do
-          klass.send(create_method, :name => "   ")
-        end
-      end
-
-      test "creation should raise an error if the friendly_id text is nil and allow_nil is false" do
-        assert_validation_error do
-          klass.send(create_method, :name => nil)
-        end
-      end
-
-      test "creation should succeed if the friendly_id text is nil and allow_nil is true" do
-        klass.friendly_id_config.stubs(:allow_nil?).returns(true)
-        assert klass.send(create_method, :name => nil)
-      end
-
-      test "creation should succeed if the friendly_id text is empty and allow_nil is true" do
-        klass.friendly_id_config.stubs(:allow_nil?).returns(true)
-        begin
-          assert klass.send(create_method, :name => "")
-        rescue ActiveRecord::RecordInvalid => e
-          raise unless e.message =~ /Name can't be blank/ # Test not applicable in this case
-        end
-      end
-
-      test "creation should succeed if the friendly_id text converts to empty and allow_nil is true" do
-        klass.friendly_id_config.stubs(:allow_nil?).returns(true)
-        assert klass.send(create_method, :name => "*")
-      end
-
-      test "should allow the same friendly_id across models" do
-        other_instance = other_class.send(create_method, :name => instance.name)
-        assert_equal other_instance.friendly_id, instance.friendly_id
-      end
-
-      test "reserved words can be specified as a regular expression" do
-        klass.friendly_id_config.stubs(:reserved_words).returns(/jo/)
-        assert_validation_error do
-          klass.send(create_method, :name => "joe")
-        end
-      end
-
-      test "should not raise reserved error unless regexp matches" do
-        klass.friendly_id_config.stubs(:reserved_words).returns(/ddsadad/)
-        assert_nothing_raised do
-          klass.send(create_method, :name => "joe")
-        end
-      end
-
-    end
-
-    module Simple
-
-      test "should allow friendly_id to be nillable if allow_nil is true" do
-        klass.friendly_id_config.stubs(:allow_nil?).returns(true)
-        instance = klass.send(create_method, :name => "hello")
-        assert instance.friendly_id
-        instance.name = nil
-        assert instance.send(save_method)
-      end
-
-    end
-
-    # Tests for any model that implements slugs.
-    module Slugged
-
-      test "should have a slug" do
-        assert_not_nil instance.slug
-      end
-
-      test "should not make a new slug unless the friendly_id method value has changed" do
-        instance.note = instance.note.to_s << " updated"
-        instance.send save_method
-        assert_equal 1, instance.slugs.size
-      end
-
-      test "should make a new slug if the friendly_id method value has changed" do
-        instance.name = "Changed title"
-        instance.send save_method
-        slugs = if instance.slugs.respond_to?(:reload)
-          instance.slugs.reload
-        else
-          instance.slugs(true)
-        end
-        assert_equal 2, slugs.size
-      end
-
-      test "should be able to reuse an old friendly_id without incrementing the sequence" do
-        old_title = instance.name
-        old_friendly_id = instance.friendly_id
-        instance.name = "A changed title"
-        instance.send save_method
-        instance.name = old_title
-        instance.send save_method
-        assert_equal old_friendly_id, instance.friendly_id
-      end
-
-      test "should increment the slug sequence for duplicate friendly ids" do
-        instance2 = klass.send(create_method, :name => instance.name)
-        assert_match(/2\z/, instance2.friendly_id)
-      end
-
-      test "should find instance with a sequenced friendly_id" do
-        instance2 = klass.send(create_method, :name => instance.name)
-        assert_equal instance2, klass.send(find_method, instance2.friendly_id)
-      end
-
-      test "should indicate correct status when found with a sequence" do
-        instance2 = klass.send(create_method, :name => instance.name)
-        instance2 = klass.send(find_method, instance2.friendly_id)
-        assert instance2.friendly_id_status.best?
-      end
-
-      test "should indicate correct status when found by a numeric friendly_id" do
-        instance = klass.send(create_method, :name => "100")
-        instance2 = klass.send(find_method, "100")
-        assert instance2.friendly_id_status.best?, "status expected to be best but isn't."
-        assert instance2.friendly_id_status.current?, "status expected to be current but isn't."
-      end
-
-      test "should remain findable by previous slugs" do
-        old_friendly_id = instance.friendly_id
-        instance.name = "#{old_friendly_id} updated"
-        instance.send(save_method)
-        assert_not_equal old_friendly_id, instance.friendly_id
-        assert_equal instance, klass.send(find_method, old_friendly_id)
-      end
-
-      test "should not create a slug when allow_nil is true and friendy_id text is blank" do
-        klass.friendly_id_config.stubs(:allow_nil?).returns(true)
-        instance = klass.send(create_method, :name => nil)
-        assert_nil instance.slug
-      end
-
-      test "should not allow friendly_id to be nillable even if allow_nil is true" do
-        klass.friendly_id_config.stubs(:allow_nil?).returns(true)
-        instance = klass.send(create_method, :name => "hello")
-        assert instance.friendly_id
-        instance.name = nil
-        assert_validation_error do
-          instance.send(save_method)
-        end
-      end
-
-      test "should approximate ascii if configured" do
-        klass.friendly_id_config.stubs(:approximate_ascii?).returns(true)
-        instance = klass.send(create_method, :name => "Cañón")
-        assert_equal "canon", instance.friendly_id
-      end
-
-      test "should approximate ascii with options if configured" do
-        klass.friendly_id_config.stubs(:approximate_ascii?).returns(true)
-        klass.friendly_id_config.stubs(:ascii_approximation_options).returns(:spanish)
-        instance = klass.send(create_method, :name => "Cañón")
-        assert_equal "canion", instance.friendly_id
-      end
-    end
-
-    # Tests for FriendlyId::Status.
-    module Status
-
-      test "should default to not friendly" do
-        assert !status.friendly?
-      end
-
-      test "should default to numeric" do
-        assert status.numeric?
-      end
-
-    end
-
-    # Tests for FriendlyId::Status for a model that uses slugs.
-    module SluggedStatus
-
-      test "should be friendly if slug is set" do
-        status.slug = Slug.new
-        assert status.friendly?
-      end
-
-      test "should be friendly if name is set" do
-        status.name = "name"
-        assert status.friendly?
-      end
-
-      test "should be current if current slug is set" do
-        status.slug = instance.slug
-        assert status.current?
-      end
-
-      test "should not be current if non-current slug is set" do
-        status.slug = Slug.new(:sluggable => instance)
-        assert !status.current?
-      end
-
-      test "should be best if it is current" do
-        status.slug = instance.slug
-        assert status.best?
-      end
-
-      test "should be best if it is numeric, but record has no slug" do
-        instance.slugs = []
-        instance.slug = nil
-        assert status.best?
-      end
-
-      [:record, :name].each do |symbol|
-        test "should have #{symbol} after find using friendly_id" do
-          instance2 = klass.send(find_method, instance.friendly_id)
-          assert_not_nil instance2.friendly_id_status.send(symbol)
-        end
-      end
-
-      def status
-        @status ||= instance.friendly_id_status
-      end
-
-      def klass
-        raise NotImplementedError
-      end
-
-      def instance
-        raise NotImplementedError
-      end
-
-    end
-
-    # Tests for models to ensure that they properly implement using the
-    # +normalize_friendly_id+ method to allow developers to hook into the
-    # slug string generation.
-    module CustomNormalizer
-
-      test "should invoke the custom normalizer" do
-        assert_equal "JOE SCHMOE", klass.send(create_method, :name => "Joe Schmoe").friendly_id
-      end
-
-      test "should respect the max_length option" do
-        klass.friendly_id_config.stubs(:max_length).returns(3)
-        assert_equal "JOE", klass.send(create_method, :name => "Joe Schmoe").friendly_id
-      end
-
-      test "should raise an error if the friendly_id text is reserved" do
-        klass.friendly_id_config.stubs(:reserved_words).returns(["JOE"])
-        if validation_exceptions
-          assert_raise(*[validation_exceptions].flatten) do
-            klass.send(create_method, :name => "Joe")
-          end
-        else  # DataMapper does not raise Validation Errors
-          instance = klass.send(create_method, :name => "Joe")
-          assert !instance.errors.empty?
-        end
-      end
-
-    end
-  end
-end

data/lib/friendly_id/version.rb

@@ -1,9 +0,0 @@
-module FriendlyId
-  module Version
-    MAJOR = 3
-    MINOR = 3
-    TINY  = 0
-    BUILD = 'rc2'
-    STRING = [MAJOR, MINOR, TINY, BUILD].compact.join('.')
-  end
-end