pseudocephalopod 0.1.0 → 0.2.0

data/.gitignore

@@ -10,4 +10,6 @@ coverage
 rdoc
 pkg
 *.gem
-*.gemspec
+*.gemspec
+coverage
+metrics/*

data/Gemfile

@@ -4,6 +4,15 @@ source :gemcutter
 gem "activerecord", "= 3.0.0.beta2"
 gem "reversible_data"
 gem "uuid"
-gem "shoulda"
 gem "sqlite3-ruby", :require => "sqlite3"
-gem "redgreen", :require => nil if RUBY_VERSION < "1.9"
+
+gem "shoulda",  :require => nil
+gem "redgreen", :require => nil if RUBY_VERSION < "1.9"
+gem "rcov",     :require => nil
+gem "reek",     :require => nil
+gem "roodi",    :require => nil
+gem "flay",     :require => nil
+gem "flog",     :require => nil
+gem "rake",     :require => nil
+gem "Saikuro",  :require => nil
+gem "jeweler",  :require => nil

data/README.md

@@ -26,7 +26,7 @@ and built to work on Rails 3 from the start.
 
 ## Usage ##
 
-Using Pseudocephalopod is simple. In Rails, simply drop this in your gemfile:
+Using Pseudocephalopod is simple. In Rails, simply drop this in your Gemfile:
 
     gem 'pseudocephalopod'
     

data/Rakefile

@@ -1,4 +1,8 @@
 require 'rubygems'
+require 'bundler'
+Bundler.setup
+Bundler.require
+
 require 'rake'
 
 require File.expand_path('../lib/pseudocephalopod/version', __FILE__)
@@ -33,27 +37,49 @@ begin
   require 'rcov/rcovtask'
   Rcov::RcovTask.new do |test|
     test.libs << 'test'
-    test.pattern = 'test/**/test_*.rb'
+    test.pattern = 'test/**/*_test.rb'
     test.verbose = true
+    test.rcov_opts << '--exclude \.bundle-cache --exclude gems-switcher'
+    test.output_dir = "metrics/coverage"
   end
 rescue LoadError
   task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+    abort "Rcov isn't installed, please run via bundle exec after bundle installing"
   end
 end
 
+task :metrics => [:rcov, :saikuro, :reek, :flay, :flog, :roodi]
+
 task :test => :check_dependencies
 
+task :flog do
+  system "flog lib"
+end
+
+task :saikuro do
+  system "rm -rf metrics/saikuro && mkdir -p metrics/saikuro && saikuro -c -t -i lib/ -y 0 -w 11 -e 16 -o metrics/saikuro/"
+end
+
+begin
+  require 'flay'
+  require 'flay_task'
+  FlayTask.new
+rescue LoadError
+  task :flay do
+    abort "Flay isn't installed, please run via bundle exec after bundle installing"
+  end
+end
+
 begin
-  require 'reek/adapters/rake_task'
-  Reek::RakeTask.new do |t|
+  require 'reek/rake/task'
+  Reek::Rake::Task.new do |t|
     t.fail_on_error = true
     t.verbose = false
     t.source_files = 'lib/**/*.rb'
   end
 rescue LoadError
   task :reek do
-    abort "Reek is not available. In order to run reek, you must: sudo gem install reek"
+    abort "Reek isn't installed, please run via bundle exec after bundle installing"
   end
 end
 
@@ -65,7 +91,7 @@ begin
   end
 rescue LoadError
   task :roodi do
-    abort "Roodi is not available. In order to run roodi, you must: sudo gem install roodi"
+    abort "Roodi isn't installed, please run via bundle exec after bundle installing"
   end
 end
 

data/lib/generators/pseudocephalopod/slug_migration/slug_migration_generator.rb

@@ -16,7 +16,7 @@ module Pseudocephalopod
       end
       
       def create_migration_file
-        migration_template "migration.rb", "db/migrate/add_cached_slug_to_#{table_name}.rb"
+        migration_template "migration.erb", "db/migrate/add_cached_slug_to_#{table_name}.rb"
       end
       
     end

data/lib/generators/pseudocephalopod/slugs/slugs_generator.rb

@@ -16,7 +16,7 @@ module Pseudocephalopod
       end
       
       def create_migration_file
-        migration_template "migration.rb", "db/migrate/create_pseudocephalopod_slugs.rb"
+        migration_template "migration.erb", "db/migrate/create_pseudocephalopod_slugs.rb"
       end
       
     end

data/lib/pseudocephalopod/active_record_methods.rb

@@ -1,27 +1,21 @@
 module Pseudocephalopod
   module ActiveRecordMethods
+    AR_CLASS_ATTRIBUTE_NAMES = %w(cached_slug_column slug_source slug_convertor_proc default_uuid_slug use_slug_history sync_slugs slug_scope use_slug_cache use_slug_to_param).map(&:to_sym)
     
     def is_sluggable(source = :name, options = {})
+      options.symbolize_keys!
+      class_attribute *AR_CLASS_ATTRIBUTE_NAMES
+      attr_accessor   :found_via_slug
+      # Load extensions
       extend  ClassMethods
       include InstanceMethods
       extend Pseudocephalopod::Scopes
       extend Pseudocephalopod::Finders
-      options.symbolize_keys!
-      # Define the attributes
-      class_attribute :cached_slug_column, :slug_source, :slug_source_convertor,
-                      :default_uuid_slug, :store_slug_history, :sync_slugs, :slug_scope
-      attr_accessor :found_via_slug
-      # Set attribute values
-      set_slug_convertor options[:convertor]
-      self.slug_source        = source.to_sym
-      self.cached_slug_column = (options[:slug_column] || :cached_slug).to_sym
-      self.default_uuid_slug  = !!options.fetch(:uuid, true)
-      self.store_slug_history = !!options.fetch(:history, true)
-      self.sync_slugs         = !!options.fetch(:sync, true)
-      self.slug_scope         = options[:slug_scope]
-      include Pseudocephalopod::Caching if !!options.fetch(:use_cache, true)
-      alias_method :to_param, :to_slug if !!options.fetch(:to_param, true)
-      include Pseudocephalopod::SlugHistory if self.store_slug_history
+      self.slug_source = source.to_sym
+      set_slug_options options
+      alias_method :to_param, :to_slug      if use_slug_to_param
+      include Pseudocephalopod::SlugHistory if use_slug_history
+      include Pseudocephalopod::Caching     if use_slug_cache
       before_validation :autogenerate_slug
     end
     
@@ -33,7 +27,7 @@ module Pseudocephalopod
       
       def generate_slug
         slug_value = send(self.slug_source)
-        slug_value = self.slug_source_convertor.call(slug_value) if slug_value.present?
+        slug_value = self.slug_convertor_proc.call(slug_value) if slug_value.present?
         if slug_value.present?
           scope = self.class.other_than(self).slug_scope_relation(self)
           slug_value = Pseudocephalopod.next_value(scope, slug_value)
@@ -88,18 +82,27 @@ module Pseudocephalopod
         self.slug_scope.present?
       end
       
+      def set_slug_options(options)
+        set_slug_convertor options[:convertor]
+        self.cached_slug_column = (options[:slug_column] || :cached_slug).to_sym
+        self.slug_scope         = options[:scope]
+        self.default_uuid_slug  = !!options.fetch(:uuid, true)
+        self.sync_slugs         = !!options.fetch(:sync, true)
+        self.use_slug_cache     = !!options.fetch(:use_cache, true)
+        self.use_slug_to_param  = !!options.fetch(:to_param, true)
+        self.use_slug_history   = !!options.fetch(:history, Pseudocephalopod::Slug.usable?)
+      end
+      
       def set_slug_convertor(convertor)
         if convertor.present?
-          if convertor.is_a?(Symbol)
-            self.slug_source_convertor = proc { |r| r.try(convertor) }
-          elsif convertor.respond_to?(:call)
-            self.slug_source_convertor = convertor
+          unless convertor.respond_to?(:call)
+            convertor_key = convertor.to_sym
+            convertor     = proc { |r| r.try(convertor_key) }
           end
+          self.slug_convertor_proc = convertor
         else
-          if "".respond_to?(:to_url)
-            self.slug_source_convertor = proc { |r| r.to_s.to_url }
-          else
-            self.slug_source_convertor = proc { |r| ActiveSupport::Multibyte::Chars.new(r.to_s).parameterize }
+          self.slug_convertor_proc = proc do |slug|
+            slug.respond_to?(:to_url) ? slug.to_url : ActiveSupport::Multibyte::Chars.new(slug.to_s).parameterize
           end
         end
       end

data/lib/pseudocephalopod/caching.rb

@@ -1,7 +1,17 @@
 require 'digest/sha2'
 
 module Pseudocephalopod
+  # Mixin for adding simple caching support to models using pseudocephalod.
+  # Usually included by passing the :cache option as true (by default it is
+  # true, you can disable by passing :cache as false or nil).
   module Caching
+    
+    class << self
+      attr_accessor :cache_expires_in
+    end
+    
+    # Cache for 10 minutes by default.
+    self.cache_expires_in = 600
    
     def self.included(parent)
       parent.extend ClassMethods
@@ -14,19 +24,30 @@ module Pseudocephalopod
     end
    
     module InstanceMethods
+      # Automatically called in after_save, will cache this records id
+      # with to match the current records slug / scope
       def globally_cache_slug
         return unless send(:"#{self.cached_slug_column}_changed?")
         value = self.to_slug
         self.class.cache_slug_lookup!(value, self) if value.present?
-        unless store_slug_history
+        unless use_slug_history
           value = send(:"#{self.cached_slug_column}_was")
           self.class.cache_slug_lookup!(value, nil)
         end
       end
+      
+      # Wraps remove_slug_history! to remove each of the slugs
+      # recording in this models slug history.
+      def remove_slug_history!
+        previous_slugs.each { |s| self.class.cache_slug_lookup!(s, nil) }
+        super
+      end
+      
     end
    
     module ClassMethods
       
+      # Wraps find_using_slug to look in the cache.
       def find_using_slug(slug, options = {})
         # First, attempt to load an id and then record from the cache.
         if (cached_id = lookup_cached_id_from_slug(slug)).present?
@@ -38,6 +59,7 @@ module Pseudocephalopod
         end
       end
       
+      # Returns a slug cache key for a given slug.
       def slug_cache_key(slug)
         [Pseudocephalopod.cache_key_prefix, slug_scope_key(Digest::SHA256.hexdigest(slug.to_s.strip))].compact.join("/")
       end
@@ -46,8 +68,19 @@ module Pseudocephalopod
         lookup_cached_id_from_slug(slug).present?
       end
       
+      # Modify the cache for a given slug. If record is nil, it will
+      # delete the item from the slug cache, otherwise it will store
+      # the records id.
       def cache_slug_lookup!(slug, record)
-        Pseudocephalopod.cache && Pseudocephalopod.cache.write(slug_cache_key(slug), record && record.id)
+        return if Pseudocephalopod.cache.blank?
+        cache = Pseudocephalopod.cache
+        key   = slug_cache_key(slug)
+        # Set an expires in option for caching.
+        caching_options = Hash.new.tap do |hash|
+          expiry = Pseudocephalopod::Caching.cache_expires_in
+          hash[:expires_in] = expiry.to_i if expiry.present?
+        end
+        record.nil? ? cache.delete(key) : cache.write(key, record.id, hash)
       end
       
       protected

data/lib/pseudocephalopod/finders.rb

@@ -6,7 +6,7 @@ module Pseudocephalopod
       value = nil
       value ||= find_by_id(slug.to_i, options) if slug =~ /\A\d+\Z/
       value ||= with_cached_slug(slug).first(options)
-      value ||= find_using_slug_history(slug, options) if store_slug_history
+      value ||= find_using_slug_history(slug, options) if use_slug_history
       value.found_via_slug = slug if value.present?
       value
     end

data/lib/pseudocephalopod/memory_cache.rb

@@ -1,18 +1,24 @@
 module Pseudocephalopod
   class MemoryCache
     
-    @@cache = {}
-    
-    def self.write(key, value)
-      @@cache[key.to_s] = value
+    def self.write(key, value, options = {})
+      cache[key.to_s] = value
     end
     
     def self.read(key)
-      @@cache[key.to_s]
+      cache[key.to_s]
+    end
+    
+    def self.delete(key)
+      cache.delete key.to_s
     end
     
     def self.reset!
-      @@cache = {}
+      @cache = nil
+    end
+    
+    def self.cache
+      @cache ||= {}
     end
     
   end

data/lib/pseudocephalopod/slug.rb

@@ -28,5 +28,9 @@ module Pseudocephalopod
       for_record(record).delete_all
     end
   
+    def self.usable?
+      table_exists? rescue false
+    end
+  
   end
 end

data/lib/pseudocephalopod/slug_history.rb

@@ -16,18 +16,19 @@ module Pseudocephalopod
         Pseudocephalopod.previous_slugs_for(self)
       end
       
+      def remove_slug_history!
+        Pseudocephalopod.remove_slug_history_for(self)
+      end
+      
       protected
       
       def record_slug_changes
-        return unless send(:"#{self.cached_slug_column}_changed?")
-        value = send(:"#{self.cached_slug_column}_was")
+        slug_column = self.cached_slug_column
+        return unless send(:"#{slug_column}_changed?")
+        value = send(:"#{slug_column}_was")
         Pseudocephalopod.record_slug(self, value) if value.present?
       end
       
-      def remove_slug_history
-        Pseudocephalopod.remove_slug_history_for(self)
-      end
-      
     end
     
     module ClassMethods

data/lib/pseudocephalopod/version.rb

@@ -1,7 +1,7 @@
 module Pseudocephalopod
   module Version
     MAJOR  = 0
-    MINOR  = 1
+    MINOR  = 2
     PATCH  = 0
     STRING = [MAJOR, MINOR, PATCH].join(".")
   end

data/lib/pseudocephalopod.rb

@@ -20,8 +20,12 @@ module Pseudocephalopod
       slug
     end
     
+    def uuid
+      @uuid ||= UUID.new
+    end
+    
     def generate_uuid_slug
-      UUID.new.generate
+      uuid.generate
     end
     
     def last_known_slug_id(scope, slug)

data/test/caching_test.rb

@@ -1,60 +1,77 @@
 require 'helper'
 
 class CachingTest < Test::Unit::TestCase
-  with_tables :slugs, :users, :unslugged_users do
+  with_tables :slugs, :users do
     
     setup { Pseudocephalopod::MemoryCache.reset! }
     
-    should 'store a cache automatically after finding it' do
-      assert !User.has_cache_for_slug?("bob")
-      u = User.create :name => "Bob"
-      assert User.has_cache_for_slug?("bob")
-      Pseudocephalopod::MemoryCache.reset!
-      assert !User.has_cache_for_slug?("bob")
-      assert_equal u, User.find_using_slug("bob")
-      assert User.has_cache_for_slug?("bob")
-      # Second find from cache
-      assert_equal u, User.find_using_slug("bob")
+    context 'with the default slug setup' do
+      
+      setup { setup_slugs! }
+    
+      should 'store a cache automatically after finding it' do
+        assert_has_no_cache_for  "bob"
+        u = User.create :name => "Bob"
+        assert_has_cache_for     "bob"
+        Pseudocephalopod::MemoryCache.reset!
+        assert_has_no_cache_for  "bob"
+        assert_same_as_slug u,   "bob"
+        assert_has_cache_for     "bob"
+        assert_same_as_slug u,   "bob"
+      end
+    
+      should 'automatically keep cache entries for history by default' do
+        setup_slugs!
+        assert_has_no_cache_for "bob"
+        assert_has_no_cache_for "red"
+        assert_has_no_cache_for "sam"
+        user = User.create :name => "bob"
+        assert_has_cache_for "bob"
+        assert_has_no_cache_for "red"
+        assert_has_no_cache_for "sam"
+        user.update_attributes :name => "Red"
+        assert_has_cache_for "bob"
+        assert_has_cache_for "red"
+        assert_has_no_cache_for "sam"
+        user.update_attributes :name => "Sam"
+        assert_has_cache_for "bob"
+        assert_has_cache_for "red"
+        assert_has_cache_for "sam"
+      end
+      
     end
     
     should 'remove cache on models without history' do
-      UnsluggedUser.is_sluggable :name, :history => false
-      u = UnsluggedUser.create :name => "Bob"
-      assert UnsluggedUser.has_cache_for_slug?("bob")
-      assert !UnsluggedUser.has_cache_for_slug?("red")
-      assert !UnsluggedUser.has_cache_for_slug?("sam")
+      setup_slugs! :history => false
+      u = User.create :name => "Bob"
+      assert_has_cache_for    "bob"
+      assert_has_no_cache_for "red"
+      assert_has_no_cache_for "sam"
       u.update_attributes :name => "Red"
       u.update_attributes :name => "Sam"
-      assert !UnsluggedUser.has_cache_for_slug?("bob")
-      assert !UnsluggedUser.has_cache_for_slug?("red")
-      assert UnsluggedUser.has_cache_for_slug?("sam")
-    end
-    
-    should 'automatically keep cache entries for history by default' do
-      assert !User.has_cache_for_slug?("bob")
-      assert !User.has_cache_for_slug?("red")
-      assert !User.has_cache_for_slug?("sam")
-      user = User.create :name => "bob"
-      assert User.has_cache_for_slug?("bob")
-      assert !User.has_cache_for_slug?("red")
-      assert !User.has_cache_for_slug?("sam")
-      user.update_attributes :name => "Red"
-      assert User.has_cache_for_slug?("bob")
-      assert User.has_cache_for_slug?("red")
-      assert !User.has_cache_for_slug?("sam")
-      user.update_attributes :name => "Sam"
-      assert User.has_cache_for_slug?("bob")
-      assert User.has_cache_for_slug?("red")
-      assert User.has_cache_for_slug?("sam")
+      assert_has_no_cache_for "bob"
+      assert_has_no_cache_for "red"
+      assert_has_cache_for    "sam"
     end
    
     should 'allow you to disable caching' do
-      UnsluggedUser.is_sluggable :name, :use_cache => false
-      assert !UnsluggedUser.respond_to?(:has_cache_for_slug?)
+      setup_slugs! :use_cache => false
+      assert !User.respond_to?(:has_cache_for_slug?)
     end
     
     # Ensure we destroy the contents of the cache after each test.
     teardown { Pseudocephalopod::MemoryCache.reset! }
     
   end
+  
+  protected
+  
+  def assert_has_cache_for(key)
+    assert User.has_cache_for_slug?(key), "User should have a cache entry for #{key.inspect}"
+  end
+  
+  def assert_has_no_cache_for(key)
+    assert !User.has_cache_for_slug?(key), "User should not have a cache entry for #{key.inspect}"
+  end
+  
 end

data/test/helper.rb

@@ -19,4 +19,25 @@ Pseudocephalopod.cache = Pseudocephalopod::MemoryCache
 
 class Test::Unit::TestCase
   extend ReversibleData::ShouldaMacros
+  
+  def setup_slugs!(*args)
+    options = args.extract_options!
+    field   = args.pop || :name
+    User.is_sluggable field, options
+  end
+  
+  def assert_same_as_slug(user, slug, options = {})
+    found_user = User.find_using_slug(slug, options)
+    assert_equal user, found_user, "#{slug.inspect} should return #{user.inspect}, got #{found_user.inspect}"
+  end
+  
+  def assert_different_to_slug(user, slug, options = {})
+    found_user = User.find_using_slug(slug, options)
+    assert_not_equal user, found_user, "#{slug.inspect} should not return #{user.inspect}, got same record."
+  end
+  
+  def assert_none_for_slug(slug)
+    assert User.find_using_slug(slug).blank?, "slug #{slug.inspect} should not return any records."
+  end
+  
 end

data/test/is_sluggable_test.rb

@@ -2,87 +2,145 @@ require 'helper'
 require 'digest/md5'
 
 class IsSluggableTest < Test::Unit::TestCase
-  with_tables :slugs, :users, :unslugged_users do
+  with_tables :slugs, :users do
     
-    should 'correctly sluggify a value' do
-      user = User.create(:name => "Bob")
-      assert_equal "bob", user.to_param
-      assert_equal "bob", user.cached_slug
+    class StringWrapper < String
+      def to_url; "my-demo-slug"; end
     end
     
-    should 'generate a uuid in place of a slug' do
-      user = User.create(:name => '')
-      assert user.cached_slug.present?
-    end
-    
-    should 'return need to generate a slug when the cahced slug is blank' do
-      user = User.new(:name => "Ninja Stuff")
-      assert user.cached_slug.blank?
-      assert user.should_generate_slug?
-      user.save
-      assert user.cached_slug.present?
-      assert !user.should_generate_slug?
-      user.name = 'Awesome'
-      assert user.should_generate_slug?
-    end
-    
-    should 'let you disable syncing a slug' do
-      UnsluggedUser.is_sluggable :name, :sync => false
-      user = UnsluggedUser.create(:name => "Ninja User")
-      assert !user.should_generate_slug?
-      user.name = "Another User Name"
-      assert !user.should_generate_slug?
-    end
-    
-    should 'by default record slug history' do
-      user = User.create :name => "Bob"
-      assert_equal [], user.previous_slugs
-      user.update_attributes! :name => "Sal"
-      user.update_attributes! :name => "Red"
-      user.update_attributes! :name => "Jim"
-      assert_equal ["red", "sal", "bob"], user.previous_slugs
-      assert_equal user, User.find_using_slug("red")
-      assert_equal user, User.find_using_slug("sal")
-      assert_equal user, User.find_using_slug("bob")
-      assert_equal user, User.find_using_slug("jim")
-    end
-    
-    should 'let you disable recording of slug history' do
-      UnsluggedUser.is_sluggable :name, :history => false
-      user = UnsluggedUser.create(:name => "Bob")
-      assert !user.respond_to?(:previous_slugs)
-      user.update_attributes! :name => "Red"
-      assert_equal user,     UnsluggedUser.find_using_slug("red")
-      assert_not_equal user, UnsluggedUser.find_using_slug("bob")
-      assert UnsluggedUser.find_using_slug("bob").blank?
-    end
-    
-    should "let you find a record by it's id as needed" do
-      user = User.create :name => "Bob"
-      assert_equal user, User.find_using_slug(user.id)
-      assert_equal user, User.find_using_slug(user.id.to_i)
+    context 'with the default slug options' do
+      
+      setup { setup_slugs! }
+      
+      should 'correctly sluggify a value' do
+        user = User.create(:name => "Bob")
+        assert_equal "bob", user.to_param
+        assert_equal "bob", user.cached_slug
+      end
+
+      should 'generate a uuid in place of a slug' do
+        user = User.create(:name => '')
+        assert user.cached_slug.present?
+      end
+
+      should 'return need to generate a slug when the cahced slug is blank' do
+        user = User.new(:name => "Ninja Stuff")
+        assert user.cached_slug.blank?
+        assert user.should_generate_slug?
+        user.save
+        assert user.cached_slug.present?
+        assert !user.should_generate_slug?
+        user.name = 'Awesome'
+        assert user.should_generate_slug?
+      end
+      
+      should "let you find a record by it's id as needed" do
+        user = User.create :name => "Bob"
+        assert_equal user, User.find_using_slug(user.id)
+        assert_equal user, User.find_using_slug(user.id.to_i)
+      end
+      
+      should 'return nil for unfound slugs by default' do
+        assert_nil User.find_using_slug("awesome")
+      end
+      
+      should 'let you find slugs and raise an exception' do
+        assert_raises(ActiveRecord::RecordNotFound) do
+          User.find_using_slug!("awesome")
+        end
+      end
+
+      should 'default to generate a uuid' do
+        user = User.create :name => ""
+        assert_match /\A[a-zA-Z0-9]{32}\Z/, user.cached_slug.gsub("-", "")
+        user = User.create
+        assert_match /\A[a-zA-Z0-9]{32}\Z/, user.cached_slug.gsub("-", "")
+      end
+
+      should 'automatically append a sequence to the end of conflicting slugs' do
+        u1 = User.create :name => "ninjas Are awesome"
+        u2 = User.create :name => "Ninjas are awesome"
+        assert_equal "ninjas-are-awesome",    u1.to_slug
+        assert_equal "ninjas-are-awesome--1", u2.to_slug
+      end
+
+      should 'let you find out if there is a better way of finding a slug' do
+        user = User.create :name => "Bob"
+        user.update_attributes! :name => "Ralph"
+        assert !User.find_using_slug("ralph").has_better_slug?
+        assert User.find_using_slug("bob").has_better_slug?
+        assert User.find_using_slug(user.id).has_better_slug?
+      end
+      
     end
     
-    should 'default to generate a uuid' do
-      user = User.create :name => ""
-      assert_match /\A[a-zA-Z0-9]{32}\Z/, user.cached_slug.gsub("-", "")
-      user = User.create
-      assert_match /\A[a-zA-Z0-9]{32}\Z/, user.cached_slug.gsub("-", "")
+    context 'with slug syncing disabled' do
+      setup { setup_slugs! :sync => false }
+      
+      should 'let you disable syncing a slug' do
+        user = User.create(:name => "Ninja User")
+        assert !user.should_generate_slug?
+        user.name = "Another User Name"
+        assert !user.should_generate_slug?
+      end
+      
+      should 'let you force slug generation' do
+        user = User.create(:name => "Ninja User")
+        assert_equal "ninja-user", user.to_slug
+        user.update_attributes :name => "Test User"
+        assert_equal "ninja-user", user.to_slug
+        user.generate_slug!
+        assert_equal "test-user", user.to_slug
+        user.reload
+        assert_equal "test-user", user.to_slug
+      end
+      
+      should 'let you force the update of all slugs' do
+        user_a = User.create(:name => "User A")
+        user_b = User.create(:name => "User B")
+        user_c = User.create(:name => "User C")
+        user_a.update_attributes :name => "User A-1"
+        user_b.update_attributes :name => "User B-1"
+        user_c.update_attributes :name => "User C-1"
+        assert_equal "user-a", user_a.to_slug
+        assert_equal "user-b", user_b.to_slug
+        assert_equal "user-c", user_c.to_slug
+        User.update_all_slugs!
+        user_a.reload
+        user_b.reload
+        user_c.reload
+        assert_equal "user-a-1", user_a.to_slug
+        assert_equal "user-b-1", user_b.to_slug
+        assert_equal "user-c-1", user_c.to_slug
+      end
+      
     end
     
-    should 'automatically append a sequence to the end of conflicting slugs' do
-      u1 = User.create :name => "ninjas Are awesome"
-      u2 = User.create :name => "Ninjas are awesome"
-      assert_equal "ninjas-are-awesome", u1.to_slug
-      assert_equal "ninjas-are-awesome--1", u2.to_slug
+    context 'setting slug convertors' do
+      
+      should 'let you specify a symbol' do
+        setup_slugs! :convertor => :upcase
+        assert_equal "AWESOME USER", User.create(:name => "Awesome User").to_slug
+      end
+      
+      should 'let you specify a proc' do
+        setup_slugs! :convertor => proc { |r| r.reverse.upcase }
+        assert_equal "RESU EMOSEWA", User.create(:name => "Awesome User").to_slug
+      end
+      
+      should 'call to_url if available by default' do
+        setup_slugs!
+        original_value = StringWrapper.new("Awesome User")
+        assert_equal "my-demo-slug", User.create(:name => original_value).to_slug
+      end
+      
     end
     
-    should 'let you find out if there is a better way of finding a slug' do
-      user = User.create :name => "Bob"
-      user.update_attributes! :name => "Ralph"
-      assert !User.find_using_slug("ralph").has_better_slug?
-      assert User.find_using_slug("bob").has_better_slug?
-      assert User.find_using_slug(user.id).has_better_slug?
+    should 'set the cached slug to nil if uuid is nil and the source value is blank' do
+      setup_slugs! :uuid => nil
+      record = User.create(:name => "")
+      assert_nil record.cached_slug
+      assert_equal record.id.to_s, record.to_slug
     end
     
   end

data/test/model_definitions.rb

@@ -11,18 +11,9 @@ ReversibleData.add :slugs do |t|
   t.datetime :created_at
 end
 
-user = ReversibleData.add :users do |u|
-  u.string :name
-  u.string :cached_slug
-  u.timestamps
-end
-
-user.define_model do
-  is_sluggable :name
-end
-
-ReversibleData.add :unslugged_users do |u|
+ReversibleData.add :users do |u|
   u.string :name
+  u.string :address
   u.string :cached_slug
   u.timestamps
 end

data/test/pseudocephalopod_test.rb

@@ -2,6 +2,11 @@ require 'helper'
 
 class PseudocephalopodTest < Test::Unit::TestCase
   
+  class SlugScopeTest
+    cattr_accessor :slug_scope_key
+    self.slug_scope_key = "my-test-scope"
+  end
+  
   should 'return the correct counter versions' do
     assert_equal 'awesome',      Pseudocephalopod.with_counter('awesome')
     assert_equal 'awesome',      Pseudocephalopod.with_counter('awesome', 0)
@@ -9,5 +14,14 @@ class PseudocephalopodTest < Test::Unit::TestCase
     assert_equal 'awesome--2',   Pseudocephalopod.with_counter('awesome', 2)
     assert_equal 'awesome--100', Pseudocephalopod.with_counter('awesome', 100)
   end
-  
+
+  should 'correct allow you to slug scope keys' do
+    assert_equal "my-test-scope", Pseudocephalopod.key_for_scope(SlugScopeTest)
+    assert_equal "my-test-scope", Pseudocephalopod.key_for_scope(SlugScopeTest.new)
+    assert_equal "my-test-scope", Pseudocephalopod.key_for_scope("my-test-scope")
+    assert_equal "",              Pseudocephalopod.key_for_scope(nil)
+    assert_equal "1",             Pseudocephalopod.key_for_scope(1)
+    assert_equal "awesome",       Pseudocephalopod.key_for_scope(:awesome)
+  end
+
 end

data/test/slug_history_test.rb

@@ -7,22 +7,69 @@ class FakedModel
 end
 
 class SlugHistoryTest < Test::Unit::TestCase
-  with_tables :slugs do
+  with_tables :slugs, :users do
+    
+    context 'for arbitrary models' do
+    
+      setup do
+        @record_a = FakedModel.new(12)
+        @record_b = FakedModel.new(4)
+        Pseudocephalopod.record_slug(@record_a, "awesome")
+        Pseudocephalopod.record_slug(@record_b, "awesome-1")
+        Pseudocephalopod.record_slug(@record_a, "ninjas")
+      end
+    
+      should 'let you lookup a given record id easily' do
+        assert Pseudocephalopod.last_known_slug_id(FakedModel, "felafel").blank?
+        assert Pseudocephalopod.last_known_slug_id(FakedModel, "ninjas-2").blank?
+        assert_equal 12, Pseudocephalopod.last_known_slug_id(FakedModel, "awesome")
+        assert_equal 4,  Pseudocephalopod.last_known_slug_id(FakedModel, "awesome-1")
+        assert_equal 12, Pseudocephalopod.last_known_slug_id(FakedModel, "ninjas")
+      end
+      
+      should 'let you return slug history for a given record'
     
-    setup do
-      @record_a = FakedModel.new(12)
-      @record_b = FakedModel.new(4)
-      Pseudocephalopod.record_slug(@record_a, "awesome")
-      Pseudocephalopod.record_slug(@record_b, "awesome-1")
-      Pseudocephalopod.record_slug(@record_a, "ninjas")
     end
     
-    should 'let you lookup a given record id easily' do
-      assert Pseudocephalopod.last_known_slug_id(FakedModel, "felafel").blank?
-      assert Pseudocephalopod.last_known_slug_id(FakedModel, "ninjas-2").blank?
-      assert_equal 12, Pseudocephalopod.last_known_slug_id(FakedModel, "awesome")
-      assert_equal 4,  Pseudocephalopod.last_known_slug_id(FakedModel, "awesome-1")
-      assert_equal 12, Pseudocephalopod.last_known_slug_id(FakedModel, "ninjas")
+    context 'on a specific record' do
+      
+      should 'by default record slug history' do
+        setup_slugs!
+        user = User.create :name => "Bob"
+        assert_equal [], user.previous_slugs
+        user.update_attributes! :name => "Sal"
+        user.update_attributes! :name => "Red"
+        user.update_attributes! :name => "Jim"
+        assert_same_as_slug user, "red"
+        assert_same_as_slug user, "sal"
+        assert_same_as_slug user, "bob"
+        assert_same_as_slug user, "jim"  
+      end
+      
+      should 'let you reset history for a slug' do
+        setup_slugs!
+        user = User.create :name => "Bob"
+        user.update_attributes! :name => "Sal"
+        user.update_attributes! :name => "Red"
+        user.update_attributes! :name => "Jim"
+        assert_equal ["red", "sal", "bob"], user.previous_slugs
+        user.remove_slug_history!
+        assert_equal [], user.previous_slugs
+        assert_none_for_slug "red"
+        assert_none_for_slug "sal"
+        assert_none_for_slug "bob"
+      end
+
+      should 'let you disable recording of slug history' do
+        setup_slugs! :history => false
+        user = User.create(:name => "Bob")
+        assert !user.respond_to?(:previous_slugs)
+        user.update_attributes! :name => "Red"
+        assert_same_as_slug      user, "red"
+        assert_different_to_slug user, "bob"
+        assert_none_for_slug "bob"
+      end
+      
     end
     
   end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Darcy Laycock
@@ -14,13 +14,13 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-23 00:00:00 +08:00
+date: 2010-04-24 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  type: :runtime
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
@@ -30,32 +30,32 @@ dependencies:
         - 0
         - beta2
         version: 3.0.0.beta2
-  type: :runtime
-  version_requirements: *id001
+  prerelease: false
+  requirement: *id001
 - !ruby/object:Gem::Dependency 
   name: shoulda
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  type: :development
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
         segments: 
         - 0
         version: "0"
-  type: :development
-  version_requirements: *id002
+  prerelease: false
+  requirement: *id002
 - !ruby/object:Gem::Dependency 
   name: reversible_data
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  type: :development
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
         segments: 
         - 0
         version: "0"
-  type: :development
-  version_requirements: *id003
+  prerelease: false
+  requirement: *id003
 description: Super simple slugs for ActiveRecord 3.0 and higher, with support for slug history
 email: sutto@sutto.net
 executables: []
@@ -73,9 +73,9 @@ files:
 - README.md
 - Rakefile
 - lib/generators/pseudocephalopod/slug_migration/slug_migration_generator.rb
-- lib/generators/pseudocephalopod/slug_migration/templates/migration.rb
+- lib/generators/pseudocephalopod/slug_migration/templates/migration.erb
 - lib/generators/pseudocephalopod/slugs/slugs_generator.rb
-- lib/generators/pseudocephalopod/slugs/templates/migration.rb
+- lib/generators/pseudocephalopod/slugs/templates/migration.erb
 - lib/pseudocephalopod.rb
 - lib/pseudocephalopod/active_record_methods.rb
 - lib/pseudocephalopod/caching.rb
@@ -86,6 +86,7 @@ files:
 - lib/pseudocephalopod/slug.rb
 - lib/pseudocephalopod/slug_history.rb
 - lib/pseudocephalopod/version.rb
+- metrics/.gitignore
 - test/caching_test.rb
 - test/helper.rb
 - test/is_sluggable_test.rb