friendly_id4 4.0.0.beta1

data/lib/friendly_id/history.rb

@@ -0,0 +1,27 @@
+require "friendly_id/slug"
+
+module FriendlyId
+  module History
+
+    def self.included(base)
+      base.class_eval do
+        include Slugged unless include? Slugged
+        extend  Finder
+        has_many :friendly_id_slugs, :as => :sluggable, :dependent => :destroy
+        before_save :build_friendly_id_slug, :if => lambda {|r| r.slug_sequencer.slug_changed?}
+      end
+    end
+
+    private
+
+    def build_friendly_id_slug
+      self.friendly_id_slugs.build :slug => friendly_id
+    end
+  end
+
+  module Finder
+    def find_by_friendly_id(*args)
+      where("friendly_id_slugs.slug = ?", args.shift).includes(:friendly_id_slugs).first(*args)
+    end
+  end
+end

data/lib/friendly_id/migration.rb

@@ -0,0 +1,17 @@
+class CreateFriendlyIdSlugs < ActiveRecord::Migration
+  def self.up
+    create_table :friendly_id_slugs do |t|
+      t.string   :slug,           :null => false
+      t.integer  :sluggable_id,   :null => false
+      t.string   :sluggable_type, :limit => 40
+      t.datetime :created_at
+    end
+    add_index :friendly_id_slugs, :sluggable_id
+    add_index :friendly_id_slugs, [:slug, :sluggable_type], :unique => true
+    add_index :friendly_id_slugs, :sluggable_type
+  end
+
+  def self.down
+    drop_table :friendly_id_slugs
+  end
+end

data/lib/friendly_id/model.rb

@@ -0,0 +1,22 @@
+module FriendlyId
+  # Instance methods that will be added to all classes using FriendlyId.
+  module Model
+
+    attr_reader :current_friendly_id
+
+    # Convenience method for accessing the class method of the same name.
+    def friendly_id_config
+      self.class.friendly_id_config
+    end
+
+    # Get the instance's friendly_id.
+    def friendly_id
+      send friendly_id_config.query_field
+    end
+
+    # Either the friendly_id, or the numeric id cast to a string.
+    def to_param
+      (friendly_id.present? ? friendly_id : id).to_s
+    end
+  end
+end

data/lib/friendly_id/object_utils.rb

@@ -0,0 +1,27 @@
+module FriendlyId
+  # Utility methods that are in Object because it's impossible to predict what
+  # kinds of objects get passed into FinderMethods#find_one and
+  # Model#normalize_friendly_id.
+  module ObjectUtils
+
+    # True is the id is definitely friendly, false if definitely unfriendly,
+    # else nil.
+    def friendly_id?
+      if kind_of?(Integer) or kind_of?(Symbol) or self.class.respond_to? :friendly_id_config
+        false
+      elsif to_i.to_s != to_s
+        true
+      end
+    end
+
+    # True if the id is definitely unfriendly, false if definitely friendly,
+    # else nil.
+    def unfriendly_id?
+      val = friendly_id? ; !val unless val.nil?
+    end
+  end
+end
+
+class Object
+  include FriendlyId::ObjectUtils
+end

data/lib/friendly_id/scoped.rb

@@ -0,0 +1,54 @@
+require "friendly_id/slugged"
+
+module FriendlyId
+
+  # This module adds scopes to in-table slugs. It's not loaded by default,
+  # so in order to active this feature you must include the module in your
+  # class.
+  #
+  # You can scope by an explicit column, or by a `belongs_to` relation.
+  #
+  # @example
+  #   class Restaurant < ActiveRecord::Base
+  #     belongs_to :city
+  #     include FriendlyId::Scoped
+  #     has_friendly_id :name, :scope => :city
+  #   end
+  module Scoped
+    def self.included(klass)
+      klass.send :include, Slugged unless klass.include? Slugged
+    end
+  end
+
+  class SlugSequencer
+    private
+
+    alias conflict_without_scope conflict
+
+    # Checks for naming conflicts, taking scopes into account.
+    # @return ActiveRecord::Base
+    def conflict_with_scope
+      column = friendly_id_config.scope_column
+      conflicts.where("#{column} = ?", sluggable.send(column)).first
+    end
+
+    def conflict
+      friendly_id_config.scope ? conflict_with_scope : conflict_without_scope
+    end
+  end
+
+  class Configuration
+    attr_accessor :scope
+
+    # Gets the scope column.
+    #
+    # Checks to see if the +:scope+ option passed to {#has_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
+      (klass.reflections[@scope].try(:association_foreign_key) || @scope).to_s
+    end
+  end
+end

data/lib/friendly_id/slug.rb

@@ -0,0 +1,3 @@
+class FriendlyIdSlug < ActiveRecord::Base
+  belongs_to :sluggable, :polymorphic => true
+end

data/lib/friendly_id/slug_sequencer.rb

@@ -0,0 +1,80 @@
+module FriendlyId
+  # This class offers functionality to check slug strings for uniqueness and,
+  # if necessary, append a sequence to ensure it.
+  class SlugSequencer
+    attr_reader :sluggable
+
+    def initialize(sluggable)
+      @sluggable = sluggable
+    end
+
+    def next
+      sequence = conflict.slug.split(separator)[1].to_i
+      next_sequence = sequence == 0 ? 2 : sequence.next
+      "#{normalized}#{separator}#{next_sequence}"
+    end
+
+    def generate
+      if slug_changed? or new_record?
+        conflict? ? self.next : normalized
+      else
+        sluggable.friendly_id
+      end
+    end
+
+    def slug_changed?
+      separator = Regexp.escape friendly_id_config.sequence_separator
+      base != sluggable.current_friendly_id.try(:sub, /#{separator}[\d]*\z/, '')
+    end
+
+    private
+
+    def base
+      sluggable.send friendly_id_config.base
+    end
+
+    def column
+      sluggable.connection.quote_column_name friendly_id_config.query_field
+    end
+
+    def conflict?
+      !! conflict
+    end
+
+    def conflict
+      unless defined? @conflict
+        @conflict = conflicts.first
+      end
+      @conflict
+    end
+
+    # @NOTE AR-specific code here
+    def conflicts
+      pkey  = sluggable.class.primary_key
+      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("LENGTH(#{column}) DESC, #{column} DESC")
+    end
+
+    def friendly_id_config
+      sluggable.friendly_id_config
+    end
+
+    def new_record?
+      sluggable.new_record?
+    end
+
+    def normalized
+      @normalized ||= sluggable.normalize_friendly_id(base)
+    end
+
+    def separator
+      friendly_id_config.sequence_separator
+    end
+
+    def wildcard
+      "#{normalized}#{separator}%"
+    end
+  end
+end

data/lib/friendly_id/slugged.rb

@@ -0,0 +1,51 @@
+require "friendly_id/slug_sequencer"
+
+module FriendlyId
+
+  # This module adds in-table slugs to an ActiveRecord model.
+  module Slugged
+
+    # @NOTE AR-specific code here
+    def self.included(klass)
+      klass.before_save :set_slug
+      klass.friendly_id_config.use_slugs = true
+    end
+
+    # @NOTE AS-specific code here
+    def normalize_friendly_id(value)
+      value.to_s.parameterize
+    end
+
+    def slug_sequencer
+      SlugSequencer.new(self)
+    end
+
+    private
+
+    def set_slug
+      send "#{friendly_id_config.slug_column}=", slug_sequencer.generate
+    end
+  end
+
+  class Configuration
+    attr :use_slugs
+    attr_writer :slug_column, :sequence_separator, :use_slugs
+
+    DEFAULTS[:slug_column]        = 'slug'
+    DEFAULTS[:sequence_separator] = '--'
+
+    undef query_field
+
+    def query_field
+      use_slugs ? slug_column : base
+    end
+
+    def sequence_separator
+      @sequence_separator ||= DEFAULTS[:sequence_separator]
+    end
+
+    def slug_column
+      @slug_column ||= DEFAULTS[:slug_column]
+    end
+  end
+end

data/lib/friendly_id/version.rb

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

data/lib/generators/friendly_id_generator.rb

@@ -0,0 +1,21 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+class FriendlyIdGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
+
+  source_root File.expand_path('../../friendly_id', __FILE__)
+
+  def copy_files(*args)
+    migration_template 'migration.rb', 'db/migrate/create_friendly_id_slugs.rb'
+  end
+
+  # Taken from ActiveRecord's migration generator
+  def self.next_migration_number(dirname) #:nodoc:
+    if ActiveRecord::Base.timestamped_migrations
+      Time.now.utc.strftime("%Y%m%d%H%M%S")
+    else
+      "%.3d" % (current_migration_number(dirname) + 1)
+    end
+  end
+end

data/test/config/mysql.yml

@@ -0,0 +1,5 @@
+adapter: mysql
+database: friendly_id_test
+username: root
+hostname: localhost
+encoding: utf8

data/test/config/postgres.yml

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

data/test/config/sqlite3.yml

@@ -0,0 +1,3 @@
+adapter: sqlite3
+database: ":memory:"
+encoding: utf8

data/test/core_test.rb

@@ -0,0 +1,43 @@
+require File.expand_path("../helper.rb", __FILE__)
+
+Author, Book = 2.times.map do
+  Class.new(ActiveRecord::Base) do
+    has_friendly_id :name
+  end
+end
+
+class CoreTest < MiniTest::Unit::TestCase
+
+  include FriendlyId::Test
+  include FriendlyId::Test::Shared
+
+  def klass
+    Author
+  end
+
+  test "models don't use friendly_id by default" do
+    assert !Class.new(ActiveRecord::Base).uses_friendly_id?
+  end
+
+  test "model classes should have a friendly id config" do
+    assert klass.has_friendly_id(:name).friendly_id_config
+  end
+
+  test "should raise error when bad config options are set" do
+    assert_raises ArgumentError do
+      klass.has_friendly_id :name, :garbage => :in
+    end
+  end
+
+  test "should reserve 'new' and 'edit' by default" do
+    ["new", "edit"].each do |word|
+      transaction do
+        assert_raises(ActiveRecord::RecordInvalid) {klass.create! :name => word}
+      end
+    end
+  end
+
+  test "instances should have a friendly id" do
+    with_instance_of(klass) {|record| assert record.friendly_id}
+  end
+end

data/test/helper.rb

@@ -0,0 +1,86 @@
+$: << File.expand_path("../../lib", __FILE__)
+$: << File.expand_path("../", __FILE__)
+$:.uniq!
+
+require "rubygems"
+require "bundler/setup"
+require "mocha"
+require "minitest/unit"
+require "active_record"
+
+if ENV["COVERAGE"]
+  require 'simplecov'
+  SimpleCov.start
+end
+
+require "friendly_id"
+
+# If you want to see the ActiveRecord log, invoke the tests using `rake test LOG=true`
+if ENV["LOG"]
+  require "logger"
+  ActiveRecord::Base.logger = Logger.new($stdout)
+end
+
+module FriendlyId
+  module Test
+
+    def self.included(base)
+      MiniTest::Unit.autorun
+    end
+
+    def transaction
+      ActiveRecord::Base.transaction { yield ; raise ActiveRecord::Rollback }
+    end
+
+    def with_instance_of(*args)
+      klass = args.shift
+      args[0] ||= {:name => "a"}
+      transaction { yield klass.create!(*args) }
+    end
+
+    module Database
+      extend self
+
+      def connect
+        ActiveRecord::Base.establish_connection config
+        version = ActiveRecord::VERSION::STRING
+        driver  = FriendlyId::Test::Database.driver
+        message = "Using #{RUBY_ENGINE} #{RUBY_VERSION} AR #{version} with #{driver}"
+        puts "-" * 72
+        if in_memory?
+          ActiveRecord::Migration.verbose = false
+          Schema.up
+          puts "#{message} (in-memory)"
+        else
+          puts message
+        end
+      end
+
+      def config
+        @config ||= YAML::load(File.open(config_file))
+      end
+
+      def config_file
+        File.expand_path("../config/#{driver}.yml", __FILE__)
+      end
+
+      def driver
+        (ENV["DB"] or "sqlite3").downcase
+      end
+
+      def in_memory?
+        config["database"] == ":memory:"
+      end
+    end
+  end
+end
+
+class Module
+  def test(name, &block)
+    define_method("test_#{name.gsub(/[^a-z0-9]/i, "_")}".to_sym, &block)
+  end
+end
+
+require "schema"
+require "shared"
+FriendlyId::Test::Database.connect