friendly_id4 4.0.0.beta6 → 4.0.0.pre

data/lib/friendly_id/scoped.rb

@@ -2,130 +2,31 @@ require "friendly_id/slugged"
 
 module FriendlyId
 
-=begin
-This module allows FriendlyId to generate unique slugs within a scope.
-
-This allows, for example, two restaurants in different cities to have the slug
-+joes-diner+:
-
-    class Restaurant < ActiveRecord::Base
-      extend FriendlyId
-      belongs_to :city
-      friendly_id :name, :use => :scoped, :scope => :city
-    end
-
-    class City < ActiveRecord::Base
-      extend FriendlyId
-      has_many :restaurants
-      friendly_id :name, :use => :slugged
-    end
-
-    City.find("seattle").restaurants.find("joes-diner")
-    City.find("chicago").restaurants.find("joes-diner")
-
-Without :scoped in this case, one of the restaurants would have the slug
-+joes-diner+ and the other would have +joes-diner--2+.
-
-The value for the +:scope+ option can be the name of a +belongs_to+ relation, or
-a column.
-
-== Tips For Working With Scoped Slugs
-
-=== Finding Records by Friendly ID
-
-If you are using scopes your friendly ids may not be unique, so a simple find
-like
-
-    Restaurant.find("joes-diner")
-
-may return the wrong record. In these cases it's best to query through the
-relation:
-
-    @city.restaurants.find("joes-diner")
-
-Alternatively, you could pass the scope value as a query parameter:
-
-    Restaurant.find("joes-diner").where(:city_id => @city.id)
-
-
-=== Finding All Records That Match a Scoped ID
-
-Query the slug column directly:
-
-    Restaurant.find_all_by_slug("joes-diner")
-
-=== Routes for Scoped Models
-
-Recall that FriendlyId is a database-centric library, and does not set up any
-routes for scoped models. You must do this yourself in your application. Here's
-an example of one way to set this up:
-
-    # in routes.rb
-    resources :cities do
-      resources :restaurants
-    end
-
-    # in views
-    <%= link_to 'Show', [@city, @restaurant] %>
-
-    # in controllers
-    @city = City.find(params[:city_id])
-    @restaurant = @city.restaurants.find(params[:id])
-
-    # URLs:
-    http://example.org/cities/seattle/restaurants/joes-diner
-    http://example.org/cities/chicago/restaurants/joes-diner
-
-=end
+  # This module adds scopes to in-table slugs.
   module Scoped
-
-
-    # Sets up behavior and configuration options for FriendlyId's scoped slugs
-    # feature.
-    def self.included(model_class)
-      model_class.instance_eval do
-        raise "FriendlyId::Scoped is incompatibe with FriendlyId::History" if self < History
-        include Slugged unless self < Slugged
-        friendly_id_config.class.send :include, Configuration
-        friendly_id_config.slug_sequencer_class.send :include, SlugSequencer
-      end
+    def self.included(klass)
+      klass.send :include, Slugged unless klass.include? Slugged
     end
+  end
 
-    # This module adds the +:scope+ configuration option to
-    # {FriendlyId::Configuration FriendlyId::Configuration}.
-    module Configuration
-
-      # Gets the scope value.
-      #
-      # When setting this value, the argument should be a symbol referencing a
-      # +belongs_to+ relation, or a column.
-      #
-      # @return Symbol The scope value
-      attr_accessor :scope
+  class SlugSequencer
+    alias conflict_without_scope conflict
 
-      # Gets the scope column.
-      #
-      # Checks to see if the +:scope+ option passed to
-      # {FriendlyId::Base#friendly_id} refers to a relation, and if so, returns
-      # the realtion's foreign key. Otherwise it assumes the option value was
-      # the name of column and returns it cast to a String.
-      #
-      # @return String The scope column
-      def scope_column
-        (model_class.reflections[@scope].try(:association_foreign_key) || @scope).to_s
-      end
+    def conflict_with_scope
+      column = friendly_id_config.scope_column
+      conflicts.where("#{column} = ?", sluggable.send(column)).first
     end
 
-    # This module overrides {FriendlyId::SlugSequencer#conflict} to consider
-    # scope, to avoid adding sequences to slugs under different scopes.
-    module SlugSequencer
+    def conflict
+      friendly_id_config.scope ? conflict_with_scope : conflict_without_scope
+    end
+  end
 
-      private
+  class Configuration
+    attr_accessor :scope
 
-      def conflict
-        column = friendly_id_config.scope_column
-        conflicts.where("#{column} = ?", sluggable.send(column)).first
-      end
+    def scope_column
+      klass.reflections[@scope].try(:association_foreign_key) || @scope.to_s
     end
   end
 end

data/lib/friendly_id/slugged.rb

@@ -1,221 +1,127 @@
-# encoding: utf-8
-require "friendly_id/slug_sequencer"
-
 module FriendlyId
-=begin
-This module adds in-table slugs to a model.
-
-Slugs are unique id strings that have been processed to remove or replace
-characters that a developer considers inconvenient for use in URLs. For example,
-blog applications typically use a post title to provide the basis of a search
-engine friendly URL:
-
-    "Gone With The Wind" -> "gone-with-the-wind"
-
-FriendlyId generates slugs from a method or column that you specify, and stores
-them in a field in your model. By default, this field must be named +:slug+,
-though you may change this using the
-{FriendlyId::Slugged::Configuration#slug_column slug_column} configuration
-option. You should add an index to this field. You may also wish to constrain it
-to NOT NULL, but this depends on your app's behavior and requirements.
-
-=== Example Setup
-
-    # your model
-    class Post < ActiveRecord::Base
-      extend FriendlyId
-      friendly_id :title, :use => :slugged
-      validates_presence_of :title, :slug, :body
-    end
-
-    # a migration
-    class CreatePosts < ActiveRecord::Migration
-      def self.up
-        create_table :posts do |t|
-          t.string :title, :null => false
-          t.string :slug, :null => false
-          t.text :body
-        end
-
-        add_index :posts, :slug, :unique => true
-      end
-
-      def self.down
-        drop_table :posts
-      end
-    end
 
-=== Slug Format
-
-By default, FriendlyId uses Active Support's
-paramaterize[http://api.rubyonrails.org/classes/ActiveSupport/Inflector.html#method-i-parameterize]
-method to create slugs. This method will intelligently replace spaces with
-dashes, and Unicode Latin characters with ASCII approximations:
-
-  movie = Movie.create! :title => "Der Preis fürs Überleben"
-  movie.slug #=> "der-preis-furs-uberleben"
+  # This module adds in-table slugs to an ActiveRecord model.
+  module Slugged
 
-==== Slug Uniqueness
+    # @NOTE AR-specific code here
+    def self.included(klass)
+      klass.before_save :set_slug
+      klass.friendly_id_config.use_slugs = true
+    end
 
-When you try to insert a record that would generate a duplicate friendly id,
-FriendlyId will append a sequence to the generated slug to ensure uniqueness:
+    # @NOTE AS-specific code here
+    def normalize_friendly_id(value)
+      value.to_s.parameterize
+    end
 
-  car = Car.create :title => "Peugot 206"
-  car2 = Car.create :title => "Peugot 206"
+    private
 
-  car.friendly_id #=> "peugot-206"
-  car2.friendly_id #=> "peugot-206--2"
+    def set_slug
+      send "#{friendly_id_config.slug_column}=", SlugSequencer.new(self).to_s
+    end
+  end
 
-==== Changing the Slug Sequence Separator
+  class Configuration
+    attr_writer :slug_column, :sequence_separator, :use_slugs
 
-You can do this with the {Slugged::Configuration#sequence_separator
-sequence_separator} configuration option.
+    DEFAULTS[:slug_column]        = 'slug'
+    DEFAULTS[:sequence_separator] = '--'
 
-==== Column or Method?
+    def query_field
+      use_slugs? ? slug_column : base
+    end
 
-FriendlyId always uses a method as the basis of the slug text - not a column. It
-first glance, this may sound confusing, but remember that Active Record provides
-methods for each column in a model's associated table, and that's what
-FriendlyId uses.
+    def sequence_separator
+      @sequence_separator || DEFAULTS[:sequence_separator]
+    end
 
-Here's an example of a class that uses a custom method to generate the slug:
+    def slug_column
+      @slug_column || DEFAULTS[:slug_column]
+    end
 
-  class Person < ActiveRecord::Base
-    friendly_id :name_and_location
-    def name_and_location
-      "#{name} from #{location}"
+    def use_slugs?
+      @use_slugs
     end
   end
 
-  bob = Person.create! :name => "Bob Smith", :location => "New York City"
-  bob.friendly_id #=> "bob-smith-from-new-york-city"
+  # This class offers functionality to check slug strings for uniqueness and,
+  # if necessary, append a sequence to ensure it.
+  class SlugSequencer
+    attr_reader :sluggable
 
-==== Providing Your Own Slug Processing Method
+    def initialize(sluggable)
+      @sluggable = sluggable
+    end
 
-You can override {Slugged#normalize_friendly_id} in your model for total
-control over the slug format.
+    def base
+      sluggable.send friendly_id_config.base
+    end
 
-==== Locale-specific Transliterations
+    def changed?
+      base != current_friendly_id.try(:sub, /--[\d]*\z/, '')
+    end
 
-Active Support's +parameterize+ uses
-transliterate[http://api.rubyonrails.org/classes/ActiveSupport/Inflector.html#method-i-transliterate],
-which in turn can use I18n's transliteration rules to consider the current
-locale when replacing Latin characters:
+    def column
+      friendly_id_config.query_field
+    end
 
-  # config/locales/de.yml
-  de:
-    i18n:
-      transliterate:
-        rule:
-          ü: "ue"
-          ö: "oe"
-          etc...
+    def conflict?
+      !! conflict
+    end
 
-  movie = Movie.create! :title => "Der Preis fürs Überleben"
-  movie.slug #=> "der-preis-fuers-ueberleben"
+    def conflict
+      unless defined? @conflict
+        @conflict = conflicts.first
+      end
+      @conflict
+    end
 
-This functionality was in fact taken from earlier versions of FriendlyId.
-=end
-  module Slugged
+    # @NOTE AR-specific code here
+    def conflicts
+      pkey  = sluggable.class.arel_table.primary_key.name
+      value = sluggable.send pkey
+      scope = sluggable.class.where("#{column} = ? OR #{column} LIKE ?", normalized, wildcard)
+      scope = scope.where("#{pkey} <> ?", value) unless sluggable.new_record?
+      scope = scope.order("#{column} DESC")
+    end
 
-    # Sets up behavior and configuration options for FriendlyId's slugging
-    # feature.
-    def self.included(model_class)
-      model_class.instance_eval do
-        friendly_id_config.class.send :include, Configuration
-        friendly_id_config.defaults[:slug_column]        ||= 'slug'
-        friendly_id_config.defaults[:sequence_separator] ||= '--'
-        friendly_id_config.slug_sequencer_class          ||= Class.new(SlugSequencer)
-        before_validation :set_slug
-      end
+    def current_friendly_id
+      sluggable.instance_variable_get(:@_current_friendly_id)
     end
 
-    # Process the given value to make it suitable for use as a slug.
-    #
-    # This method is not intended to be invoked directly; FriendlyId uses it
-    # internaly to process strings into slugs.
-    #
-    # However, if FriendlyId's default slug generation doesn't suite your needs,
-    # you can override this method in your model class to control exactly how
-    # slugs are generated.
-    #
-    # === Example
-    #
-    #   class Person < ActiveRecord::Base
-    #     friendly_id :name_and_location
-    #
-    #     def name_and_location
-    #       "#{name} from #{location}"
-    #     end
-    #
-    #     # Use default slug, but uupper case and with underscores
-    #     def normalize_friendly_id(string)
-    #       super.upcase.gsub("-", "_")
-    #     end
-    #   end
-    #
-    #   bob = Person.create! :name => "Bob Smith", :location => "New York City"
-    #   bob.friendly_id #=> "BOB_SMITH_FROM_NEW_YORK_CITY"
-    #
-    # === More Resources
-    #
-    # You might want to look into Babosa[https://github.com/norman/babosa],
-    # which is the slugging library used by FriendlyId prior to version 4, which
-    # offers some specialized functionality missing from Active Support.
-    #
-    # @param [#to_s] value The value used as the basis of the slug.
-    # @return The candidate slug text, without a sequence.
-    def normalize_friendly_id(value)
-      value.to_s.parameterize
+    def friendly_id_config
+      sluggable.friendly_id_config
     end
 
-    # Gets a new instance of the configured slug sequencing class.
-    #
-    # @see FriendlyId::SlugSequencer
-    def slug_sequencer
-      friendly_id_config.slug_sequencer_class.new(self)
+    def new_record?
+      sluggable.new_record?
     end
 
-    # Sets the slug.
-    def set_slug
-      send "#{friendly_id_config.slug_column}=", slug_sequencer.generate
+    def normalized
+      @normalized ||= sluggable.normalize_friendly_id(base)
     end
-    private :set_slug
 
-    # This module adds the +:slug_column+, and +:sequence_separator+, and
-    # +:slug_sequencer_class+ configuration options to
-    # {FriendlyId::Configuration FriendlyId::Configuration}.
-    module Configuration
-      attr_writer :slug_column, :sequence_separator
-      attr_accessor :slug_sequencer_class
+    def separator
+      friendly_id_config.sequence_separator
+    end
 
-      # Makes FriendlyId use the slug column for querying.
-      # @return String The slug column.
-      def query_field
-        slug_column
-      end
+    def next
+      sequence = conflict.slug.split(separator)[1].to_i
+      next_sequence = sequence == 0 ? 2 : sequence.next
+      "#{normalized}#{separator}#{next_sequence}"
+    end
 
-      # The string used to separate a slug base from a numeric sequence.
-      #
-      # By default, +--+ is used to separate the slug from the sequence.
-      # FriendlyId uses two dashes to distinguish sequences from slugs with
-      # numbers in their name.
-      #
-      # You can change the default separator by setting the
-      # {FriendlyId::Slugged::Configuration#sequence_separator
-      # sequence_separator} configuration option.
-      #
-      # For obvious reasons, you should avoid setting it to "+-+" unless you're
-      # sure you will never want to have a friendly id with a number in it.
-      # @return String The sequence separator string. Defaults to "+--+".
-      def sequence_separator
-        @sequence_separator or defaults[:sequence_separator]
+    def to_s
+      if changed? or new_record?
+        conflict? ? self.next : normalized
+      else
+        sluggable.friendly_id
       end
+    end
 
-      # The column that will be used to store the generated slug.
-      def slug_column
-        @slug_column or defaults[:slug_column]
-      end
+    def wildcard
+      "#{normalized}#{separator}%"
     end
   end
+
 end