From dc4787e90575fe63368ed34c152f2e4cc7fa10e4 Mon Sep 17 00:00:00 2001 From: Peter Gumeson Date: Sun, 7 Jun 2009 02:57:22 -0700 Subject: [PATCH] Integrated Yehuda's new callback code from rails --- README.md | 12 +- lib/couchrest/mixins/callbacks.rb | 273 +++++++++++++---------- lib/couchrest/mixins/validation.rb | 2 +- lib/couchrest/more/extended_document.rb | 2 +- lib/couchrest/support/class.rb | 138 +++++------- spec/couchrest/more/casted_model_spec.rb | 4 +- spec/couchrest/more/extended_doc_spec.rb | 16 +- spec/fixtures/more/article.rb | 2 +- 8 files changed, 228 insertions(+), 221 deletions(-) diff --git a/README.md b/README.md index b9ed345..6312b4f 100644 --- a/README.md +++ b/README.md @@ -69,20 +69,20 @@ CouchRest::Model has been deprecated and replaced by CouchRest::ExtendedDocument ### Callbacks `CouchRest::ExtendedDocuments` instances have 4 callbacks already defined for you: - `validate_callback`, `create_callback`, `save_callback`, `update_callback` and `destroy_callback` + `:validate`, `:create`, `:save`, `:update` and `:destroy` `CouchRest::CastedModel` instances have 1 callback already defined for you: - `validate_callback` + `:validate` Define your callback as follows: - save_callback :before, :generate_slug_from_name + set_callback :save, :before, :generate_slug_from_name CouchRest uses a mixin you can find in lib/mixins/callbacks which is extracted from Rails 3, here are some simple usage examples: - save_callback :before, :before_method - save_callback :after, :after_method, :if => :condition - save_callback :around {|r| stuff; yield; stuff } + set_callback :save, :before, :before_method + set_callback :save, :after, :after_method, :if => :condition + set_callback :save, :around {|r| stuff; yield; stuff } Check the mixin or the ExtendedDocument class to see how to implement your own callbacks. diff --git a/lib/couchrest/mixins/callbacks.rb b/lib/couchrest/mixins/callbacks.rb index 2516702..ca9a7c5 100644 --- a/lib/couchrest/mixins/callbacks.rb +++ b/lib/couchrest/mixins/callbacks.rb @@ -1,8 +1,8 @@ require File.join(File.dirname(__FILE__), '..', 'support', 'class') -# Extracted from ActiveSupport::Callbacks written by Yehuda Katz -# http://github.com/wycats/rails/raw/abstract_controller/activesupport/lib/active_support/new_callbacks.rb -# http://github.com/wycats/rails/raw/18b405f154868204a8f332888871041a7bad95e1/activesupport/lib/active_support/callbacks.rb +# Extracted from ActiveSupport::NewCallbacks written by Yehuda Katz +# http://github.com/rails/rails/raw/d6e4113c83a9d55be6f2af247da2cecaa855f43b/activesupport/lib/active_support/new_callbacks.rb +# http://github.com/rails/rails/commit/1126a85aed576402d978e6f76eb393b6baaa9541 module CouchRest # Callbacks are hooks into the lifecycle of an object that allow you to trigger logic @@ -85,19 +85,18 @@ module CouchRest def self.included(klass) klass.extend ClassMethods end - + def run_callbacks(kind, options = {}, &blk) send("_run_#{kind}_callbacks", &blk) end - + class Callback @@_callback_sequence = 0 - + attr_accessor :filter, :kind, :name, :options, :per_key, :klass - def initialize(filter, kind, options, klass, name) + def initialize(filter, kind, options, klass) @kind, @klass = kind, klass - @name = name - + normalize_options!(options) @per_key = options.delete(:per_key) @@ -108,7 +107,7 @@ module CouchRest _compile_per_key_options end - + def clone(klass) obj = super() obj.klass = klass @@ -120,7 +119,7 @@ module CouchRest obj.options[:unless] = @options[:unless].dup obj end - + def normalize_options!(options) options[:if] = Array(options[:if]) options[:unless] = Array(options[:unless]) @@ -129,14 +128,13 @@ module CouchRest options[:per_key][:if] = Array(options[:per_key][:if]) options[:per_key][:unless] = Array(options[:per_key][:unless]) end - + def next_id @@_callback_sequence += 1 end - - def matches?(_kind, _name, _filter) + + def matches?(_kind, _filter) @kind == _kind && - @name == _name && @filter == _filter end @@ -144,11 +142,11 @@ module CouchRest filter_options[:if].push(new_options[:unless]) if new_options.key?(:unless) filter_options[:unless].push(new_options[:if]) if new_options.key?(:if) end - + def recompile!(_options, _per_key) _update_filter(self.options, _options) _update_filter(self.per_key, _per_key) - + @callback_id = next_id @filter = _compile_filter(@raw_filter) @compiled_options = _compile_options(@options) @@ -164,19 +162,19 @@ module CouchRest end RUBY_EVAL end - + # This will supply contents for before and around filters, and no # contents for after filters (for the forward pass). def start(key = nil, options = {}) object, terminator = (options || {}).values_at(:object, :terminator) - + return if key && !object.send("_one_time_conditions_valid_#{@callback_id}?") - + terminator ||= false - + # options[0] is the compiled form of supplied conditions # options[1] is the "end" for the conditional - + if @kind == :before || @kind == :around if @kind == :before # if condition # before_save :filter_name, :if => :condition @@ -204,7 +202,7 @@ module CouchRest # yield self # end # end - + name = "_conditional_callback_#{@kind}_#{next_id}" txt = <<-RUBY_EVAL def #{name}(halted) @@ -222,14 +220,14 @@ module CouchRest end end end - + # This will supply contents for around and after filters, but not # before filters (for the backward pass). def end(key = nil, options = {}) object = (options || {})[:object] - + return if key && !object.send("_one_time_conditions_valid_#{@callback_id}?") - + if @kind == :around || @kind == :after # if condition # after_save :filter_name, :if => :condition # filter_name @@ -241,27 +239,27 @@ module CouchRest end end end - + private # Options support the same options as filters themselves (and support # symbols, string, procs, and objects), so compile a conditional # expression based on the options def _compile_options(options) return [] if options[:if].empty? && options[:unless].empty? - + conditions = [] - + unless options[:if].empty? conditions << Array(_compile_filter(options[:if])) end - + unless options[:unless].empty? conditions << Array(_compile_filter(options[:unless])).map {|f| "!#{f}"} end - + ["if #{conditions.flatten.join(" && ")}", "end"] end - + # Filters support: # Arrays:: Used in conditions. This is used to specify # multiple conditions. Used internally to @@ -289,7 +287,22 @@ module CouchRest filter when Proc @klass.send(:define_method, method_name, &filter) - method_name << (filter.arity == 1 ? "(self)" : "") + method_name << case filter.arity + when 1 + "(self)" + when 2 + " self, Proc.new " + else + "" + end + when Method + @klass.send(:define_method, "#{method_name}_method") { filter } + @klass.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1 + def #{method_name}(&blk) + #{method_name}_method.call(self, &blk) + end + RUBY_EVAL + method_name when String @klass.class_eval <<-RUBY_EVAL def #{method_name} @@ -298,52 +311,65 @@ module CouchRest RUBY_EVAL method_name else - kind, name = @kind, @name - @klass.send(:define_method, method_name) do - filter.send("#{kind}_#{name}", self) - end + kind = @kind + @klass.send(:define_method, "#{method_name}_object") { filter } + + _normalize_legacy_filter(kind, filter) + + @klass.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1 + def #{method_name}(&blk) + #{method_name}_object.send(:#{kind}, self, &blk) + end + RUBY_EVAL + method_name end end + + def _normalize_legacy_filter(kind, filter) + if !filter.respond_to?(kind) && filter.respond_to?(:filter) + filter.metaclass.class_eval( + "def #{kind}(context, &block) filter(context, &block) end", + __FILE__, __LINE__ - 1) + elsif filter.respond_to?(:before) && filter.respond_to?(:after) && kind == :around + def filter.around(context) + should_continue = before(context) + yield if should_continue + after(context) + end + end + end + end - # This method_missing is supplied to catch callbacks with keys and create - # the appropriate callback for future use. - def method_missing(meth, *args, &blk) - if meth.to_s =~ /_run__([\w:]+)__(\w+)__(\w+)__callbacks/ - return self.class._create_and_run_keyed_callback($1, $2.to_sym, $3.to_sym, self, &blk) - end - super - end - # An Array with a compile method class CallbackChain < Array def initialize(symbol) @symbol = symbol end - + def compile(key = nil, options = {}) method = [] method << "halted = false" each do |callback| method << callback.start(key, options) end - method << "yield self if block_given?" + method << "yield self if block_given? && !halted" reverse_each do |callback| method << callback.end(key, options) end method.compact.join("\n") end - + def clone(klass) chain = CallbackChain.new(@symbol) chain.push(*map {|c| c.clone(klass)}) end end - + module ClassMethods - CHAINS = {:before => :before, :around => :before, :after => :after} unless self.const_defined?("CHAINS") - + CHAINS = {:before => :before, :around => :before, :after => :after} + # Make the _run_save_callbacks method. The generated method takes # a block that it'll yield to. It'll call the before and around filters # in order, yield the block, and then run the after filters. @@ -355,43 +381,44 @@ module CouchRest # The _run_save_callbacks method can optionally take a key, which # will be used to compile an optimized callback method for each # key. See #define_callbacks for more information. - def _define_runner(symbol, str, options) - str = <<-RUBY_EVAL - def _run_#{symbol}_callbacks(key = nil) + def _define_runner(symbol, callbacks) + body = callbacks.compile(nil, :terminator => send("_#{symbol}_terminator")) + + body, line = <<-RUBY_EVAL, __LINE__ + def _run_#{symbol}_callbacks(key = nil, &blk) if key - send("_run__\#{self.class.name.split("::").last}__#{symbol}__\#{key}__callbacks") { yield if block_given? } + name = "_run__\#{self.class.name.hash.abs}__#{symbol}__\#{key.hash.abs}__callbacks" + + unless respond_to?(name) + self.class._create_keyed_callback(name, :#{symbol}, self, &blk) + end + + send(name, &blk) else - #{str} + #{body} end end RUBY_EVAL - - class_eval str, __FILE__, __LINE__ + 1 - - before_name, around_name, after_name = - options.values_at(:before, :after, :around) + + undef_method "_run_#{symbol}_callbacks" if method_defined?("_run_#{symbol}_callbacks") + class_eval body, __FILE__, line end - + # This is called the first time a callback is called with a particular # key. It creates a new callback method for the key, calculating # which callbacks can be omitted because of per_key conditions. - def _create_and_run_keyed_callback(klass, kind, key, obj, &blk) + def _create_keyed_callback(name, kind, obj, &blk) @_keyed_callbacks ||= {} - @_keyed_callbacks[[kind, key]] ||= begin - str = self.send("_#{kind}_callbacks").compile(key, :object => obj, :terminator => self.send("_#{kind}_terminator")) + @_keyed_callbacks[name] ||= begin + str = send("_#{kind}_callbacks"). + compile(name, :object => obj, :terminator => send("_#{kind}_terminator")) + + class_eval "def #{name}() #{str} end", __FILE__, __LINE__ - self.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1 - def _run__#{klass.split("::").last}__#{kind}__#{key}__callbacks - #{str} - end - RUBY_EVAL - true end - - obj.send("_run__#{klass.split("::").last}__#{kind}__#{key}__callbacks", &blk) end - + # Define callbacks. # # Creates a _callback method that you can use to add callbacks. @@ -423,58 +450,62 @@ module CouchRest # In that case, each action_name would get its own compiled callback # method that took into consideration the per_key conditions. This # is a speed improvement for ActionPack. + def update_callbacks(name, filters = CallbackChain.new(name), block = nil) + type = [:before, :after, :around].include?(filters.first) ? filters.shift : :before + options = filters.last.is_a?(Hash) ? filters.pop : {} + filters.unshift(block) if block + + responded = self.respond_to?(":_#{name}_callbacks") + + callbacks = send("_#{name}_callbacks") + yield callbacks, type, filters, options if block_given? + + _define_runner(name, callbacks) + end + + def set_callback(name, *filters, &block) + update_callbacks(name, filters, block) do |callbacks, type, filters, options| + filters.map! do |filter| + # overrides parent class + callbacks.delete_if {|c| c.matches?(type, filter) } + Callback.new(filter, type, options.dup, self) + end + + options[:prepend] ? callbacks.unshift(*filters) : callbacks.push(*filters) + end + end + + def skip_callback(name, *filters, &block) + update_callbacks(name, filters, block) do |callbacks, type, filters, options| + filters.each do |filter| + callbacks = send("_#{name}_callbacks=", callbacks.clone(self)) + + filter = callbacks.find {|c| c.matches?(type, filter) } + + if filter && options.any? + filter.recompile!(options, options[:per_key] || {}) + else + callbacks.delete(filter) + end + end + end + end + def define_callbacks(*symbols) terminator = symbols.pop if symbols.last.is_a?(String) symbols.each do |symbol| - self.extlib_inheritable_accessor("_#{symbol}_terminator") - self.send("_#{symbol}_terminator=", terminator) - self.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1 - extlib_inheritable_accessor :_#{symbol}_callbacks - self._#{symbol}_callbacks = CallbackChain.new(:#{symbol}) + extlib_inheritable_accessor("_#{symbol}_terminator") { terminator } - def self.#{symbol}_callback(*filters, &blk) - type = [:before, :after, :around].include?(filters.first) ? filters.shift : :before - options = filters.last.is_a?(Hash) ? filters.pop : {} - filters.unshift(blk) if block_given? - - filters.map! do |filter| - # overrides parent class - self._#{symbol}_callbacks.delete_if {|c| c.matches?(type, :#{symbol}, filter)} - Callback.new(filter, type, options.dup, self, :#{symbol}) - end - self._#{symbol}_callbacks.push(*filters) - _define_runner(:#{symbol}, - self._#{symbol}_callbacks.compile(nil, :terminator => _#{symbol}_terminator), - options) - end - - def self.skip_#{symbol}_callback(*filters, &blk) - type = [:before, :after, :around].include?(filters.first) ? filters.shift : :before - options = filters.last.is_a?(Hash) ? filters.pop : {} - filters.unshift(blk) if block_given? - filters.each do |filter| - self._#{symbol}_callbacks = self._#{symbol}_callbacks.clone(self) - - filter = self._#{symbol}_callbacks.find {|c| c.matches?(type, :#{symbol}, filter) } - per_key = options[:per_key] || {} - if filter - filter.recompile!(options, per_key) - else - self._#{symbol}_callbacks.delete(filter) - end - _define_runner(:#{symbol}, - self._#{symbol}_callbacks.compile(nil, :terminator => _#{symbol}_terminator), - options) - end - - end - + extlib_inheritable_accessor("_#{symbol}_callbacks") do + CallbackChain.new(symbol) + end + + self.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1 def self.reset_#{symbol}_callbacks - self._#{symbol}_callbacks = CallbackChain.new(:#{symbol}) - _define_runner(:#{symbol}, self._#{symbol}_callbacks.compile, {}) + update_callbacks(:#{symbol}) end - - self.#{symbol}_callback(:before) + + self.set_callback(:#{symbol}, :before) RUBY_EVAL end end diff --git a/lib/couchrest/mixins/validation.rb b/lib/couchrest/mixins/validation.rb index 467e143..015770a 100644 --- a/lib/couchrest/mixins/validation.rb +++ b/lib/couchrest/mixins/validation.rb @@ -77,7 +77,7 @@ module CouchRest base.class_eval <<-EOS, __FILE__, __LINE__ define_callbacks :validate if method_defined?(:_run_save_callbacks) - save_callback :before, :check_validations + set_callback :save, :before, :check_validations end EOS base.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1 diff --git a/lib/couchrest/more/extended_document.rb b/lib/couchrest/more/extended_document.rb index 44c73c3..b8c84ac 100644 --- a/lib/couchrest/more/extended_document.rb +++ b/lib/couchrest/more/extended_document.rb @@ -62,7 +62,7 @@ module CouchRest property(:updated_at, :read_only => true, :cast_as => 'Time', :auto_validation => false) property(:created_at, :read_only => true, :cast_as => 'Time', :auto_validation => false) - save_callback :before do |object| + set_callback :save, :before do |object| object['updated_at'] = Time.now object['created_at'] = object['updated_at'] if object.new? end diff --git a/lib/couchrest/support/class.rb b/lib/couchrest/support/class.rb index ecbab76..a33c2d5 100644 --- a/lib/couchrest/support/class.rb +++ b/lib/couchrest/support/class.rb @@ -1,96 +1,55 @@ -# Copyright (c) 2004-2008 David Heinemeier Hansson +# Extracted From +# http://github.com/rails/rails/commit/971e2438d98326c994ec6d3ef8e37b7e868ed6e2 + +# Extends the class object with class and instance accessors for class attributes, +# just like the native attr* accessors for instance attributes. # -# 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: +# class Person +# cattr_accessor :hair_colors +# end # -# 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. - -# Allows attributes to be shared within an inheritance hierarchy, but where -# each descendant gets a copy of their parents' attributes, instead of just a -# pointer to the same. This means that the child can add elements to, for -# example, an array without those additions being shared with either their -# parent, siblings, or children, which is unlike the regular class-level -# attributes that are shared across the entire hierarchy. +# Person.hair_colors = [:brown, :black, :blonde, :red] class Class - # Defines class-level and instance-level attribute reader. - # - # @param *syms Array of attributes to define reader for. - # @return List of attributes that were made into cattr_readers - # - # @api public - # - # @todo Is this inconsistent in that it does not allow you to prevent - # an instance_reader via :instance_reader => false def cattr_reader(*syms) syms.flatten.each do |sym| next if sym.is_a?(Hash) - class_eval(<<-RUBY, __FILE__, __LINE__ + 1) - unless defined? @@#{sym} - @@#{sym} = nil - end - - def self.#{sym} - @@#{sym} - end - - def #{sym} - @@#{sym} - end - RUBY + class_eval(<<-EOS, __FILE__, __LINE__ + 1) + unless defined? @@#{sym} # unless defined? @@hair_colors + @@#{sym} = nil # @@hair_colors = nil + end # end + # + def self.#{sym} # def self.hair_colors + @@#{sym} # @@hair_colors + end # end + # + def #{sym} # def hair_colors + @@#{sym} # @@hair_colors + end # end + EOS end end unless Class.respond_to?(:cattr_reader) - # Defines class-level (and optionally instance-level) attribute writer. - # - # @param Boolean}]> Array of attributes to define writer for. - # @option syms :instance_writer if true, instance-level attribute writer is defined. - # @return List of attributes that were made into cattr_writers - # - # @api public def cattr_writer(*syms) - options = syms.last.is_a?(Hash) ? syms.pop : {} + options = syms.extract_options! syms.flatten.each do |sym| - class_eval(<<-RUBY, __FILE__, __LINE__ + 1) - unless defined? @@#{sym} - @@#{sym} = nil - end - - def self.#{sym}=(obj) - @@#{sym} = obj - end - RUBY - - unless options[:instance_writer] == false - class_eval(<<-RUBY, __FILE__, __LINE__ + 1) - def #{sym}=(obj) - @@#{sym} = obj - end - RUBY - end + class_eval(<<-EOS, __FILE__, __LINE__ + 1) + unless defined? @@#{sym} # unless defined? @@hair_colors + @@#{sym} = nil # @@hair_colors = nil + end # end + # + def self.#{sym}=(obj) # def self.hair_colors=(obj) + @@#{sym} = obj # @@hair_colors = obj + end # end + # + #{" # + def #{sym}=(obj) # def hair_colors=(obj) + @@#{sym} = obj # @@hair_colors = obj + end # end + " unless options[:instance_writer] == false } # # instance writer above is generated unless options[:instance_writer] == false + EOS end end unless Class.respond_to?(:cattr_writer) - # Defines class-level (and optionally instance-level) attribute accessor. - # - # @param *syms Boolean}]> Array of attributes to define accessor for. - # @option syms :instance_writer if true, instance-level attribute writer is defined. - # @return List of attributes that were made into accessors - # - # @api public def cattr_accessor(*syms) cattr_reader(*syms) cattr_writer(*syms) @@ -156,6 +115,8 @@ class Class def #{ivar}=(obj) self.class.#{ivar} = obj end RUBY end + + self.send("#{ivar}=", yield) if block_given? end end unless Class.respond_to?(:extlib_inheritable_writer) @@ -168,9 +129,24 @@ class Class # @return An Array of attributes turned into inheritable accessors. # # @api public - def extlib_inheritable_accessor(*syms) + def extlib_inheritable_accessor(*syms, &block) extlib_inheritable_reader(*syms) - extlib_inheritable_writer(*syms) + extlib_inheritable_writer(*syms, &block) end unless Class.respond_to?(:extlib_inheritable_accessor) end +class Array + # Extracts options from a set of arguments. Removes and returns the last + # element in the array if it's a hash, otherwise returns a blank hash. + # + # def options(*args) + # args.extract_options! + # end + # + # options(1, 2) # => {} + # options(1, 2, :a => :b) # => {:a=>:b} + def extract_options! + last.is_a?(::Hash) ? pop : {} + end unless Array.respond_to?(:extract_options!) +end + diff --git a/spec/couchrest/more/casted_model_spec.rb b/spec/couchrest/more/casted_model_spec.rb index 029e294..e81fe16 100644 --- a/spec/couchrest/more/casted_model_spec.rb +++ b/spec/couchrest/more/casted_model_spec.rb @@ -35,10 +35,10 @@ class WithCastedCallBackModel < Hash property :run_before_validate property :run_after_validate - validate_callback :before do |object| + set_callback :validate, :before do |object| object.run_before_validate = true end - validate_callback :after do |object| + set_callback :validate, :after do |object| object.run_after_validate = true end end diff --git a/spec/couchrest/more/extended_doc_spec.rb b/spec/couchrest/more/extended_doc_spec.rb index d4100bf..1a752ac 100644 --- a/spec/couchrest/more/extended_doc_spec.rb +++ b/spec/couchrest/more/extended_doc_spec.rb @@ -29,28 +29,28 @@ describe "ExtendedDocument" do property :run_before_update property :run_after_update - validate_callback :before do |object| + set_callback :validate, :before do |object| object.run_before_validate = true end - validate_callback :after do |object| + set_callback :validate, :after do |object| object.run_after_validate = true end - save_callback :before do |object| + set_callback :save, :before do |object| object.run_before_save = true end - save_callback :after do |object| + set_callback :save, :after do |object| object.run_after_save = true end - create_callback :before do |object| + set_callback :create, :before do |object| object.run_before_create = true end - create_callback :after do |object| + set_callback :create, :after do |object| object.run_after_create = true end - update_callback :before do |object| + set_callback :update, :before do |object| object.run_before_update = true end - update_callback :after do |object| + set_callback :update, :after do |object| object.run_after_update = true end end diff --git a/spec/fixtures/more/article.rb b/spec/fixtures/more/article.rb index 840b45b..aa26e1d 100644 --- a/spec/fixtures/more/article.rb +++ b/spec/fixtures/more/article.rb @@ -26,7 +26,7 @@ class Article < CouchRest::ExtendedDocument timestamps! - save_callback :before, :generate_slug_from_title + set_callback :save, :before, :generate_slug_from_title def generate_slug_from_title self['slug'] = title.downcase.gsub(/[^a-z0-9]/,'-').squeeze('-').gsub(/^\-|\-$/,'') if new?