mil_friendly_id 4.0.9.8

data/lib/generators/friendly_id_generator.rb

@@ -0,0 +1,17 @@
+require 'rails/generators'
+require "rails/generators/active_record"
+
+# This generator adds a migration for the {FriendlyId::History
+# FriendlyId::History} addon.
+class FriendlyIdGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
+  extend ActiveRecord::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
+
+end

data/mil_friendly_id.gemspec

@@ -0,0 +1,45 @@
+# encoding: utf-8
+$:.push File.expand_path("../lib", __FILE__)
+
+require "friendly_id"
+
+Gem::Specification.new do |s|
+  s.name              = "mil_friendly_id"
+  s.version           = FriendlyId::VERSION
+  s.authors           = ["Norman Clarke", "Philip Arndt"]
+  s.email             = ["norman@njclarke.com", "parndt@gmail.com"]
+  s.homepage          = "http://github.com/norman/friendly_id"
+  s.summary           = "A comprehensive slugging and pretty-URL plugin."
+  s.rubyforge_project = "friendly_id"
+  s.files             = `git ls-files`.split("\n")
+  s.test_files        = `git ls-files -- {test}/*`.split("\n")
+  s.require_paths     = ["lib"]
+
+  s.add_dependency 'acts_as_paranoid', '0.4.1'
+
+  s.add_development_dependency "railties", "~> 3.2.0"
+  s.add_development_dependency "activerecord", "~> 3.2.0"
+  s.add_development_dependency "minitest", "3.2.0"
+  s.add_development_dependency "mocha"
+  s.add_development_dependency "maruku"
+  s.add_development_dependency "yard"
+  s.add_development_dependency "i18n"
+  s.add_development_dependency "ffaker"
+  s.add_development_dependency "simplecov"
+  s.add_development_dependency "globalize3"
+
+  s.description = <<-EOM
+FriendlyId is the "Swiss Army bulldozer" of slugging and permalink plugins for
+Ruby on Rails. It allows you to create pretty URLs and work with human-friendly
+strings as if they were numeric ids for Active Record models.
+EOM
+
+  s.post_install_message = <<-EOM
+NOTE: FriendlyId 4.x breaks compatibility with 3.x. If you're upgrading
+from 3.x, please see this document:
+
+http://rubydoc.info/github/norman/friendly_id/master/file/WhatsNew.md
+
+EOM
+
+end

data/test/base_test.rb

@@ -0,0 +1,72 @@
+require "helper"
+
+class CoreTest < MiniTest::Unit::TestCase
+  include FriendlyId::Test
+
+  test "friendly_id can be added using 'extend'" do
+    klass = Class.new(ActiveRecord::Base) do
+      extend FriendlyId
+    end
+    assert klass.respond_to? :friendly_id
+  end
+
+  test "friendly_id can be added using 'include'" do
+    klass = Class.new(ActiveRecord::Base) do
+      include FriendlyId
+    end
+    assert klass.respond_to? :friendly_id
+  end
+
+  test "friendly_id should accept a base and a hash" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.abstract_class = true
+      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
+      self.abstract_class = true
+      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
+      self.abstract_class = true
+      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
+        self.abstract_class = true
+        extend FriendlyId
+      end
+      assert_equal :foo, klass.friendly_id_config.base
+    ensure
+      FriendlyId.instance_variable_set :@defaults, nil
+    end
+  end
+end

data/test/compatibility/ancestry/Gemfile

@@ -0,0 +1,8 @@
+source :rubygems
+
+gem "sqlite3", "~> 1.3.4"
+gem "activerecord", "3.0.10"
+gem "minitest", "~> 2.4.0"
+gem "mocha", "~> 0.9.12"
+gem "ancestry"
+gem "rake"

data/test/compatibility/ancestry/ancestry_test.rb

@@ -0,0 +1,34 @@
+require File.expand_path("../../../helper", __FILE__)
+
+require "ancestry"
+
+ActiveRecord::Migration.create_table("things") do |t|
+  t.string  :name
+  t.string  :slug
+  t.string :ancestry
+end
+ActiveRecord::Migration.add_index :things, :ancestry
+
+class Thing < ActiveRecord::Base
+  extend FriendlyId
+  friendly_id do |config|
+    config.use :slugged
+    config.use :scoped
+    config.base  = :name
+    config.scope = :ancestry
+  end
+  has_ancestry
+end
+
+class AncestryTest < MiniTest::Unit::TestCase
+  include FriendlyId::Test
+
+  test "should sequence slugs when scoped by ancestry" do
+    3.times.inject([]) do |memo, _|
+      memo << Thing.create!(:name => "a", :parent => memo.last)
+    end.each do |thing|
+      assert_equal "a", thing.friendly_id
+    end
+  end
+end
+

data/test/compatibility/threading/Gemfile

@@ -0,0 +1,8 @@
+source :rubygems
+
+gem "pg"
+gem "mysql2"
+gem "mocha"
+gem "activerecord", "3.1.1"
+gem "sqlite3"
+gem "fatalistic"

data/test/compatibility/threading/threading.rb

@@ -0,0 +1,45 @@
+ENV["DB"] = "postgres"
+
+require "thread"
+require File.expand_path("../../../helper", __FILE__)
+require "active_record/locking/fatalistic"
+
+ActiveRecord::Migration.tap do |m|
+  m.drop_table "things"
+  m.create_table("things") do |t|
+    t.string  :name
+    t.string  :slug
+  end
+  m.add_index :things, :slug, :unique => true
+end
+
+class Thing < ActiveRecord::Base
+  extend FriendlyId
+  friendly_id :name, :use => :slugged
+end
+
+$things = 10.times.map do
+  Thing.new :name => "a b c"
+end
+
+$mutex = Mutex.new
+
+def save_thing
+  thing = $mutex.synchronize do
+    $things.pop
+  end
+  if thing.nil? then return end
+  Thing.lock do
+    thing.save!
+    print "#{thing.friendly_id}\n"
+  end
+  true
+end
+
+2.times.map do
+  Thread.new do
+    while true do
+      break unless save_thing
+    end
+  end
+end.map(&:value)

data/test/configuration_test.rb

@@ -0,0 +1,48 @@
+require "helper"
+
+class ConfigurationTest < MiniTest::Unit::TestCase
+
+  include FriendlyId::Test
+
+  def setup
+    @model_class = Class.new(ActiveRecord::Base) do
+      self.abstract_class = true
+    end
+  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
+
+  test "#use should accept a name that resolves to a module" do
+    refute @model_class < FriendlyId::Slugged
+    @model_class.class_eval do
+      extend FriendlyId
+      friendly_id :hello, :use => :slugged
+    end
+    assert @model_class < FriendlyId::Slugged
+  end
+
+  test "#use should accept a module" do
+    my_module = Module.new
+    refute @model_class < my_module
+    @model_class.class_eval do
+      extend FriendlyId
+      friendly_id :hello, :use => my_module
+    end
+    assert @model_class < my_module
+  end
+
+end

data/test/core_test.rb

@@ -0,0 +1,48 @@
+require "helper"
+
+class Book < ActiveRecord::Base
+  extend FriendlyId
+  friendly_id :name
+end
+
+class Author < ActiveRecord::Base
+  extend FriendlyId
+  friendly_id :name
+  has_many :books
+end
+
+class CoreTest < MiniTest::Unit::TestCase
+
+  include FriendlyId::Test
+  include FriendlyId::Test::Shared::Core
+
+  def model_class
+    Author
+  end
+
+  test "models don't use friendly_id by default" do
+    assert !Class.new(ActiveRecord::Base) {
+      self.abstract_class = true
+    }.respond_to?(:friendly_id)
+  end
+
+  test "model classes should have a friendly id config" do
+    assert model_class.friendly_id(:name).friendly_id_config
+  end
+
+  test "instances should have a friendly id" do
+    with_instance_of(model_class) {|record| assert record.friendly_id}
+  end
+
+  test "instances can be marshaled when a relationship is used" do
+    transaction do
+      author = Author.create :name => 'Philip'
+      author.books.create :name => 'my book'
+      begin
+        assert Marshal.load(Marshal.dump(author))
+      rescue TypeError => e
+        flunk(e.to_s)
+      end
+    end
+  end
+end

data/test/databases.yml

@@ -0,0 +1,19 @@
+mysql:
+  adapter: mysql2
+  database: friendly_id_test
+  username: root
+  hostname: localhost
+  encoding: utf8
+
+postgres:
+  adapter: postgresql
+  host: localhost
+  port: 5432
+  username: postgres
+  database: friendly_id_test
+  encoding: utf8
+
+sqlite3:
+  adapter: sqlite3
+  database: ":memory:"
+  encoding: utf8

data/test/generator_test.rb

@@ -0,0 +1,20 @@
+require "helper"
+require "rails/generators"
+require "generators/friendly_id_generator"
+
+class FriendlyIdGeneratorTest < Rails::Generators::TestCase
+
+  tests FriendlyIdGenerator
+  destination File.expand_path("../../tmp", __FILE__)
+
+  setup :prepare_destination
+
+  test "should generate a migration" do
+    begin
+      run_generator
+      assert_migration "db/migrate/create_friendly_id_slugs"
+    ensure
+      FileUtils.rm_rf self.destination_root
+    end
+  end
+end

data/test/globalize_test.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+require "helper"
+
+class TranslatedArticle < ActiveRecord::Base
+  translates :slug, :title
+  extend FriendlyId
+  friendly_id :title, :use => :globalize
+end
+
+class GlobalizeTest < MiniTest::Unit::TestCase
+  include FriendlyId::Test
+
+  def setup
+    I18n.locale = :en
+  end
+
+  test "should find slug in current locale if locale is set, otherwise in default locale" do
+    transaction do
+      I18n.default_locale = :en
+      article_en = I18n.with_locale(:en) { TranslatedArticle.create(:title => 'a title') }
+      article_de = I18n.with_locale(:de) { TranslatedArticle.create(:title => 'titel') }
+
+      I18n.with_locale(:de) {
+        assert_equal TranslatedArticle.find("titel"), article_de
+        assert_equal TranslatedArticle.find("a-title"), article_en
+      }
+    end
+  end
+
+  test "should set friendly id for locale" do
+    transaction do
+      article = TranslatedArticle.create!(:title => "War and Peace")
+      article.set_friendly_id("Guerra y paz", :es)
+      article.save!
+      article = TranslatedArticle.find('war-and-peace')
+      I18n.with_locale(:es) { assert_equal "guerra-y-paz", article.friendly_id }
+      I18n.with_locale(:en) { assert_equal "war-and-peace", article.friendly_id }
+    end
+  end
+
+  # https://github.com/svenfuchs/globalize3/blob/master/test/globalize3/dynamic_finders_test.rb#L101
+  # see: https://github.com/svenfuchs/globalize3/issues/100
+  test "record returned by friendly_id should have all translations" do
+    transaction do
+      I18n.with_locale(:en) do
+        article = TranslatedArticle.create(:title => 'a title')
+        Globalize.with_locale(:ja) { article.update_attributes(:title => 'タイトル') }
+        article_by_friendly_id = TranslatedArticle.find("a-title")
+        article.translations.each do |translation|
+          assert_includes article_by_friendly_id.translations, translation
+        end
+      end
+    end
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,87 @@
+require "rubygems"
+require "bundler/setup"
+require "minitest/unit"
+require "mocha"
+require "active_record"
+require 'active_support/core_ext/time/conversions'
+
+
+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 b c"}
+      transaction { yield model_class.create!(*args) }
+    end
+
+    module Database
+      extend self
+
+      def connect
+        version = ActiveRecord::VERSION::STRING
+        driver  = FriendlyId::Test::Database.driver
+        engine  = RUBY_ENGINE rescue "ruby"
+
+        ActiveRecord::Base.establish_connection config[driver]
+        message = "Using #{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(File.expand_path("../databases.yml", __FILE__)))
+      end
+
+      def driver
+        (ENV["DB"] or "sqlite3").downcase
+      end
+
+      def in_memory?
+        config[driver]["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
+at_exit {ActiveRecord::Base.connection.disconnect!}