djanowski-permalink_fu 0.1.0

data/README.markdown

@@ -0,0 +1,71 @@
+# PermalinkFu
+
+A simple plugin for creating URL-friendly permalinks (slugs) from attributes.
+
+Uses [`ActiveSupport::Multibyte::Handlers::UTF8Handler`](http://api.rubyonrails.org/classes/ActiveSupport/Multibyte/Handlers/UTF8Handler.html) (part of Rails since 1.2) rather than `iconv` (which is [inconsistent between platforms](http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/243426)) for normalization/decomposition.
+
+
+## Usage
+
+    class Article < ActiveRecord::Base
+      has_permalink :title
+    end
+
+This will escape the title in a before_validation callback, turning e.g. "Föö!! Bàr" into "foo-bar".
+
+The permalink is by default stored in the `permalink` attribute.
+
+    has_permalink :title, :as => :slug
+  
+will store it in `slug` instead.
+
+    has_permalink [:category, :title]
+  
+will store a permalink form of `"#{category}-#{title}"`.
+
+Permalinks are guaranteed unique: "foo-bar-2", "foo-bar-3" etc are used if there are conflicts. You can set the scope of the uniqueness like
+
+    has_permalink :title, :scope => :blog_id
+
+This means that two articles with the same `blog_id` can not have the same permalink, but two articles with different `blog_id`s can.
+
+Two finders are provided:
+
+    Article.find_by_permalink(params[:id])
+    Article.find_by_permalink!(params[:id])
+    
+These methods keep their name no matter what attribute is used to store the permalink.
+
+The `find_by_permalink` method returns `nil` if there is no match; the `find_by_permalink!` method will raise `ActiveRecord::RecordNotFound`.
+
+By default, this fork will override `ActiveRecord::Base#to_param` so that your controllers can still find your models without further work:
+    
+    article.to_param
+    # => "1-foo-bar"
+
+You can change this behavior by using the `param` option:
+
+    has_permalink :title, :param => :permalink
+
+    has_permalink :title, :param => false
+    
+This means that the permalink will be used instead of the primary key (id) in generated URLs. Remember to change your controller code from e.g. `find` to `find_by_permalink!`.
+
+You can 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.
+
+You can use `PermalinkFu.escape` to escape a string manually.
+
+
+## Credits
+
+Originally extracted from [Mephisto](http://mephistoblog.com) by [technoweenie](http://github.com/technoweenie/permalink_fu/).
+
+Conditions added by [Pat Nakajima](http://github.com/nakajima/permalink_fu/).
+
+[Henrik Nyh](http://github.com/technoweenie/permalink_fu/) replaced `iconv` with `ActiveSupport::Multibyte`.

data/Rakefile

@@ -0,0 +1,26 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+
+gem_spec_file = 'permalink_fu.gemspec'
+
+gem_spec = eval(File.read(gem_spec_file)) rescue nil
+
+desc 'Default: run all specs.'
+task :default => :spec
+
+desc "Run all specs in spec directory (excluding plugin specs)"
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts = ['--options', File.join(File.dirname(__FILE__), 'spec', 'spec.opts')]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+desc "Generate the gemspec file."
+task :gemspec do
+  require 'erb'
+
+  File.open(gem_spec_file, 'w') do |f|
+    f.write ERB.new(File.read("#{gem_spec_file}.erb")).result(binding)
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+ActiveRecord::Base.send :include, PermalinkFu

data/lib/permalink_fu.rb

@@ -0,0 +1,143 @@
+begin
+  require "active_support"
+rescue LoadError
+  require "rubygems"
+  require "active_support"
+end
+
+module PermalinkFu
+
+  def self.escape(str)
+    s = ActiveSupport::Multibyte::Handlers::UTF8Handler.normalize(str.to_s, :kd)
+    s.gsub!(/[^\w -]+/n, '')  # strip unwanted characters
+    s.strip! # ohh la la
+    s.downcase!
+    s.gsub!(/[ -]+/, '-')  # separate by single dashes
+    s
+  end
+  
+  def self.included(base)
+    base.extend ClassMethods
+    class << base
+      attr_accessor :permalink_options
+      attr_accessor :permalink_attributes
+      attr_accessor :permalink_field
+    end
+  end
+  
+  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], :as => :category_permalink
+    #
+    #     # add a scope
+    #     has_permalink :title, :scope => :blog_id
+    #
+    #     # add a scope and specify the permalink field name
+    #     has_permalink :title, :as => :slug, :scope => :blog_id
+    #   end
+    #
+    def has_permalink(attr_names = [], options = {})
+      self.permalink_attributes = Array(attr_names)
+      self.permalink_field      = (options.delete(:as) || 'permalink').to_s
+      self.permalink_options    = options
+      before_validation :create_unique_permalink
+      evaluate_attribute_method permalink_field, "def #{self.permalink_field}=(new_value);write_attribute(:#{self.permalink_field}, PermalinkFu.escape(new_value));end", "#{self.permalink_field}="
+      extend  PermalinkFinders
+
+      case options[:param]
+      when false
+        # nothing
+      when :permalink
+        include ToParam
+      else
+        include ToParamWithID
+      end
+    end
+  end
+  
+  module ToParam
+    def to_param
+      send(self.class.permalink_field)
+    end
+  end
+  
+  module ToParamWithID
+    def to_param
+      "#{id}-#{send(self.class.permalink_field)}"
+    end
+  end
+  
+  module PermalinkFinders
+    def find_by_permalink(value)
+      find(:first, :conditions => { permalink_field => value  })
+    end
+    
+    def find_by_permalink!(value)
+      find_by_permalink(value) ||
+      raise(ActiveRecord::RecordNotFound, "Couldn't find #{name} with permalink #{value.inspect}")
+    end
+  end
+  
+protected
+  def create_unique_permalink
+    return unless should_create_permalink?
+    if send(self.class.permalink_field).to_s.empty?
+      send("#{self.class.permalink_field}=", create_permalink_for(self.class.permalink_attributes))
+    end
+    limit   = self.class.columns_hash[self.class.permalink_field].limit
+    base    = send("#{self.class.permalink_field}=", send(self.class.permalink_field)[0..limit - 1])
+    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]
+      conditions.first << " and #{self.class.permalink_options[:scope]} = ?"
+      conditions       << send(self.class.permalink_options[:scope])
+    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)
+    attr_names.collect { |attr_name| send(attr_name).to_s } * " "
+  end
+
+private
+  def should_create_permalink?
+    if 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
+
+  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

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: djanowski-permalink_fu
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Damian Janowski
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-16 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: ""
+email: damian.janowski@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.textile
+files: 
+- lib/permalink_fu.rb
+- init.rb
+- README.markdown
+- MIT-LICENSE
+- Rakefile
+- README.textile
+has_rdoc: false
+homepage: 
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- permalink_fu
+- --main
+- README.textile
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: ActiveRecord plugin for automatically converting fields to permalinks.
+test_files: []
+