isa-friendly_id_datamapper 3.2.0.beta1

data/ChangeLog.md

@@ -0,0 +1,8 @@
+# FriendlyId DataMapper Adapter Changelog
+
+* Table of Contents
+{:toc}
+
+## 3.1.0.beta1 (2010-09-13)
+
+* Initial beta release.

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Norman Clarke, Alex Coles
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,63 @@
+# FriendlyId DataMapper Adapter
+
+This is an pre-release (beta) adapter for
+[FriendlyId](http://norman.github.com/friendly_id) using DataMapper.
+
+## FriendlyId Features
+
+It currently supports all of FriendlyId's features except:
+
+* Rails Generator
+* Support for multiple finders
+
+Currently, only finds using `get` is supported.
+
+    @post = Post.get("this-is-a-title")
+    @post.friendly_id # this-is-a-title
+
+## Compatibility
+
+The FriendlyId DataMapper Adapter keeps in lock-step with major and
+minor versions of the FriendlyId gem, i.e.
+`friendly_id_datamapper 3.1.x` is compatible with `friendly_id 3.1.x series`.
+Patch and build versions are not kept in lock-step.
+
+## Usage
+
+    gem install friendly_id friendly_id_datamapper
+
+    require "friendly_id"
+    require "friendly_id/datamapper"
+
+    class Post
+      include DataMapper::Resource
+
+      property :id,    Serial
+      property :title, String
+
+      has_friendly_id :title, :use_slug => true
+    end
+
+
+For more information on the available features, please see the
+[FriendlyId Guide](http://norman.github.com/friendly_id/file.Guide.html).
+
+## Bugs
+
+Please report them on the [Github issue tracker](http://github.com/myabc/friendly_id_datamapper/issues)
+for this project.
+
+If you have a bug to report, please include the following information:
+
+* **Version information for FriendlyId, friendly_id_datamapper, Rails and Ruby.**
+* Stack trace and error message.
+* Any snippets of relevant model, view or controller code that shows how your
+  are using FriendlyId.
+
+If you are able to, it helps even more if you can fork FriendlyId on Github,
+and add a test that reproduces the error you are experiencing.
+
+## Credits
+
+Copyright (c) 2010, released under the MIT license.
+

data/Rakefile

@@ -0,0 +1,29 @@
+require "rake"
+require "rake/testtask"
+require "rake/gempackagetask"
+require "rake/clean"
+
+CLEAN << "pkg" << "doc" << "coverage" << ".yardoc"
+
+Rake::GemPackageTask.new(eval(File.read("friendly_id_datamapper.gemspec"))) { |pkg| }
+Rake::TestTask.new(:test) { |t| t.pattern = "test/*_test.rb" }
+
+task :default => :test
+
+begin
+  require "yard"
+  YARD::Rake::YardocTask.new do |t|
+    t.options = ["--output-dir=docs"]
+  end
+rescue LoadError
+end
+
+begin
+  require "rcov/rcovtask"
+  Rcov::RcovTask.new do |r|
+    r.test_files = FileList["test/**/*_test.rb"]
+    r.verbose = true
+    r.rcov_opts << "--exclude gems/*"
+  end
+rescue LoadError
+end

data/lib/friendly_id/datamapper_adapter/configuration.rb

@@ -0,0 +1,67 @@
+module FriendlyId
+  module DataMapperAdapter
+
+    # Extends FriendlyId::Configuration with some implementation details and
+    # features specific to DataMapper.
+    class Configuration < FriendlyId::Configuration
+
+      # The column used to cache the friendly_id string. If no column is specified,
+      # FriendlyId will look for a column named +cached_slug+ and use it automatically
+      # if it exists. If for some reason you have a column named +cached_slug+
+      # but don't want FriendlyId to modify it, pass the option
+      # +:cache_column => false+ to {FriendlyId::DataMapperAdapter#has_friendly_id has_friendly_id}.
+      attr_accessor :cache_column
+
+      # An array of classes for which the configured class serves as a
+      # FriendlyId scope.
+      attr_reader :child_scopes
+
+      attr_reader :custom_cache_column
+
+      def cache_column
+        return @cache_column if defined?(@cache_column)
+        @cache_column = autodiscover_cache_column
+      end
+
+      def cache_column?
+        !! cache_column
+      end
+
+      def cache_column=(cache_column)
+        @cache_column = cache_column
+        @custom_cache_column = cache_column
+      end
+
+      def child_scopes
+        @child_scopes ||= associated_friendly_classes.select do |klass|
+          klass.friendly_id_config.scopes_over?(configured_class)
+        end
+      end
+
+      def custom_cache_column?
+        !! custom_cache_column
+      end
+
+      def scope_for(record)
+        scope? ? record.send(scope).to_param : nil
+      end
+
+      def scopes_over?(klass)
+        scope? && scope == klass.to_s.underscore.to_sym
+      end
+
+      private
+
+      def autodiscover_cache_column
+        :cached_slug if configured_class.properties[:cached_slug]
+      end
+
+      def associated_friendly_classes
+        configured_class.relationships.values.select { |relationship|
+          relationship.child_model.respond_to?(:friendly_id_config)
+        }.map(&:child_model)
+      end
+
+    end
+  end
+end

data/lib/friendly_id/datamapper_adapter/simple_model.rb

@@ -0,0 +1,83 @@
+
+
+module FriendlyId
+  module DataMapperAdapter
+
+    module SimpleModel
+
+      def self.included(base)
+        base.class_eval do
+          column = friendly_id_config.column
+          validates_presence_of column, :unless => :skip_friendly_id_validations
+          validates_length_of   column, :maximum => friendly_id_config.max_length, :unless => :skip_friendly_id_validations
+          validates_with_method column, :method => :validate_friendly_id, :unless => :skip_friendly_id_validations
+
+          before :update do
+            @old_friendly_id = original_attributes[properties[friendly_id_config.column]]
+          end
+
+          after  :update, :update_scopes
+        end
+
+        def base.get(*key)
+          if key.size == 1
+            return super if key.first.unfriendly_id?
+            column     = self.friendly_id_config.column
+            repository = self.repository
+            key        = self.key(repository.name).typecast(key)
+            result     = self.first(column.to_sym => key)
+            return super unless result
+            result.friendly_id_status.name = name
+            result
+          else
+            super
+          end
+        end
+      end
+
+      # Get the {FriendlyId::Status} after the find has been performed.
+      def friendly_id_status
+        @friendly_id_status ||= Status.new(:record => self)
+      end
+
+      # Returns the friendly_id.
+      def friendly_id
+        send friendly_id_config.column
+      end
+
+      # Returns the friendly id, or if none is available, the numeric id.
+      def to_param
+        (friendly_id || id).to_s
+      end
+
+      private
+
+      # Update the slugs for any model that is using this model as its
+      # FriendlyId scope.
+      def update_scopes
+        if @old_friendly_id != friendly_id
+          friendly_id_config.child_scopes.each do |klass|
+            Slug.all(:sluggable_type => klass, :scope => @old_friendly_id).update(:scope => friendly_id)
+          end
+        end
+      end
+
+      def friendly_id_config
+        self.class.friendly_id_config
+      end
+
+      def skip_friendly_id_validations
+        friendly_id.nil? && friendly_id_config.allow_nil?
+      end
+
+      def validate_friendly_id
+        if result = friendly_id_config.reserved_error_message(friendly_id)
+          return [false, result.join(' ')]
+        else
+          return true
+        end
+      end
+
+    end
+  end
+end

data/lib/friendly_id/datamapper_adapter/slug.rb

@@ -0,0 +1,72 @@
+# A Slug is a unique, human-friendly identifier for a DataMapper model
+class Slug
+  include ::DataMapper::Resource
+
+  property :id,             Serial
+  property :name,           String,   :index => :index_slugs_on_n_s_s_and_s, :required => true, :length => 1..255
+  property :sluggable_id,   Integer,  :index => :sluggable_id
+  property :sequence,       Integer,  :index => :index_slugs_on_n_s_s_and_s, :required => true, :default => 1
+  property :sluggable_type, Class,    :index => :index_slugs_on_n_s_s_and_s
+  property :scope,          String,   :index => :index_slugs_on_n_s_s_and_s
+  property :created_at,     DateTime
+
+  before :save do
+    self.sequence   = next_sequence
+    self.created_at = DateTime.now
+  end
+
+  def self.similar_to(slug)
+    all({
+      :name           => slug.name,
+      :scope          => slug.scope,
+      :sluggable_type => slug.sluggable_type,
+      :order          => [:sequence.asc]
+    })
+  end
+
+  # Whether this slug is the most recent of its owner's slugs.
+  def current?
+    sluggable.slug == self
+  end
+
+  def outdated?
+    !current?
+  end
+
+  def to_friendly_id
+    sequence > 1 ? friendly_id_with_sequence : name
+  end
+
+  def sluggable
+    sluggable_type.get(sluggable_id)
+  end
+
+  def sluggable=(instance)
+    attribute_set(:sluggable_type, instance.class)
+    attribute_set(:sluggable_id,   instance.id)
+  end
+
+  private
+
+  def enable_name_reversion
+    conditions = { :sluggable_id => sluggable_id, :sluggable_type => sluggable_type,
+        :name => name, :scope => scope }
+    self.class.all(conditions).destroy
+  end
+
+  def friendly_id_with_sequence
+    "#{name}#{separator}#{sequence}"
+  end
+
+  def next_sequence
+    enable_name_reversion
+    conditions =  { :name => name, :scope => scope, :sluggable_type => sluggable_type }
+    prev = self.class.first(conditions.update(:order => :sequence.desc))
+    prev ? prev.sequence.succ : 1
+  end
+
+  def separator
+    sluggable_type.friendly_id_config.sequence_separator
+  end
+
+end

data/lib/friendly_id/datamapper_adapter/slugged_model.rb

@@ -0,0 +1,186 @@
+require 'friendly_id/slugged'
+require 'friendly_id/status'
+
+module FriendlyId
+  module DataMapperAdapter
+
+    module SluggedModel
+
+      include FriendlyId::Slugged::Model
+
+      def self.included(base)
+        base.class_eval do
+          has n, :slugs,
+            :model      => ::Slug,
+            :child_key  => [:sluggable_id],
+            :conditions => { :sluggable_type => base },
+            :order      => [:id.desc]
+
+          before :save do
+            begin
+              build_slug if new_slug_needed?
+              method = friendly_id_config.method
+            rescue FriendlyId::BlankError
+              @errors ||= ValidationErrors.new
+              @errors[method] = "can't be blank"
+              throw :halt, false
+            rescue FriendlyId::ReservedError
+              @errors ||= ValidationErrors.new
+              @errors[method] = "is reserved"
+              throw :halt, false
+            end
+          end
+
+          after(:save) do
+            throw :halt, false if friendly_id_config.allow_nil? && !slug
+
+            slug.sluggable_id = id
+            slug.save
+            set_slug_cache
+          end
+
+          after :update, :update_scope
+          after :update, :update_dependent_scopes
+
+          before(:destroy) do
+            slugs.destroy!
+          end
+        end
+
+        base.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def self.get(*key)
+            options = key.extract_options!
+
+            if key.size == 1
+              return super if key.first.is_a?(Array) || key.first.unfriendly_id?
+              name, sequence = key.first.to_s.parse_friendly_id
+
+              if !friendly_id_config.scope? && friendly_id_config.cache_column?
+                result = self.first(friendly_id_config.cache_column => key.first)
+              end
+
+              conditions = {
+                slugs.name     => name,
+                slugs.sequence => sequence
+              }
+              conditions.merge!({
+                slugs.scope    => (options[:scope].to_param if options[:scope] && options[:scope].respond_to?(:to_param))
+              }) if friendly_id_config.scope?
+
+              result ||= self.first(conditions)
+              return super unless result
+              result.friendly_id_status.name = name
+              result.friendly_id_status.sequence = sequence
+              result
+            else
+              super
+            end
+          end
+
+          def self.get!(*key)
+            return super unless friendly_id_config.scope?
+
+            result = get(*key)
+            if result
+              result
+            else
+              options = key.extract_options!
+              scope   = options[:scope]
+              message = "Could not find \#{self.name} with key \#{key.inspect}"
+              message << " and scope \#{scope.inspect}" if scope
+              message << ". Scope expected but none given." unless scope
+              raise(::DataMapper::ObjectNotFoundError, message)
+            end
+          end
+        RUBY
+      end
+
+      def slug
+        @slug ||= slugs.first
+      end
+
+      def find_slug(name, sequence)
+        @slug = slugs.first(:name => name, :sequence => sequence)
+      end
+
+      # Returns the friendly id, or if none is available, the numeric id. Note that this
+      # method will use the cached_slug value if present, unlike {#friendly_id}.
+      def to_param
+        friendly_id_config.cache_column ? to_param_from_cache : to_param_from_slug
+      end
+
+      private
+
+      def scope_changed?
+        friendly_id_config.scope? && send(friendly_id_config.scope).to_param != slug.scope
+      end
+
+      # Respond with the cached value if available.
+      def to_param_from_cache
+        attribute_get(friendly_id_config.cache_column) || id.to_s
+      end
+
+      # Respond with the slugged value if available.
+      def to_param_from_slug
+        slug? ? slug.to_friendly_id : id.to_s
+      end
+
+      # Build the new slug using the generated friendly id.
+      def build_slug
+        return unless new_slug_needed?
+        @slug = slugs.new(:name => slug_text, :scope => friendly_id_config.scope_for(self))
+        raise FriendlyId::BlankError unless @slug.valid?
+        @new_friendly_id = @slug.to_friendly_id
+        @slug
+      end
+
+      # Reset the cached friendly_id?
+      def new_cache_needed?
+        uses_slug_cache? && slug? && send(friendly_id_config.cache_column) != slug.to_friendly_id
+      end
+
+      # Reset the cached friendly_id.
+      def set_slug_cache
+        if new_cache_needed?
+          self.attribute_set(friendly_id_config.cache_column, slug.to_friendly_id)
+          self.save_self(false) # save!
+        end
+      end
+
+      def skip_friendly_id_validations
+        friendly_id.nil? && friendly_id_config.allow_nil?
+      end
+
+      def update_scope
+        return unless slug && scope_changed?
+        transaction do
+          slug.scope = send(friendly_id_config.scope).to_param
+          similar = Slug.similar_to(slug)
+          if !similar.empty?
+            slug.sequence = similar.first.sequence.succ
+          end
+          slug.save
+        end
+      end
+
+      # Update the slugs for any model that is using this model as its
+      # FriendlyId scope.
+      def update_dependent_scopes
+        return unless friendly_id_config.class.scopes_used?
+        # slugs.reload.size == 1, slugs.dirty? == true
+        if slugs.size > 1 && @new_friendly_id
+          friendly_id_config.child_scopes.each do |klass|
+            # slugs.first -- ordering not respected when dirty
+            Slug.all(:sluggable_type => klass, :scope => slugs.first.to_friendly_id).update(:scope => @new_friendly_id)
+          end
+        end
+      end
+
+      # Does the model use slug caching?
+      def uses_slug_cache?
+        friendly_id_config.cache_column?
+      end
+
+    end
+  end
+end

data/lib/friendly_id/datamapper_adapter/tasks.rb

@@ -0,0 +1,69 @@
+require 'active_support/core_ext'
+
+module FriendlyId
+  class TaskRunner
+
+    extend Forwardable
+
+    attr_accessor :days
+    attr_accessor :klass
+    attr_accessor :task_options
+
+    def_delegators :klass, :find, :friendly_id_config
+
+    OLD_SLUG_DAYS = 45
+
+    def initialize(&block)
+      self.klass = ENV["MODEL"]
+      self.days  = ENV["DAYS"]
+    end
+
+    def days=(days)
+      @days ||= days.blank? ? OLD_SLUG_DAYS : days.to_i
+    end
+
+    def klass=(klass)
+      @klass ||= klass.to_s.classify.constantize unless klass.blank?
+    end
+
+    def make_slugs
+      validate_uses_slugs
+      options = {:limit => 100, :slugs => nil, :order => [:id.asc]}.merge(task_options || {})
+      while records = klass.all(options) do
+        break if records.size == 0
+        records.each do |record|
+          record.send(:build_slug)  # FIXME: DataMapper Hack: this hook is not getting called
+          record.save
+          yield(record) if block_given?
+        end
+        options.merge!(:id.gt => records.last.id)
+      end
+    end
+
+    def delete_slugs
+      validate_uses_slugs
+      Slug.all(:sluggable_type => klass).destroy!
+      if column = friendly_id_config.cache_column
+        klass.all.update!(column => nil)
+      end
+    end
+
+    def delete_old_slugs
+      conditions = ["created_at < ?", DateTime.now - days]
+      if klass
+        conditions[0] << " AND sluggable_type = ?"
+        conditions << klass.to_s
+      end
+      Slug.all(:conditions => conditions).select(&:outdated?).map(&:destroy)
+    end
+
+    def validate_uses_slugs
+      (raise "You need to pass a MODEL=<model name> argument to rake") if klass.blank?
+      unless friendly_id_config.use_slug?
+        raise "Class '%s' doesn't use slugs" % klass.to_s
+      end
+    rescue NoMethodError
+      raise "Class '%s' doesn't use FriendlyId" % klass.to_s
+    end
+  end
+end

data/lib/friendly_id/datamapper_adapter/version.rb

@@ -0,0 +1,11 @@
+module FriendlyId
+  module DataMapperAdapter
+    module Version
+      MAJOR  = 3
+      MINOR  = 2
+      TINY   = 0
+      BUILD  = 'beta1'
+      STRING = [MAJOR, MINOR, TINY, BUILD].compact.join('.')
+    end
+  end
+end

data/lib/friendly_id_datamapper.rb

@@ -0,0 +1,34 @@
+require 'dm-core'
+require 'dm-transactions'
+require 'dm-validations'
+require 'friendly_id/datamapper_adapter/configuration'
+require 'friendly_id/datamapper_adapter/slug'
+require 'friendly_id/datamapper_adapter/simple_model'
+require 'friendly_id/datamapper_adapter/slugged_model'
+# require 'friendly_id/datamapper_adapter/tasks'
+require 'forwardable'
+
+module FriendlyId
+  module DataMapperAdapter
+
+    include FriendlyId::Base
+
+    def has_friendly_id(method, options = {})
+      extend FriendlyId::DataMapperAdapter::ClassMethods
+      @friendly_id_config = Configuration.new(self, method, options)
+
+      if friendly_id_config.use_slug?
+        include ::FriendlyId::DataMapperAdapter::SluggedModel
+      else
+        include ::FriendlyId::DataMapperAdapter::SimpleModel
+      end
+    end
+
+    module ClassMethods
+      attr_accessor :friendly_id_config
+    end
+
+  end
+end
+
+DataMapper::Model.append_extensions FriendlyId::DataMapperAdapter

data/test/basic_slugged_model_test.rb

@@ -0,0 +1,16 @@
+require File.expand_path('../test_helper', __FILE__)
+
+module FriendlyId
+  module Test
+    module DataMapperAdapter
+
+      # Tests for DataMapper models using FriendlyId with slugs.
+      class BasicSluggedModelTest < ::Test::Unit::TestCase
+        include FriendlyId::Test::Generic
+        include FriendlyId::Test::Slugged
+        include FriendlyId::Test::DataMapperAdapter::Slugged
+        include FriendlyId::Test::DataMapperAdapter::Core
+      end
+    end
+  end
+end