slugged 0.3.2

data/lib/generators/slugged/slugs/templates/migration.erb

@@ -0,0 +1,20 @@
+class CreateSluggedSlugs < ActiveRecord::Migration
+  
+  def self.up
+    create_table :slugs do |t|
+      t.string   :scope
+      t.string   :slug
+      t.integer  :record_id
+      t.datetime :created_at
+    end
+    add_index :slugs, [:scope, :slug]
+    add_index :slugs, [:scope, :record_id]
+    add_index :slugs, [:scope, :slug, :created_at]
+    add_index :slugs, [:scope, :record_id, :created_at]
+  end
+
+  def self.down
+    drop_table :slugs
+  end
+  
+end

data/lib/slugged.rb

@@ -0,0 +1,80 @@
+require 'active_support'
+require 'active_record'
+require 'uuid'
+
+require 'active_support/dependencies/autoload'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/concern'
+
+module Slugged
+  extend ActiveSupport::Autoload
+
+  mattr_accessor :cache_key_prefix, :cache
+
+  class << self
+
+    def with_counter(prefix, counter = 0)
+      counter < 1 ? prefix : "#{prefix}--#{counter}"
+    end
+
+    def next_value(scope, prefix)
+      counter = 0
+      slug    = self.with_counter(prefix, counter)
+      while scope.with_cached_slug(slug).exists?
+        counter += 1
+        slug     = self.with_counter(prefix, counter)
+      end
+      slug
+    end
+
+    def uuid
+      @uuid ||= UUID.new
+    end
+
+    def generate_uuid_slug
+      uuid.generate
+    end
+
+    def last_known_slug_id(scope, slug)
+      Slugged::Slug.id_for(Slugged.key_for_scope(scope), slug)
+    end
+
+    def record_slug(record, slug)
+      Slugged::Slug.record_slug(record, slug)
+    end
+
+    def previous_slugs_for(record)
+      Slugged::Slug.previous_for(record)
+    end
+
+    def remove_slug_history_for(record)
+      Slugged::Slug.remove_history_for(record)
+    end
+
+    def key_for_scope(scope)
+      if scope.respond_to?(:slug_scope_key)
+        scope.slug_scope_key
+      elsif scope.class.respond_to?(:slug_scope_key)
+        scope.class.slug_scope_key
+      else
+        scope.to_s
+      end
+    end
+
+  end
+
+  self.cache_key_prefix ||= "cached-slugs"
+
+  autoload :Caching
+  autoload :Scopes
+  autoload :Finders
+  autoload :SlugHistory
+  autoload :Slug
+  autoload :MemoryCache
+
+  require 'slugged/active_record_methods'
+  ActiveRecord::Base.extend Slugged::ActiveRecordMethods
+
+  require 'slugged/railtie' if defined?(Rails::Railtie)
+
+end

data/lib/slugged/active_record_methods.rb

@@ -0,0 +1,112 @@
+module Slugged
+  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 Slugged::Scopes
+      extend Slugged::Finders
+      self.slug_source = source.to_sym
+      set_slug_options options
+      alias_method :to_param, :to_slug      if use_slug_to_param
+      include Slugged::SlugHistory if use_slug_history
+      include Slugged::Caching     if use_slug_cache
+      before_save :autogenerate_slug
+    end
+    
+    module InstanceMethods
+      
+      def to_slug
+        cached_slug.present? ? cached_slug : id.to_s
+      end
+      
+      def generate_slug
+        slug_value = send(self.slug_source)
+        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 = Slugged.next_value(scope, slug_value)
+          write_attribute self.cached_slug_column, slug_value
+        elsif self.default_uuid_slug
+          write_attribute self.cached_slug_column, Slugged.generate_uuid_slug
+        else
+          write_attribute self.cached_slug_column, nil
+        end
+      end
+      
+      def generate_slug!
+        generate_slug
+        save :validate => false
+      end
+      
+      def autogenerate_slug
+        generate_slug if should_generate_slug?
+      end
+      
+      def should_generate_slug?
+        send(self.cached_slug_column).blank? || (self.sync_slugs && send(:"#{self.slug_source}_changed?"))
+      end
+      
+      def has_better_slug?
+        found_via_slug.present? && found_via_slug != to_slug
+      end
+      
+      def slug_scope_key(nested_scope = [])
+        self.class.slug_scope_key(nested_scope)
+      end
+      
+    end
+    
+    module ClassMethods
+      
+      def update_all_slugs!
+        find_each { |r| r.generate_slug! }
+      end
+      
+      def slug_scope_key(nested_scope = [])
+        ([table_name, slug_scope] + Array(nested_scope)).flatten.compact.join("|")
+      end
+      
+      def slug_scope_relation(record)
+        has_slug_scope? ? where(slug_scope => record.send(slug_scope)) : scoped
+      end
+      
+      protected
+      
+      def has_slug_scope?
+        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, Slugged::Slug.usable?)
+      end
+      
+      def set_slug_convertor(convertor)
+        if convertor.present?
+          unless convertor.respond_to?(:call)
+            convertor_key = convertor.to_sym
+            convertor     = proc { |r| r.try(convertor_key) }
+          end
+          self.slug_convertor_proc = convertor
+        else
+          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
+      
+    end    
+  end
+end

data/lib/slugged/caching.rb

@@ -0,0 +1,87 @@
+require 'digest/sha2'
+
+module Slugged
+  # Mixin for adding simple caching support to models using slugged.
+  # 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
+    extend ActiveSupport::Concern
+    
+    mattr_accessor :cache_expires_in
+    # Cache for 10 minutes by default.
+    self.cache_expires_in = 600
+   
+    included do
+      after_save :globally_cache_slug
+    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 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?
+          return find(cached_id, options).tap { |r| r.found_via_slug = slug }
+        end
+        # Otherwise, fallback to the normal approach.
+        super.tap do |record|
+          cache_slug_lookup!(slug, record) if record.present?
+        end
+      end
+      
+      # Returns a slug cache key for a given slug.
+      def slug_cache_key(slug)
+        [Slugged.cache_key_prefix, slug_scope_key(Digest::SHA256.hexdigest(slug.to_s.strip))].compact.join("/")
+      end
+      
+      def has_cache_for_slug?(slug)
+        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)
+        return if Slugged.cache.blank?
+        cache = Slugged.cache
+        key   = slug_cache_key(slug)
+        # Set an expires in option for caching.
+        caching_options = Hash.new.tap do |hash|
+          expiry = Slugged::Caching.cache_expires_in
+          hash[:expires_in] = expiry.to_i if expiry.present?
+        end
+        record.nil? ? cache.delete(key) : cache.write(key, record.id, caching_options)
+      end
+      
+      protected
+      
+      def lookup_cached_id_from_slug(slug)
+        Slugged.cache && Slugged.cache.read(slug_cache_key(slug))
+      end
+      
+    end
+    
+  end
+end

data/lib/slugged/finders.rb

@@ -0,0 +1,19 @@
+module Slugged
+  module Finders
+    
+    def find_using_slug(slug, options = {})
+      slug = slug.to_s
+      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 use_slug_history
+      value.found_via_slug = slug if value.present?
+      value
+    end
+    
+    def find_using_slug!(slug, options = {})
+      find_using_slug(slug, options) or raise ActiveRecord::RecordNotFound
+    end
+    
+  end
+end

data/lib/slugged/memory_cache.rb

@@ -0,0 +1,29 @@
+module Slugged
+  # Implements a simple cache store that uses the
+  # current processes memory. This makes is primarily
+  # used for testing purposes in the situations where
+  # caching is used.
+  class MemoryCache
+    
+    def self.write(key, value, options = {})
+      cache[key.to_s] = value
+    end
+    
+    def self.read(key)
+      cache[key.to_s]
+    end
+    
+    def self.delete(key)
+      cache.delete key.to_s
+    end
+    
+    def self.reset!
+      @cache = nil
+    end
+    
+    def self.cache
+      @cache ||= {}
+    end
+    
+  end
+end

data/lib/slugged/railtie.rb

@@ -0,0 +1,9 @@
+module Slugged
+  class Railtie < Rails::Railtie
+    
+    initializer "slugged.initialize_cache" do
+      Slugged.cache = Rails.cache if Rails.cache.present?
+    end
+    
+  end
+end

data/lib/slugged/scopes.rb

@@ -0,0 +1,13 @@
+module Slugged
+  module Scopes
+    
+    def with_cached_slug(slug)
+      where(self.cached_slug_column => slug.to_s)
+    end
+    
+    def other_than(record)
+      record.new_record? ? scoped : where("#{quoted_table_name}.#{connection.quote_column_name(:id)} != ?", record.id)
+    end
+    
+  end
+end

data/lib/slugged/slug.rb

@@ -0,0 +1,36 @@
+module Slugged
+  class Slug < ActiveRecord::Base
+    set_table_name "slugs"
+  
+    validates_presence_of :record_id, :slug, :scope
+  
+    scope :ordered,    order('created_at DESC')
+    scope :only_slug,  select(:slug)
+    scope :for_record, lambda { |r| where(:record_id => r.id, :scope => Slugged.key_for_scope(r)) }
+    scope :for_slug,   lambda { |scope, slug| where(:scope=> scope.to_s, :slug => slug.to_s)}
+  
+    def self.id_for(scope, slug)
+      ordered.for_slug(scope, slug).first.try(:record_id)
+    end
+    
+    def self.record_slug(record, slug)
+      scope = Slugged.key_for_scope(record)
+      # Clear slug history in this scope before recording the new slug
+      for_slug(scope, slug).delete_all
+      create :scope => scope, :record_id => record.id, :slug => slug.to_s
+    end
+    
+    def self.previous_for(record)
+      ordered.only_slug.for_record(record).all.map(&:slug)
+    end
+    
+    def self.remove_history_for(record)
+      for_record(record).delete_all
+    end
+  
+    def self.usable?
+      table_exists? rescue false
+    end
+  
+  end
+end

data/lib/slugged/slug_history.rb

@@ -0,0 +1,41 @@
+module Slugged
+  module SlugHistory
+    extend ActiveSupport::Concern
+    
+    included do
+      after_save :record_slug_changes
+      after_destroy :remove_slug_history!
+    end
+   
+    module InstanceMethods
+      
+      def previous_slugs
+        Slugged.previous_slugs_for(self)
+      end
+      
+      def remove_slug_history!
+        Slugged.remove_slug_history_for(self)
+      end
+      
+      protected
+      
+      def record_slug_changes
+        slug_column = self.cached_slug_column
+        return unless send(:"#{slug_column}_changed?")
+        value = send(:"#{slug_column}_was")
+        Slugged.record_slug(self, value) if value.present?
+      end
+      
+    end
+    
+    module ClassMethods
+      
+      def find_using_slug_history(slug, options = {})
+        id = Slugged.last_known_slug_id(self, slug)
+        id.present? ? find_by_id(id, options) : nil
+      end
+      
+    end
+    
+  end
+end