permalink_fu 1.0.0

data/lib/permalink_fu.rb

@@ -0,0 +1,176 @@
+require 'yaml'
+require 'digest/sha1'
+
+module PermalinkFu
+  def has_permalink(attr_names = [], permalink_field = nil, options = {})
+    if permalink_field.is_a?(Hash)
+      options = permalink_field
+      permalink_field = nil
+    end
+    ClassMethods.setup_permalink_fu_on self do
+      self.permalink_attributes = Array(attr_names)
+      self.permalink_field      = (permalink_field || 'permalink').to_s
+      self.permalink_options    = {:unique => true}.update(options)
+    end
+    
+    include InstanceMethods
+  end
+
+  class << self
+    # This method does the actual permalink escaping.
+    def escape(str)
+      s = ClassMethods.decode(str)#.force_encoding("UTF-8")
+      s.gsub!(/[^\x00-\x7F]+/, '') # Remove anything non-ASCII entirely (e.g. diacritics).
+      s.gsub!(/[^\w_ \-]+/i,   '') # Remove unwanted chars.
+      s.gsub!(/[ \-]+/i,      '-') # No more than one of the separator in a row.
+      s.gsub!(/^\-|\-$/i,      '') # Remove leading/trailing separator.
+      s.downcase!
+      s.size == 0 ? ClassMethods.random_permalink(str) : s
+    end
+  end
+
+  # Contains class methods for ActiveRecord models that have permalinks
+  module ClassMethods
+    # Contains Unicode codepoints, loading as needed from YAML files
+    CODEPOINTS = Hash.new { |h, k|
+      h[k] = YAML::load_file(File.join(File.dirname(__FILE__), "data", "#{k}.yml"))
+    }
+    
+    class << self
+      def decode(string)
+        string.gsub(/[^\x00-\x7f]/u) do |codepoint|
+          begin
+            CODEPOINTS["x%02x" % (codepoint.unpack("U")[0] >> 8)][codepoint.unpack("U")[0] & 255]
+          rescue
+            "_"
+          end
+        end
+      end
+      
+      def random_permalink(seed = nil)
+        Digest::SHA1.hexdigest("#{seed}#{Time.now.to_s.split(//).sort_by {rand}}")
+      end
+    end
+  
+    def self.setup_permalink_fu_on(base)
+      base.extend self
+      class << base
+        attr_accessor :permalink_options
+        attr_accessor :permalink_attributes
+        attr_accessor :permalink_field
+      end
+
+      yield
+
+      if base.permalink_options[:unique]
+        base.before_validation :create_unique_permalink
+      else
+        base.before_validation :create_common_permalink
+      end
+      class << base
+        alias_method :define_attribute_methods_without_permalinks, :define_attribute_methods
+        alias_method :define_attribute_methods, :define_attribute_methods_with_permalinks
+      end unless base.respond_to?(:define_attribute_methods_without_permalinks)
+    end
+
+    def define_attribute_methods_with_permalinks
+      if (value = define_attribute_methods_without_permalinks) && self.permalink_field
+        class_eval <<-EOV
+          def #{self.permalink_field}=(new_value);
+            write_attribute(:#{self.permalink_field}, new_value.blank? ? '' : PermalinkFu.escape(new_value));
+          end
+        EOV
+      end
+      value
+    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 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::ClassMethods.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
+
+# Extend ActiveRecord functionality
+ActiveRecord::Base.extend PermalinkFu

data/test/permalink_fu_test.rb

@@ -0,0 +1,476 @@
+# encoding: UTF-8
+
+# Load the plugin's test_helper (Rails 2.x needs the path)
+begin
+  require File.dirname(__FILE__) + '/test_helper.rb'
+rescue LoadError
+  require 'test_helper'
+end
+
+class PermalinkFuTest < Test::Unit::TestCase
+  @@samples = {
+    'This IS a Tripped out title!!.!1  (well/ not really)' => 'this-is-a-tripped-out-title1-well-not-really',
+    '////// meph1sto r0x ! \\\\\\' => 'meph1sto-r0x',
+    'āčēģīķļņū' => 'acegiklnu',
+    '中文測試 chinese text' => 'zhong-wen-ce-shi-chinese-text',
+    'fööbär' => 'foobar'
+  }
+
+  @@extra = { 'some-)()()-ExtRa!/// .data==?>    to \/\/test' => 'some-extra-data-to-test' }
+
+  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[:permalink] = 'the permalink'
+    assert_not_equal @m.permalink, @m[: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[: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[: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[: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[: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[: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[: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[:permalink]
+    assert @m[: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[:permalink]
+    assert @m[: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[:permalink]
+    @m.title = "new title"
+    assert @m.valid?
+    assert_equal "old-title", @m[: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[: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[:permalink]
+    @m.title = "new title"
+    assert @m.valid?
+    assert_equal "new-title", @m[: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
+
+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