friendly_id4 4.0.0.beta6 → 4.0.0.pre

data/lib/friendly_id/slug.rb

@@ -1,6 +0,0 @@
-# A FriendlyId slug stored in an external table.
-#
-# @see FriendlyId::History
-class FriendlyIdSlug < ActiveRecord::Base
-  belongs_to :sluggable, :polymorphic => true
-end

data/lib/friendly_id/slug_sequencer.rb

@@ -1,82 +0,0 @@
-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
-
-    # Given a slug, get the next available slug in the sequence.
-    def next
-      sequence = conflict.slug.split(separator)[1].to_i
-      next_sequence = sequence == 0 ? 2 : sequence.next
-      "#{normalized}#{separator}#{next_sequence}"
-    end
-
-    # Generate a new sequenced slug.
-    def generate
-      if new_record? or slug_changed?
-        conflict? ? self.next : normalized
-      else
-        sluggable.friendly_id
-      end
-    end
-
-    # Whether or not the model instance's slug has changed.
-    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
-
-    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/generators/friendly_id_generator.rb

@@ -1,24 +0,0 @@
-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('../../friendly_id', __FILE__)
-
-  # Copies the migration template to db/migrate.
-  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/base_test.rb

@@ -1,54 +0,0 @@
-require File.expand_path("../helper.rb", __FILE__)
-
-class CoreTest < MiniTest::Unit::TestCase
-  include FriendlyId::Test
-
-  test "friendly_id should accept a base and a hash" do
-    klass = Class.new(ActiveRecord::Base) do
-      extend FriendlyId
-      friendly_id :foo, :use => :slugged, :slug_column => :bar
-    end
-    assert klass < FriendlyId::Slugged
-    assert_equal :foo, klass.friendly_id_config.base
-    assert_equal :bar, klass.friendly_id_config.slug_column
-  end
-
-
-  test "friendly_id should accept a block" do
-    klass = Class.new(ActiveRecord::Base) do
-      extend FriendlyId
-      friendly_id :foo do |config|
-        config.use :slugged
-        config.base = :foo
-        config.slug_column = :bar
-      end
-    end
-    assert klass < FriendlyId::Slugged
-    assert_equal :foo, klass.friendly_id_config.base
-    assert_equal :bar, klass.friendly_id_config.slug_column
-  end
-
-  test "the block passed to friendly_id should be evaluated before arguments" do
-    klass = Class.new(ActiveRecord::Base) do
-      extend FriendlyId
-      friendly_id :foo do |config|
-        config.base = :bar
-      end
-    end
-    assert_equal :foo, klass.friendly_id_config.base
-  end
-
-  test "should allow defaults to be set via a block" do
-    begin
-      FriendlyId.defaults do |config|
-        config.base = :foo
-      end
-      klass = Class.new(ActiveRecord::Base) do
-        extend FriendlyId
-      end
-      assert_equal :foo, klass.friendly_id_config.base
-    ensure
-      FriendlyId.instance_variable_set :@defaults, nil
-    end
-  end
-end

data/test/config/mysql.yml

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

data/test/config/mysql2.yml

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

data/test/config/postgres.yml

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

data/test/config/sqlite3.yml

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

data/test/configuration_test.rb

@@ -1,27 +0,0 @@
-require File.expand_path("../helper", __FILE__)
-
-class ConfigurationTest < MiniTest::Unit::TestCase
-
-  include FriendlyId::Test
-
-  def setup
-    @model_class = Class.new(ActiveRecord::Base)
-  end
-
-  test "should set model class on initialization" do
-    config = FriendlyId::Configuration.new @model_class
-    assert_equal @model_class, config.model_class
-  end
-
-  test "should set options on initialization if present" do
-    config = FriendlyId::Configuration.new @model_class, :base => "hello"
-    assert_equal "hello", config.base
-  end
-
-  test "should raise error if passed unrecognized option" do
-    assert_raises NoMethodError do
-      FriendlyId::Configuration.new @model_class, :foo => "bar"
-    end
-  end
-
-end

data/test/helper.rb

@@ -1,90 +0,0 @@
-$: << File.expand_path("../../lib", __FILE__)
-$: << File.expand_path("../", __FILE__)
-$:.uniq!
-
-require "rubygems"
-require "bundler/setup"
-require "mocha"
-require "minitest/unit"
-require "active_record"
-# require "active_support/core_ext/class"
-
-if ENV["COVERAGE"]
-  require 'simplecov'
-  SimpleCov.start do
-    add_filter "test/"
-    add_filter "friendly_id/migration"
-  end
-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)
-      model_class = args.shift
-      args[0] ||= {:name => "a"}
-      transaction { yield model_class.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

data/test/history_test.rb

@@ -1,55 +0,0 @@
-require File.expand_path("../helper.rb", __FILE__)
-
-class Manual < ActiveRecord::Base
-  extend FriendlyId
-  friendly_id :name, :use => :history
-end
-
-class HistoryTest < MiniTest::Unit::TestCase
-
-  include FriendlyId::Test
-  include FriendlyId::Test::Shared::Core
-
-  def model_class
-    Manual
-  end
-
-  test "should insert record in slugs table on create" do
-    with_instance_of(model_class) {|record| assert !record.friendly_id_slugs.empty?}
-  end
-
-  test "should not create new slug record if friendly_id is not changed" do
-    with_instance_of(model_class) do |record|
-      record.active = true
-      record.save!
-      assert_equal 1, FriendlyIdSlug.count
-    end
-  end
-
-  test "should create new slug record when friendly_id changes" do
-    with_instance_of(model_class) do |record|
-      record.name = record.name + "b"
-      record.save!
-      assert_equal 2, FriendlyIdSlug.count
-    end
-  end
-
-  test "should be findable by old slugs" do
-    with_instance_of(model_class) do |record|
-      old_friendly_id = record.friendly_id
-      record.name = record.name + "b"
-      record.save!
-      assert found = model_class.find_by_friendly_id(old_friendly_id)
-      assert !found.readonly?
-    end
-  end
-
-  test "should raise error if used with scoped" do
-    model_class = Class.new(ActiveRecord::Base)
-    model_class.extend FriendlyId
-    assert_raises RuntimeError do
-      model_class.friendly_id :name, :use => [:history, :scoped]
-    end
-  end
-
-end

data/test/object_utils_test.rb

@@ -1,26 +0,0 @@
-require File.expand_path("../helper.rb", __FILE__)
-
-
-class ObjectUtilsTest < MiniTest::Unit::TestCase
-
-  include FriendlyId::Test
-
-  test "strings with letters are friendly_ids" do
-    assert "a".friendly_id?
-  end
-
-  test "integers should be unfriendly ids" do
-    assert 1.unfriendly_id?
-  end
-
-  test "numeric strings are neither friendly nor unfriendly" do
-    assert_equal nil, "1".friendly_id?
-    assert_equal nil, "1".unfriendly_id?
-  end
-
-  test "ActiveRecord::Base instances should be unfriendly_ids" do
-    model_class = Class.new(ActiveRecord::Base)
-    model_class.table_name = "authors"
-    assert model_class.new.unfriendly_id?
-  end
-end

data/test/reserved_test.rb

@@ -1,26 +0,0 @@
-require File.expand_path("../helper.rb", __FILE__)
-
-class ReservedTest < MiniTest::Unit::TestCase
-
-  include FriendlyId::Test
-
-  class Journalist < ActiveRecord::Base
-    extend FriendlyId
-    friendly_id :name
-  end
-
-
-  def model_class
-    Journalist
-  end
-
-  test "should reserve 'new' and 'edit' by default" do
-    ["new", "edit"].each do |word|
-      transaction do
-        assert_raises(ActiveRecord::RecordInvalid) {model_class.create! :name => word}
-      end
-    end
-  end
-end
-
-

data/test/schema.rb

@@ -1,56 +0,0 @@
-require "friendly_id/migration"
-
-module FriendlyId
-  module Test
-    class Schema < ActiveRecord::Migration
-      class << self
-        def down
-          CreateFriendlyIdSlugs.down
-          tables.each do |name|
-            drop_table name
-          end
-        end
-
-        def up
-          CreateFriendlyIdSlugs.up
-
-          tables.each do |table_name|
-            create_table table_name do |t|
-              t.string  :name
-              t.boolean :active
-            end
-          end
-
-          slugged_tables.each do |table_name|
-            add_column table_name, :slug, :string
-            add_index  table_name, :slug, :unique => true
-          end
-
-          # This will be used to test scopes
-          add_column :novels, :novelist_id, :integer
-          remove_index :novels, :slug
-
-          # This will be used to test column name quoting
-          add_column :journalists, "strange name", :string
-
-          # This will be used to test STI
-          add_column :journalists, "type", :string
-        end
-
-        private
-
-        def slugged_tables
-          ["journalists", "articles", "novelists", "novels", "manuals"]
-        end
-
-        def simple_tables
-          ["authors", "books"]
-        end
-
-        def tables
-          simple_tables + slugged_tables
-        end
-      end
-    end
-  end
-end