sayso-permalink_fu 0.0.1.001

data/.autotest

@@ -0,0 +1,36 @@
+class Autotest
+  ##
+  # Convert a path in a string, s, into a class name, changing
+  # underscores to CamelCase, etc.
+ 
+  def path_to_classname(s)
+    sep = File::SEPARATOR
+    f = s.sub(/^test#{sep}/, '').sub(/\.rb$/, '').split(sep)
+    f = f.map { |path| path.split(/_|(\d+)/).map { |seg| seg.capitalize }.join }
+    f = f.map { |path| path =~ /Test$/ ? path : "#{path}Test"  }
+    f.join('::')
+  end
+end
+
+Autotest.add_hook :initialize do |at|
+  unless ARGV.empty?
+    if ARGV[0] == '-d'
+      at.find_directories = ARGV[1..-1].dup
+    else
+      at.find_directories = []
+      at.extra_files = ARGV.dup
+    end
+  end
+  
+  # doesn't seem to work
+  # at.clear_mappings
+  
+  at.add_mapping(/^lib\/.*\.rb$/) do |filename, _|
+    possible = File.basename(filename, 'rb').gsub '_', '_?'
+    files_matching %r%^test/.*#{possible}_test\.rb$%
+  end
+
+  at.add_mapping(/^test.*\/.*test\.rb$/) do |filename, _|
+    filename
+  end
+end

data/.gitignore

@@ -0,0 +1 @@
+nbproject/

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in permalink_fu.gemspec
+gemspec

data/README

@@ -0,0 +1,40 @@
+PermalinkFu
+
+This is a simple plugin extracted from Mephisto for creating permalinks from attributes.
+
+  class Article < ActiveRecord::Base
+    has_permalink :title
+  end
+
+This will escape the title, making it fit to use in a URL in the after_validation callback.
+
+Use PermalinkFu.escape to escape a string manually if you like.
+
+If you're having issues with Iconv, you can manually tweak PermalinkFu.translation_to PermalinkFu.translation_from.
+These are set to nil if Iconv is not loaded.  You can also manually set them to nil if you don't want to use iconv.
+
+[Added 3.13.2008 by Pat Nakajima] You can now add conditions to #has_permalink like so:
+
+	class Article < ActiveRecord::Base
+	  has_permalink :title, :if => Proc.new { |article| article.needs_permalink? }
+	end
+
+Use the :if or :unless options to specify a Proc, method, or string to be called or evaluated. The permalink
+will only be generated if the option evaluates to true.
+
+
+[Added 3.11.2009 by Martin Emde] Make permalink_fu update your permalink everytime the dependent field(s) change.
+
+	class Article < ActiveRecord::Base
+	  has_permalink :title, :update => true
+	end
+
+This will update your permalink every time title changes. Rails versions with _changed? methods will reduce the checks for uniqueness to only when the permalink field is changed.
+
+Without :update set to true, your permalink will be set one time and subsequent changes to the field
+(title in this example) will not affect the permalink field. To regenerate the permalink field,
+set it to nil or a blank string within your model.
+
+Old versions of rails without _changed? attribute support will result in the permalink field being regenerated every save.
+
+[Bug Fixed 3.11.2009] Permalink was not being checked for uniqueness when set directly with permalink= on rails versions with _changed?

data/Rakefile

@@ -0,0 +1,13 @@
+require 'rake'
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end
+
+desc 'Default: run test examples'
+task :default => 'test'

data/lib/permalink_fu.rb

@@ -0,0 +1,39 @@
+require File.join(File.dirname(__FILE__), 'permalink_fu', 'railtie')
+require File.join(File.dirname(__FILE__), 'permalink_fu', 'active_record')
+
+begin
+  require 'iconv'
+rescue Object
+  puts "No Iconv found, you might want to look into it."
+end
+
+module PermalinkFu
+
+  class << self
+
+    # This method does the actual permalink escaping.
+    def escape(string)
+      result = ::ActiveSupport::Inflector.transliterate(string.to_s)
+      result = self.iconvify(result)
+      result.gsub!(/[^\x00-\x7F]+/, '') # Remove anything non-ASCII entirely (e.g. diacritics).
+      result.gsub!(/[^\w_ \-]+/i,   '') # Remove unwanted chars.
+      result.gsub!(/[ \-]+/i,      '-') # No more than one of the separator in a row.
+      result.gsub!(/^\-|\-$/i,      '') # Remove leading/trailing separator.
+      result.downcase!
+      result.size.zero? ? random_permalink : result
+    rescue
+      random_permalink
+    end
+
+    def random_permalink
+      ::ActiveSupport::SecureRandom.hex(16)
+    end
+
+    def iconvify(string)
+      return string unless defined?(Iconv)
+      return Iconv.iconv('ascii//translit//IGNORE', 'utf-8', string).to_s
+    end
+
+  end
+
+end

data/lib/permalink_fu/active_record.rb

@@ -0,0 +1,160 @@
+module PermalinkFu
+
+  module ActiveRecord
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # This is the plugin method available on all ActiveRecord models.
+    module ClassMethods
+      # Specifies the given field(s) as a permalink, meaning it is passed through PermalinkFu.escape and set to the permalink_field.  This
+      # is done
+      #
+      #   class Foo < ActiveRecord::Base
+      #     # stores permalink form of #title to the #permalink attribute
+      #     has_permalink :title
+      #
+      #     # stores a permalink form of "#{category}-#{title}" to the #permalink attribute
+      #
+      #     has_permalink [:category, :title]
+      #
+      #     # stores permalink form of #title to the #category_permalink attribute
+      #     has_permalink [:category, :title], :category_permalink
+      #
+      #     # add a scope
+      #     has_permalink :title, :scope => :blog_id
+      #
+      #     # add a scope and specify the permalink field name
+      #     has_permalink :title, :slug, :scope => :blog_id
+      #
+      #     # do not bother checking for a unique scope
+      #     has_permalink :title, :unique => false
+      #
+      #     # update the permalink every time the attribute(s) change
+      #     # without _changed? methods (old rails version) this will rewrite the permalink every time
+      #     has_permalink :title, :update => true
+      #
+      #   end
+      #
+      def has_permalink(attr_names = [], permalink_field = nil, options = {})
+        include InstanceMethods
+
+        if permalink_field.is_a?(Hash)
+          options = permalink_field
+          permalink_field = nil
+        end
+
+
+        cattr_accessor :permalink_options
+        cattr_accessor :permalink_attributes
+        cattr_accessor :permalink_field
+
+        self.permalink_attributes = Array(attr_names)
+        self.permalink_field      = (permalink_field || 'permalink').to_s
+        self.permalink_options    = {:unique => true}.update(options)
+
+        if self.permalink_options[:unique]
+          before_validation :create_unique_permalink
+        else
+          before_validation :create_common_permalink
+        end
+
+        define_method :"#{self.permalink_field}=" do |value|
+          write_attribute(self.permalink_field, value.blank? ? '' : PermalinkFu.escape(value))
+        end
+
+      end
+    end
+
+    # This contains instance methods for ActiveRecord models that have permalinks.
+    module InstanceMethods
+
+      protected
+
+      def create_common_permalink
+        return unless should_create_permalink?
+        if read_attribute(self.class.permalink_field).blank? || permalink_fields_changed?
+          send("#{self.class.permalink_field}=", create_permalink_for(self.class.permalink_attributes))
+        end
+
+        # Quit now if we have the changed method available and nothing has changed
+        permalink_changed = "#{self.class.permalink_field}_changed?"
+        return if respond_to?(permalink_changed) && !send(permalink_changed)
+
+        # Otherwise find the limit and crop the permalink
+        limit   = self.class.columns_hash[self.class.permalink_field].limit
+        base    = send("#{self.class.permalink_field}=", read_attribute(self.class.permalink_field)[0..limit - 1])
+        [limit, base]
+      end
+
+      def create_unique_permalink
+        limit, base = create_common_permalink
+        return if limit.nil? # nil if the permalink has not changed or :if/:unless fail
+        counter = 1
+        # oh how i wish i could use a hash for conditions
+        conditions = ["#{self.class.permalink_field} = ?", base]
+        unless new_record?
+          conditions.first << " and id != ?"
+          conditions       << id
+        end
+        if self.class.permalink_options[:scope]
+          [self.class.permalink_options[:scope]].flatten.each do |scope|
+            value = send(scope)
+            if value
+              conditions.first << " and #{scope} = ?"
+              conditions       << send(scope)
+            else
+              conditions.first << " and #{scope} IS NULL"
+            end
+          end
+        end
+
+        while ::ActiveRecord::Base.uncached{self.class.exists?(conditions)}
+          suffix = "-#{counter += 1}"
+          conditions[1] = "#{base[0..limit-suffix.size-1]}#{suffix}"
+          send("#{self.class.permalink_field}=", conditions[1])
+        end
+      end
+
+      def create_permalink_for(attr_names)
+        str = attr_names.collect { |attr_name| send(attr_name).to_s } * " "
+        str.blank? ? PermalinkFu.random_permalink : str
+      end
+
+      private
+      def should_create_permalink?
+        if self.class.permalink_field.blank?
+          false
+        elsif self.class.permalink_options[:if]
+          evaluate_method(self.class.permalink_options[:if])
+        elsif self.class.permalink_options[:unless]
+          !evaluate_method(self.class.permalink_options[:unless])
+        else
+          true
+        end
+      end
+
+      # Don't even check _changed? methods unless :update is set
+      def permalink_fields_changed?
+        return false unless self.class.permalink_options[:update]
+        self.class.permalink_attributes.any? do |attribute|
+          changed_method = "#{attribute}_changed?"
+          respond_to?(changed_method) ? send(changed_method) : true
+        end
+      end
+
+      def evaluate_method(method)
+        case method
+        when Symbol
+          send(method)
+        when String
+          eval(method, instance_eval { binding })
+        when Proc, Method
+          method.call(self)
+        end
+      end
+    end
+  end
+
+end

data/lib/permalink_fu/railtie.rb

@@ -0,0 +1,19 @@
+require 'rails'
+
+module PermalinkFu
+  
+  class Railtie < ::Rails::Railtie
+    
+    initializer 'permalink_fu.insert_into_active_record' do
+      ::ActiveSupport.on_load :active_record do
+        include PermalinkFu::ActiveRecord
+      end
+    end
+
+    # rake_tasks do
+    #  load "tasks/permalink_fu.rake"
+    # end
+
+  end
+
+end

data/permalink_fu.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |s|
+  s.name        = "sayso-permalink_fu"
+  s.version     = "0.0.1.001"
+  s.authors     = ['SaySo']
+  s.platform    = Gem::Platform::RUBY
+  s.rubyforge_project = "knapo-permalink_fu"
+
+
+  s.homepage    = "http://github.com/sayso/permalink_fu"
+  s.summary      = 'Simple plugin extracted from Mephisto for creating permalinks from attributes - forked and gemified for sayso'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_dependency('rails', '>= 3.0.5')
+  s.add_dependency('activerecord', '>= 3.0.5')
+  s.add_dependency('activesupport', '>= 3.0.5')
+end

data/test/permalink_fu_test.rb

@@ -0,0 +1,323 @@
+# encoding: UTF-8
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class PermalinkFuTest < Test::Unit::TestCase
+  @@samples = {
+    'This IS a Tripped out title!!.!1  (well/ not really)'.freeze => 'this-is-a-tripped-out-title1-well-not-really'.freeze,
+    '////// meph1sto r0x ! \\\\\\'.freeze => 'meph1sto-r0x'.freeze,
+    'āčēģīķļņū'.freeze => 'acegiklnu'.freeze,
+    '中文測試 chinese text'.freeze => 'chinese-text'.freeze,
+    'fööbär'.freeze => 'foobar'.freeze
+  }
+
+  @@extra = { 'some-)()()-ExtRa!/// .data==?>    to \/\/test'.freeze => 'some-extra-data-to-test'.freeze }
+
+  def test_basemodel
+    @m = BaseModel.new
+    assert @m.valid?
+    assert_equal @m.id, nil
+    assert_equal @m.title, nil
+    assert_equal @m.permalink, nil
+    assert_equal @m.extra, nil
+    assert_equal @m.foo, nil
+  end
+
+  def test_set_new_permalink_attributes_on_sub_class
+    @m = ClassModel.new
+    @m.title = 'foo'
+    @m.extra = 'bar'
+    assert @m.valid?
+    assert_equal @m.permalink, 'foo'
+    
+    @m = SubClassHasPermalinkModel.new
+    @m.title = 'foo'
+    @m.extra = 'bar'
+    assert @m.valid?
+    assert_equal @m.permalink, 'foo-bar'
+  end
+  
+  def test_should_not_inherit_permalink_attributes
+    @m = SubClassNoPermalinkModel.new
+    @m.title = 'foo'
+    assert @m.valid?
+    assert_equal @m.permalink, nil
+  end
+
+  def test_should_escape_permalinks
+    @@samples.each do |from, to|
+      assert_equal to, PermalinkFu.escape(from)
+    end
+  end
+  
+  def test_should_escape_activerecord_model
+    @m = MockModel.new
+    @@samples.each do |from, to|
+      @m.title = from; @m.permalink = nil
+      assert @m.valid?
+      assert_equal to, @m.permalink
+    end
+  end
+  
+  def test_should_escape_activerecord_model_with_existing_permalink
+    @m = MockModel.new
+    @@samples.each do |from, to|
+      @m.title = 'whatever'; @m.permalink = from
+      assert @m.valid?
+      assert_equal to, @m.permalink
+    end
+  end
+  
+  def test_multiple_attribute_permalink
+    @m = MockModelExtra.new
+    @@samples.each do |from, to|
+      @@extra.each do |from_extra, to_extra|
+        @m.title = from; @m.extra = from_extra; @m.permalink = nil
+        assert @m.valid?
+        assert_equal "#{to}-#{to_extra}", @m.permalink
+      end
+    end
+  end
+
+  def test_should_create_unique_permalink
+    @m = MockModel.new
+    @m.title = 'foo'
+    assert @m.valid?
+    assert_equal 'foo-2', @m.permalink
+    
+    @m.title = 'bar'
+    @m.permalink = nil
+    assert @m.valid?
+    assert_equal 'bar-3', @m.permalink
+  end
+  
+  def test_should_create_unique_permalink_when_assigned_directly
+    @m = MockModel.new
+    @m.permalink = 'foo'
+    assert @m.valid?
+    assert_equal 'foo-2', @m.permalink
+    
+    # should always check itself for uniqueness when not respond_to?(:permalink_changed?)
+    @m.permalink = 'bar'
+    assert @m.valid?
+    assert_equal 'bar-3', @m.permalink
+  end
+  
+  def test_should_common_permalink_if_unique_is_false
+    @m = CommonMockModel.new
+    @m.permalink = 'foo'
+    assert @m.valid?
+    assert_equal 'foo', @m.permalink
+  end
+  
+  def test_should_not_check_itself_for_unique_permalink_if_unchanged
+    @m = MockModel.new
+    @m.id = 2
+    @m.permalink = 'bar-2'
+    @m.instance_eval do
+      @changed_attributes = {}
+    end
+    assert @m.valid?
+    assert_equal 'bar-2', @m.permalink
+  end
+
+  def test_should_check_itself_for_unique_permalink_if_permalink_field_changed
+    @m = PermalinkChangeableMockModel.new
+    @m.permalink_will_change!
+    @m.permalink = 'foo'
+    assert @m.valid?
+    assert_equal 'foo-2', @m.permalink
+  end
+
+  def test_should_not_check_itself_for_unique_permalink_if_permalink_field_not_changed
+    @m = PermalinkChangeableMockModel.new
+    @m.permalink = 'foo'
+    assert @m.valid?
+    assert_equal 'foo', @m.permalink
+  end
+  
+  def test_should_create_unique_scoped_permalink
+    @m = ScopedModel.new
+    @m.permalink = 'foo'
+    assert @m.valid?
+    assert_equal 'foo-2', @m.permalink
+  
+    @m.foo = 5
+    @m.permalink = 'foo'
+    assert @m.valid?
+    assert_equal 'foo', @m.permalink
+  end
+  
+  def test_should_limit_permalink
+    @old = MockModel.columns_hash['permalink'].instance_variable_get(:@limit)
+    MockModel.columns_hash['permalink'].instance_variable_set(:@limit, 2)
+    @m   = MockModel.new
+    @m.title = 'BOO'
+    assert @m.valid?
+    assert_equal 'bo', @m.permalink
+  ensure
+    MockModel.columns_hash['permalink'].instance_variable_set(:@limit, @old)
+  end
+  
+  def test_should_limit_unique_permalink
+    @old = MockModel.columns_hash['permalink'].instance_variable_get(:@limit)
+    MockModel.columns_hash['permalink'].instance_variable_set(:@limit, 3)
+    @m   = MockModel.new
+    @m.title = 'foo'
+    assert @m.valid?
+    assert_equal 'f-2', @m.permalink
+  ensure
+    MockModel.columns_hash['permalink'].instance_variable_set(:@limit, @old)
+  end
+  
+  def test_should_abide_by_if_proc_condition
+    @m = IfProcConditionModel.new
+    @m.title = 'dont make me a permalink'
+    assert @m.valid?
+    assert_nil @m.permalink
+  end
+  
+  def test_should_abide_by_if_method_condition
+    @m = IfMethodConditionModel.new
+    @m.title = 'dont make me a permalink'
+    assert @m.valid?
+    assert_nil @m.permalink
+  end
+  
+  def test_should_abide_by_if_string_condition
+    @m = IfStringConditionModel.new
+    @m.title = 'dont make me a permalink'
+    assert @m.valid?
+    assert_nil @m.permalink
+  end
+  
+  def test_should_abide_by_unless_proc_condition
+    @m = UnlessProcConditionModel.new
+    @m.title = 'make me a permalink'
+    assert @m.valid?
+    assert_not_nil @m.permalink
+  end
+  
+  def test_should_abide_by_unless_method_condition
+    @m = UnlessMethodConditionModel.new
+    @m.title = 'make me a permalink'
+    assert @m.valid?
+    assert_not_nil @m.permalink
+  end
+  
+  def test_should_abide_by_unless_string_condition
+    @m = UnlessStringConditionModel.new
+    @m.title = 'make me a permalink'
+    assert @m.valid?
+    assert_not_nil @m.permalink
+  end
+  
+  def test_should_allow_override_of_permalink_method
+    @m = OverrideModel.new
+    @m.write_attribute(:permalink, 'the permalink')
+    assert_not_equal @m.permalink, @m.read_attribute(:permalink)
+  end
+  
+  def test_should_create_permalink_from_attribute_not_attribute_accessor
+    @m = OverrideModel.new
+    @m.title = 'the permalink'
+    assert @m.valid?
+    assert_equal 'the-permalink', @m.read_attribute(:permalink)
+  end
+  
+  def test_should_not_update_permalink_unless_field_changed
+    @m = NoChangeModel.new
+    @m.title = 'the permalink'
+    @m.permalink = 'unchanged'
+    assert @m.valid?
+    assert_equal 'unchanged', @m.read_attribute(:permalink)
+  end
+  
+  def test_should_not_update_permalink_without_update_set_even_if_field_changed
+    @m = ChangedWithoutUpdateModel.new
+    @m.title = 'the permalink'
+    @m.permalink = 'unchanged'
+    assert @m.valid?
+    assert_equal 'unchanged', @m.read_attribute(:permalink)
+  end
+  
+  def test_should_update_permalink_if_changed_method_does_not_exist
+    @m = OverrideModel.new
+    @m.title = 'the permalink'
+    assert @m.valid?
+    assert_equal 'the-permalink', @m.read_attribute(:permalink)
+  end
+
+  def test_should_update_permalink_if_the_existing_permalink_is_nil
+    @m = NoChangeModel.new
+    @m.title = 'the permalink'
+    @m.permalink = nil
+    assert @m.valid?
+    assert_equal 'the-permalink', @m.read_attribute(:permalink)
+  end
+
+  def test_should_update_permalink_if_the_existing_permalink_is_blank
+    @m = NoChangeModel.new
+    @m.title = 'the permalink'
+    @m.permalink = ''
+    assert @m.valid?
+    assert_equal 'the-permalink', @m.read_attribute(:permalink)
+  end
+
+  def test_should_assign_a_random_permalink_if_the_title_is_nil
+    @m = NoChangeModel.new
+    @m.title = nil
+    assert @m.valid?
+    assert_not_nil @m.read_attribute(:permalink)
+    assert @m.read_attribute(:permalink).size > 0
+  end
+
+  def test_should_assign_a_random_permalink_if_the_title_has_no_permalinkable_characters
+    @m = NoChangeModel.new
+    @m.title = '////'
+    assert @m.valid?
+    assert_not_nil @m.read_attribute(:permalink)
+    assert @m.read_attribute(:permalink).size > 0
+  end
+
+  def test_should_update_permalink_the_first_time_the_title_is_set
+    @m = ChangedWithoutUpdateModel.new
+    @m.title = "old title"
+    assert @m.valid?
+    assert_equal "old-title", @m.read_attribute(:permalink)
+    @m.title = "new title"
+    assert @m.valid?
+    assert_equal "old-title", @m.read_attribute(:permalink)
+  end
+
+  def test_should_not_update_permalink_if_already_set_even_if_title_changed
+    @m = ChangedWithoutUpdateModel.new
+    @m.permalink = "old permalink"
+    @m.title = "new title"
+    assert @m.valid?
+    assert_equal "old-permalink", @m.read_attribute(:permalink)
+  end
+
+  def test_should_update_permalink_every_time_the_title_is_changed
+    @m = ChangedWithUpdateModel.new
+    @m.title = "old title"
+    assert @m.valid?
+    assert_equal "old-title", @m.read_attribute(:permalink)
+    @m.title = "new title"
+    assert @m.valid?
+    assert_equal "new-title", @m.read_attribute(:permalink)
+  end
+  
+  def test_should_work_correctly_for_scoped_fields_with_nil_value
+    s1 = ScopedModelForNilScope.new
+    s1.title = 'ack'
+    s1.foo = 3
+    assert s1.valid?
+    assert_equal 'ack', s1.permalink
+    
+    s2 = ScopedModelForNilScope.new
+    s2.title = 'ack'
+    s2.foo = nil
+    assert s2.valid?
+    assert_equal 'ack-2', s2.permalink
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,162 @@
+require 'test/unit'
+require File.join(File.dirname(__FILE__), '../lib/permalink_fu')
+
+begin
+  require 'rubygems'
+  require 'ruby-debug'
+  Debugger.start
+rescue LoadError
+  # no ruby debugger
+end
+
+gem 'activerecord'
+require 'active_record'
+require File.join(File.dirname(__FILE__), '../init')
+
+class BaseModel < ActiveRecord::Base
+  cattr_accessor :columns
+  @@columns ||= []
+  
+  def self.column(name, sql_type = nil, default = nil, null = true)
+    columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default, sql_type, null)
+  end
+  
+  def self.exists?(*args)
+    false
+  end
+  
+  column :id,         'int(11)'
+  column :title,      'varchar(100)'
+  column :permalink,  'varchar(100)'
+  column :extra,      'varchar(100)'
+  column :foo,        'varchar(100)'
+  
+end
+
+class ClassModel < BaseModel
+  has_permalink :title
+end
+
+class SubClassHasPermalinkModel < ClassModel
+  has_permalink [:title, :extra]
+end
+
+class SubClassNoPermalinkModel < ClassModel
+end
+
+class MockModel < BaseModel
+  def self.exists?(conditions)
+    if conditions[1] == 'foo'   || conditions[1] == 'bar' || 
+      (conditions[1] == 'bar-2' && conditions[2] != 2)
+      true
+    else
+      false
+    end
+  end
+
+  has_permalink :title
+end
+
+class PermalinkChangeableMockModel < BaseModel
+  def self.exists?(conditions)
+    if conditions[1] == 'foo'
+      true
+    else
+      false
+    end
+  end
+
+  has_permalink :title
+
+  def permalink_changed?
+    @permalink_changed
+  end
+
+  def permalink_will_change!
+    @permalink_changed = true
+  end
+end
+
+class CommonMockModel < BaseModel
+  def self.exists?(conditions)
+    false # oh noes
+  end
+
+  has_permalink :title, :unique => false
+end
+
+class ScopedModel < BaseModel
+  def self.exists?(conditions)
+    if conditions[1] == 'foo' && conditions[2] != 5
+      true
+    else
+      false
+    end
+  end
+
+  has_permalink :title, :scope => :foo
+end
+
+class ScopedModelForNilScope < BaseModel
+  def self.exists?(conditions)
+    (conditions[0] == 'permalink = ? and foo IS NULL') ? (conditions[1] == 'ack') : false
+  end
+
+  has_permalink :title, :scope => :foo
+end
+
+class OverrideModel < BaseModel
+  has_permalink :title
+  
+  def permalink
+    'not the permalink'
+  end
+end
+
+class ChangedWithoutUpdateModel < BaseModel
+  has_permalink :title  
+  def title_changed?; true; end
+end
+
+class ChangedWithUpdateModel < BaseModel
+  has_permalink :title, :update => true 
+  def title_changed?; true; end
+end
+
+class NoChangeModel < BaseModel
+  has_permalink :title, :update => true
+  def title_changed?; false; end
+end
+
+class IfProcConditionModel < BaseModel
+  has_permalink :title, :if => Proc.new { |obj| false }
+end
+
+class IfMethodConditionModel < BaseModel
+  has_permalink :title, :if => :false_method
+  
+  def false_method; false; end
+end
+
+class IfStringConditionModel < BaseModel
+  has_permalink :title, :if => 'false'
+end
+
+class UnlessProcConditionModel < BaseModel
+  has_permalink :title, :unless => Proc.new { |obj| false }
+end
+
+class UnlessMethodConditionModel < BaseModel
+  has_permalink :title, :unless => :false_method
+  
+  def false_method; false; end
+end
+
+class UnlessStringConditionModel < BaseModel
+  has_permalink :title, :unless => 'false'
+end
+
+class MockModelExtra < BaseModel
+  has_permalink [:title, :extra]
+end
+

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+name: sayso-permalink_fu
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1.001
+platform: ruby
+authors: 
+- SaySo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-23 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.0.5
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.0.5
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.0.5
+  type: :runtime
+  version_requirements: *id003
+description: 
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .autotest
+- .gitignore
+- Gemfile
+- README
+- Rakefile
+- lib/permalink_fu.rb
+- lib/permalink_fu/active_record.rb
+- lib/permalink_fu/railtie.rb
+- permalink_fu.gemspec
+- test/permalink_fu_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/sayso/permalink_fu
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: knapo-permalink_fu
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Simple plugin extracted from Mephisto for creating permalinks from attributes - forked and gemified for sayso
+test_files: 
+- test/permalink_fu_test.rb
+- test/test_helper.rb