hanswurst 0.5.4 → 0.5.5

data/VERSION

@@ -1 +1 @@
-0.5.4
+0.5.5

data/lib/hanswurst.rb

@@ -1,390 +1,23 @@
 require 'couch_potato'
 
-class HanswurstValidator < ActiveModel::EachValidator
-  def doc_is_valid_role?(doc, roles)
-    !(roles & doc.hanswurst_roles.keys).empty?
-  end
-
-  def is_valid_klass?(klasses, value)
-    valid = false
-    klasses.each do |klass|
-      valid = true if value.is_a? klass
-    end
-    valid
-  end
-
-  def doc_is_valid_klass?(doc, klasses)
-    !(klasses & doc.hanswurst_roles.values).empty?
-  end
-
-
-  def validate_each(record, attribute, values)
-    #p options
-    #p record
-    return if values.nil?
-    values = values.values if values.class == Hash
-    values = [values] unless values.class == Array
-    valid = true
-    max = options[:max]
-    if max && values.size > max
-      record.errors.add attribute, "must not have more than #{max} entries"
-      return
-    end
-    fkey = options[:fkey] || false
-    if fkey
-      values = values.collect do |id|
-        CouchPotato.database.load_document id 
-      end
-    end
-
-    if klass = options[:class]
-      klasses = [klass].flatten
-      if fkey
-        klasses = klasses.collect{ |k| k.to_s }
-        values.each do |doc|
-          valid = false unless doc && doc.hanswurst_roles && doc_is_valid_klass?(doc, klasses)
-        end
-        record.errors.add attribute, "must be a doc id of a class #{klasses.join(' or ')}" unless valid
-      else
-        values.each do |thing|
-          valid = false unless is_valid_klass?(klasses, thing)  
-        end
-        record.errors.add attribute, "must be an instance of #{klasses.join(' or ')}" unless valid
-      end
-    elsif role = options[:role]
-      roles = [role].flatten.collect{ |r| r.to_s }
-      if fkey
-        values.each do |doc|
-          valid = false unless doc && doc.hanswurst_roles && doc_is_valid_role?(doc, roles)
-        end
-        record.errors.add attribute, "must be a doc id of a role #{roles.join(' or ')}" unless valid
-      else
-        klasses = roles.collect do |role_alias|
-          klass = Hanswurst.role_class(role_alias.to_sym)
-          record.errors.add(attribute,  "could not find role #{role_alias} with Hanswurst.role_class. Did you register it with Hanswurst.register_role() ?") if klass.nil?
-          klass
-        end
-        values.each do |thing|
-          valid = false unless is_valid_klass?(klasses, thing)  
-        end
-        record.errors.add attribute, "must be an instance of #{klasses.join(' or ')}" unless valid
-      end
-      
-    end
-    #roles = options[:in] || [options[:with]]    
-  end
-end
-
+require_relative File.join('hanswurst', 'validator')
+require_relative File.join('hanswurst', 'class_methods')
+require_relative File.join('hanswurst', 'method_missing')
+require_relative File.join('hanswurst', 'instance_methods')
+require_relative File.join('hanswurst', 'delegates')
+require_relative File.join('hanswurst', 'shares')
+require_relative File.join('hanswurst', 'as')
+require_relative File.join('hanswurst', 'callbacks')
 
 # Each Hanswurst may have a different combination of roles. It's a very flexible way to be a couch potato.
 class Hanswurst
-  module Delegates
-    def self.included(mod)
-      mod.instance_eval do
-        def delegates(hsh)
-          @delegations ||= {}
-          hsh.each do |prop,role|
-            if prop.is_a? Array
-              prop.each do |pr|
-                @delegations.update pr => role
-              end
-            else
-              @delegations.update prop => role
-            end
-          end
-        end
-
-        def delegations
-          @delegations || {}
-        end
-      end
-    end
-
-    # shortcuts view_for_[role], list_for_[role]
-    def method_missing(meth, *args, &code)
-      meth.to_s =~ /^([^=]+)=?$/
-      unified_meth = $1
-      if role = self.class.delegations[unified_meth.to_sym]
-        self.send(role).send(meth, *args, &code)
-      else
-        super
-      end
-    end
-  end
-
-  module Shares
-    def self.included(mod)
-      mod.instance_eval do
-        def shares(hsh)
-          hsh = {hsh => hsh} if hsh.is_a? Symbol
-          @shared_dependancies ||= {}
-          @shared_dependancies.update hsh
-        end
-
-        def shared_dependancies
-          @shared_dependancies || {}
-        end
-      end
-    end
-  end
-
-  # error raised when a role is not valid
-  class RoleNotValid < Exception
-    def initialize(role, value)
-      @role = role
-      @value = value
-    end
-
-    def message()
-      errors = @value.errors.messages.collect do |field, err|
-        "#{field} #{err.join('/')}"
-      end.join(" # ")
-      "#{@role} not valid: #{errors}"
-    end
-  end
-
-  # helper for easy access to role attributes
-  class As
-    def initialize(doc, role)
-      @doc = doc
-      @role = role
-    end
-  
-    def _role
-      @role
-    end
-
-    def _id
-      @doc._id
-    end
-
-    def _doc
-      @doc
-    end
-
-    # we suppose, we have a subrole
-    def method_missing(meth, *args, &code)
-      # a hack around http://api.rubyonrails.org/classes/ActiveModel/Dirty.html
-      # since ActiveModel::Dirty does not recognize when property is a hash and hashentries do change
-      @doc.update_roles! if meth =~ /=$/
-
-      obj = @role.send(meth, *args)
-      if obj.is_a? CouchPotato::Persistence
-        obj = self.class.new(@doc, @role.send(meth, *args))
-      end
-      obj.instance_eval(&code) if code
-      obj
-    end
-  end
-
-  # class methods for Hanswurst
-  module ClassMethods
-
-    # get class obj from a classname
-    def getClass(classname)
-      classname.split('::').inject Kernel do |c,name| c = c.const_get name; end
-    end
-
-    # hsh is role_alias => klass where role_alias should be a symbol
-    def register_role(hsh)
-      @roles ||= {}
-      @roles.update hsh
-    end
-
-    # returns the role klass for the role_alias (role_alias should be a symbol)
-    def role_class(role_alias)
-      @roles ||= {}
-      @roles[role_alias]
-    end
-
-    # creates a view to show only documents of the role +role_alias+ 
-    def role_view(role_alias, viewname, options)
-      # I keep this commented out to inform the reader that we don't want this in order to easily reuse general lists
-      #options[:list] &&= :"#{role_alias}_#{options[:list]}"
-      options[:conditions] &&= " && ( #{options[:conditions]} )"
-      options[:conditions] = "(doc.hanswurst_roles.#{role_alias} !== undefined)#{options[:conditions]}"
-      self.view :"#{role_alias}_#{viewname}", options
-    end
-
-    alias :view_for :role_view
-
-    # creates a list for documents of the role +role_alias+ 
-    def role_list(role_alias, listname, val)
-      self.list :"#{role_alias}_#{listname}", val.to_s
-    end
-
-    alias :list_for :role_list
-
-    # shortcuts view_for_[role], list_for_[role]
-    def method_missing(meth, *args, &code)
-      case meth
-      when /^view_for_(.+)$/
-        send(:view_for, $1, *args)
-      when /^list_for_(.+)$/
-        send(:list_for, $1, *args)
-      else
-        super
-      end
-    end
-  end
-  
-  extend ClassMethods
-
   include CouchPotato::Persistence
-
-  module MethodMissing
-    # dispatches self.role calls and self.role= setters
-    def method_missing(meth, *args, &code)
-      value = args.first
-      case meth
-      when /^([^=]+)\=$/ # obj.role = ... # => we set a role
-        role=$1
-        add_role(role, value.class) unless role_exists?(role)
-        set_role(role, value) if role_exists?(role)
-        return as(meth)
-      else
-        return as(meth) if role_exists?(meth.to_s)
-      end
-      super
-    end
-  end
+  include MethodMissing
+  include Callbacks
+  extend ClassMethods
 
   property :hanswurst_roles
   property :hanswurst_data
-
-  # check if every role is valid before saving
-  before_save do
-    self.hanswurst_data.each do |role,val|
-      unless val.valid?
-        raise RoleNotValid.new(role, val)
-      end
-    end
-  end
-
-  include MethodMissing
-
-  def initialize(hsh={})
-    unless hsh.empty?
-      hsh.each do |role, obj|
-        self.send(:"#{role}=", obj)
-      end
-    end
-  end
-
-  # copy the doc including the roles
-  def copy()
-    attributes = self.to_hash
-    attributes.delete "ruby_class"
-    attributes.delete "_id"
-    attributes.delete "_rev"
-    attributes.delete :created_at
-    attributes.delete :updated_at
-    hanswust_data = attributes.delete :hanswurst_data
-    obj = self.class.new attributes
-    hanswust_data.each do |role,val|
-      obj.send(:"#{role}=", val.dup)
-    end
-    obj
-  end
-
-  def <<(hsh)
-    add_roles(hsh)
-  end
-
-  # a hack around http://api.rubyonrails.org/classes/ActiveModel/Dirty.html
-  # since ActiveModel::Dirty does not recognize when property is a hash and hashentries do change
-  def update_roles!
-    self.hanswurst_data_will_change!
-  end
-
-  private
-
-  # add a role
-  def add_role(role, klass, &code)
-    add_roles(role => klass)
-    as(role, &code)
-  end
-
-  def handle_shared(role, klass)
-    if klass.respond_to?(:shared_dependancies)
-      shared = {}
-      klass.shared_dependancies.each do |shared_role, shared_class|
-        shared_class = Hanswurst.role_class(shared_class) if shared_class.is_a? Symbol
-        shared[shared_role] = shared_class unless role_exists? shared_role
-      end
-      add_roles shared
-    end
-  end
-
-  # add more hanswurst_roles at once
-  def add_roles(hsh)
-    self.hanswurst_data ||= {} 
-    self.hanswurst_roles ||= {}
-    hsh.each do |role,klass|
-      raise "class expected: #{klass.inspect}" unless klass.is_a? Class
-      handle_shared(role, klass)
-      self.hanswurst_roles.update role.to_s => klass.name
-    end
-    update_roles!
-    self.hanswurst_roles
-  end
-
-  # does he have a role
-  def role_exists?(role)
-    self.hanswurst_roles and self.hanswurst_roles[role.to_s]
-  end
-
-  # does he have hanswurst_data for the role
-  def hanswurst_data_exists?(role)
-    self.hanswurst_data and self.hanswurst_data[role.to_s]
-  end
-
-  # set a role
-  def set_role(role, value)
-    value ? set(role, value) : delete_role(role)
-  end
-
-  # delete a role
-  def delete_role(role)
-    delete role # delete the hanswurst_data
-    self.hanswurst_roles.delete role.to_s # and the role itself
-  end
-
-  # set instance for a role
-  def set(role, val)
-    self.hanswurst_data ||= {}
-    self.hanswurst_data.update role.to_s => val
-    update_roles!
-  end
-
-  # create a new instance of a role
-  def create(role)
-    raise "unknown role #{role.inspect}" unless role_exists? role.to_s
-    self.hanswurst_data ||= {}
-    self.hanswurst_data[role.to_s] = self.class.getClass(self.hanswurst_roles[role.to_s]).new
-    update_roles!
-  end
-
-  # delete a role
-  def delete(role)
-    self.hanswurst_data ||= {}
-    self.hanswurst_data.delete(role.to_s)
-    update_roles!
-    #self.hanswurst_data = {} # we have to do this, otherwise it won't save?!
-    #self.hanswurst_data = hsh
-  end
-
-  def as(role, &code)
-    return nil unless role_exists?(role)
-    unless hanswurst_data[role.to_s]                 
-      create(role.to_s)
-    end
-    if role_obj = hanswurst_data[role.to_s]
-      obj = As.new(self, role_obj)
-      obj.instance_eval(&code) if code
-      return obj
-    end
-    nil
-  end
 end
 
+

data/lib/hanswurst/as.rb

@@ -0,0 +1,35 @@
+# Each Hanswurst may have a different combination of roles. It's a very flexible way to be a couch potato.
+class Hanswurst
+
+  # helper for easy access to role attributes
+  class As
+    def initialize(doc, role)
+      @doc = doc
+      @role = role
+    end
+  
+    def _role
+      @role
+    end
+
+    def _id
+      @doc._id
+    end
+
+    def _doc
+      @doc
+    end
+
+    # we suppose, we have a subrole
+    def method_missing(meth, *args, &code)
+      # a hack around http://api.rubyonrails.org/classes/ActiveModel/Dirty.html
+      # since ActiveModel::Dirty does not recognize when property is a hash and hashentries do change
+      @doc.update_roles! if meth =~ /=$/
+
+      obj = @role.send(meth, *args)
+      obj = self.class.new(@doc, @role.send(meth, *args)) if obj.is_a? CouchPotato::Persistence
+      obj.instance_eval(&code) if code
+      obj
+    end
+  end
+end

data/lib/hanswurst/callbacks.rb

@@ -0,0 +1,68 @@
+class Hanswurst
+  module Callbacks
+    def self.included(base)
+      base.class_eval do
+        # mimic the create_document method from https://github.com/langalex/couch_potato/blob/master/lib/couch_potato/database.rb  
+        before_create do
+          ok = true
+          self.hanswurst_data.each do |role,document|
+            if document.is_a?(CouchPotato::Persistence)
+              document.errors.clear
+              document.created_at ||= (Time.zone || Time).now
+              document.updated_at = (Time.zone || Time).now
+              (ok = false) if false == document.run_callbacks(:validation_on_save) do
+                (ok = false) if false == document.run_callbacks(:validation_on_create) do
+                  raise(CouchPotato::Database::ValidationsFailedError.new(["role: " + role].concat(document.errors.full_messages))) unless database.send(:valid_document?, document)
+                end
+              end
+
+              (ok = false) if false == document.run_callbacks(:save) do
+                (ok = false) if false == document.run_callbacks(:create) do
+                  true
+                end
+              end
+            end
+          end
+          ok
+        end
+
+        # mimic the update_document method from https://github.com/langalex/couch_potato/blob/master/lib/couch_potato/database.rb  
+        before_update do
+          ok = true
+          self.hanswurst_data.each do |role,document|
+            if document.is_a?(CouchPotato::Persistence)
+              document.errors.clear
+              document.created_at ||= (Time.zone || Time).now
+              document.updated_at = (Time.zone || Time).now
+              (ok = false) if false == document.run_callbacks(:validation_on_save) do
+                (ok = false) if false == document.run_callbacks(:validation_on_update) do
+                  raise(CouchPotato::Database::ValidationsFailedError.new(["role: " + role].concat(document.errors.full_messages))) unless database.send(:valid_document?, document)
+                end
+              end
+
+              (ok = false) if false == document.run_callbacks(:save) do
+                (ok = false) if false == document.run_callbacks(:update) do
+                  true
+                end
+              end
+            end      
+          end
+          ok
+        end
+
+        # mimic the destroy_document method from https://github.com/langalex/couch_potato/blob/master/lib/couch_potato/database.rb  
+        before_destroy do
+          ok = true
+          self.hanswurst_data.each do |role,document|
+            if document.is_a?(CouchPotato::Persistence)
+              (ok = false) if false == document.run_callbacks(:destroy) do
+                true
+              end
+            end
+          end
+          ok
+        end
+      end
+    end
+  end
+end

data/lib/hanswurst/class_methods.rb

@@ -0,0 +1,55 @@
+
+# TODO allow subclasses of Hanswurst to have the role registry (or handle it via callback)
+
+class Hanswurst
+  # class methods for Hanswurst
+  module ClassMethods
+
+    # get class obj from a classname
+    def getClass(classname)
+      classname.split('::').inject Kernel do |c,name| c = c.const_get name; end
+    end
+
+    # hsh is role_alias => klass where role_alias should be a symbol
+    def register_role(hsh)
+      @roles ||= {}
+      @roles.update hsh
+    end
+
+    # returns the role klass for the role_alias (role_alias should be a symbol)
+    def role_class(role_alias)
+      @roles ||= {}
+      @roles[role_alias]
+    end
+
+    # creates a view to show only documents of the role +role_alias+ 
+    def role_view(role_alias, viewname, options)
+      # I keep this commented out to inform the reader that we don't want this in order to easily reuse general lists
+      #options[:list] &&= :"#{role_alias}_#{options[:list]}"
+      options[:conditions] &&= " && ( #{options[:conditions]} )"
+      options[:conditions] = "(doc.hanswurst_roles.#{role_alias} !== undefined)#{options[:conditions]}"
+      self.view :"#{role_alias}_#{viewname}", options
+    end
+
+    alias :view_for :role_view
+
+    # creates a list for documents of the role +role_alias+ 
+    def role_list(role_alias, listname, val)
+      self.list :"#{role_alias}_#{listname}", val.to_s
+    end
+
+    alias :list_for :role_list
+
+    # shortcuts view_for_[role], list_for_[role]
+    def method_missing(meth, *args, &code)
+      case meth
+      when /^view_for_(.+)$/
+        send(:view_for, $1, *args)
+      when /^list_for_(.+)$/
+        send(:list_for, $1, *args)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/hanswurst/delegates.rb

@@ -0,0 +1,35 @@
+class Hanswurst
+  module Delegates
+    def self.included(mod)
+      mod.instance_eval do
+        def delegates(hsh)
+          @delegations ||= {}
+          hsh.each do |prop,role|
+            if prop.is_a? Array
+              prop.each do |pr|
+                @delegations.update pr => role
+              end
+            else
+              @delegations.update prop => role
+            end
+          end
+        end
+
+        def delegations
+          @delegations || {}
+        end
+      end
+    end
+
+    # shortcuts view_for_[role], list_for_[role]
+    def method_missing(meth, *args, &code)
+      meth.to_s =~ /^([^=]+)=?$/
+      unified_meth = $1
+      if role = self.class.delegations[unified_meth.to_sym]
+        self.send(role).send(meth, *args, &code)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/hanswurst/instance_methods.rb

@@ -0,0 +1,130 @@
+class Hanswurst
+  def initialize(hsh={})
+    unless hsh.empty?
+      hsh.each do |role, obj|
+        self.send(:"#{role}=", obj)
+      end
+    end
+  end
+
+  # copy the doc including the roles
+  def copy()
+    attributes = self.to_hash
+    attributes.delete "ruby_class"
+    attributes.delete "_id"
+    attributes.delete "_rev"
+    attributes.delete :created_at
+    attributes.delete :updated_at
+    hanswust_data = attributes.delete :hanswurst_data
+    obj = self.class.new attributes
+    hanswust_data.each do |role,val|
+      obj.send(:"#{role}=", val.dup)
+    end
+    obj
+  end
+
+  def <<(hsh)
+    add_roles(hsh)
+  end
+
+  # a hack around http://api.rubyonrails.org/classes/ActiveModel/Dirty.html
+  # since ActiveModel::Dirty does not recognize when property is a hash and hashentries do change
+  def update_roles!
+    self.hanswurst_data_will_change!
+    true
+  end
+
+  private
+
+  # add a role
+  def add_role(role, klass, &code)
+    add_roles(role => klass)
+    as(role, &code)
+  end
+
+  def handle_shared(role, klass)
+    if klass.respond_to?(:shared_dependancies)
+      shared = {}
+      klass.shared_dependancies.each do |shared_role, shared_class|
+        shared_class = Hanswurst.role_class(shared_class) if shared_class.is_a? Symbol
+        shared[shared_role] = shared_class unless role_exists? shared_role
+      end
+      add_roles shared
+    end
+  end
+
+  # add more hanswurst_roles at once
+  def add_roles(hsh)
+    self.hanswurst_data ||= {} 
+    self.hanswurst_roles ||= {}
+    hsh.each do |role,klass|
+      raise "class expected: #{klass.inspect}" unless klass.is_a? Class
+      handle_shared(role, klass)
+      self.hanswurst_roles.update role.to_s => klass.name
+    end
+    update_roles!
+    self.hanswurst_roles
+  end
+
+  # does he have a role
+  def role_exists?(role)
+    self.hanswurst_roles and self.hanswurst_roles[role.to_s]
+  end
+
+  # does he have hanswurst_data for the role
+  def hanswurst_data_exists?(role)
+    self.hanswurst_data and self.hanswurst_data[role.to_s]
+  end
+
+  # set a role
+  def set_role(role, value)
+    value ? set(role, value) : delete_role(role)
+  end
+
+  # delete a role
+  def delete_role(role)
+    return false unless delete(role)  # delete the hanswurst_data
+    self.hanswurst_roles.delete role.to_s # and the role itself
+  end
+
+  # set instance for a role
+  def set(role, val)
+    self.hanswurst_data ||= {}
+    self.hanswurst_data.update role.to_s => val
+    update_roles!
+  end
+
+  # create a new instance of a role
+  def create(role)
+    raise "unknown role #{role.inspect}" unless role_exists? role.to_s
+    self.hanswurst_data ||= {}
+    self.hanswurst_data[role.to_s] = self.class.getClass(self.hanswurst_roles[role.to_s]).new
+    update_roles!
+  end
+
+  # delete a role
+  def delete(role)
+    self.hanswurst_data ||= {}
+    doc = self.hanswurst_data[role.to_s]
+    if doc && doc.is_a?(CouchPotato::Persistence)
+      return false if false == doc.run_callbacks(:destroy) do
+        self.hanswurst_data.delete(role.to_s)
+        update_roles!
+      end
+    end
+    true
+  end
+
+  def as(role, &code)
+    return nil unless role_exists?(role)
+    unless hanswurst_data[role.to_s]                 
+      create(role.to_s)
+    end
+    if role_obj = hanswurst_data[role.to_s]
+      obj = As.new(self, role_obj)
+      obj.instance_eval(&code) if code
+      return obj
+    end
+    nil
+  end
+end

data/lib/hanswurst/method_missing.rb

@@ -0,0 +1,18 @@
+class Hanswurst
+  module MethodMissing
+    # dispatches self.role calls and self.role= setters
+    def method_missing(meth, *args, &code)
+      value = args.first
+      case meth
+      when /^([^=]+)\=$/ # obj.role = ... # => we set a role
+        role=$1
+        add_role(role, value.class) unless role_exists?(role)
+        set_role(role, value) if role_exists?(role)
+        return as(meth)
+      else
+        return as(meth) if role_exists?(meth.to_s)
+      end
+      super
+    end
+  end
+end

data/lib/hanswurst/shares.rb

@@ -0,0 +1,17 @@
+class Hanswurst
+  module Shares
+    def self.included(mod)
+      mod.instance_eval do
+        def shares(hsh)
+          hsh = {hsh => hsh} if hsh.is_a? Symbol
+          @shared_dependancies ||= {}
+          @shared_dependancies.update hsh
+        end
+
+        def shared_dependancies
+          @shared_dependancies || {}
+        end
+      end
+    end
+  end
+end

data/lib/hanswurst/validator.rb

@@ -0,0 +1,74 @@
+class HanswurstValidator < ActiveModel::EachValidator
+  def doc_is_valid_role?(doc, roles)
+    !(roles & doc.hanswurst_roles.keys).empty?
+  end
+
+  def is_valid_klass?(klasses, value)
+    valid = false
+    klasses.each do |klass|
+      valid = true if value.is_a? klass
+    end
+    valid
+  end
+
+  def doc_is_valid_klass?(doc, klasses)
+    !(klasses & doc.hanswurst_roles.values).empty?
+  end
+
+
+  def validate_each(record, attribute, values)
+    #p options
+    #p record
+    return if values.nil?
+    values = values.values if values.class == Hash
+    values = [values] unless values.class == Array
+    valid = true
+    max = options[:max]
+    if max && values.size > max
+      record.errors.add attribute, "must not have more than #{max} entries"
+      return
+    end
+    fkey = options[:fkey] || false
+    if fkey
+      values = values.collect do |id|
+        CouchPotato.database.load_document id 
+      end
+    end
+
+    if klass = options[:class]
+      klasses = [klass].flatten
+      if fkey
+        klasses = klasses.collect{ |k| k.to_s }
+        values.each do |doc|
+          valid = false unless doc && doc.hanswurst_roles && doc_is_valid_klass?(doc, klasses)
+        end
+        record.errors.add attribute, "must be a doc id of a class #{klasses.join(' or ')}" unless valid
+      else
+        values.each do |thing|
+          valid = false unless is_valid_klass?(klasses, thing)  
+        end
+        record.errors.add attribute, "must be an instance of #{klasses.join(' or ')}" unless valid
+      end
+    elsif role = options[:role]
+      roles = [role].flatten.collect{ |r| r.to_s }
+      if fkey
+        values.each do |doc|
+          valid = false unless doc && doc.hanswurst_roles && doc_is_valid_role?(doc, roles)
+        end
+        record.errors.add attribute, "must be a doc id of a role #{roles.join(' or ')}" unless valid
+      else
+        klasses = roles.collect do |role_alias|
+          klass = Hanswurst.role_class(role_alias.to_sym)
+          record.errors.add(attribute,  "could not find role #{role_alias} with Hanswurst.role_class. Did you register it with Hanswurst.register_role() ?") if klass.nil?
+          klass
+        end
+        values.each do |thing|
+          valid = false unless is_valid_klass?(klasses, thing)  
+        end
+        record.errors.add attribute, "must be an instance of #{klasses.join(' or ')}" unless valid
+      end
+      
+    end
+    #roles = options[:in] || [options[:with]]    
+  end
+end

data/test/test_hanswurst.rb

@@ -5,6 +5,7 @@ CouchPotato::Config.database_name = ENV['COUCH_POTATO_TEST_DB']
 
 
 class Pers
+
   include CouchPotato::Persistence
   property :firstname
   property :lastname
@@ -12,6 +13,57 @@ class Pers
   def name(seperator)
     "#{lastname}#{seperator}#{firstname}"
   end
+
+  attr_accessor :callbacks
+
+  before_save do
+    @callbacks ||= []
+    @callbacks << :before_save
+  end
+
+  after_save do
+    @callbacks ||= []
+    @callbacks << :after_save
+  end
+
+  before_create do
+    @callbacks ||= []
+    @callbacks << :before_create
+  end
+
+  after_create do
+    @callbacks ||= []
+    @callbacks << :after_create
+  end
+
+  before_update do
+    @callbacks ||= []
+    @callbacks << :before_update
+  end
+
+  after_update do
+    @callbacks ||= []
+    @callbacks << :after_update
+  end
+
+  before_destroy do
+    @callbacks ||= []
+    @callbacks << :before_destroy
+  end
+
+  after_destroy do
+    @callbacks ||= []
+    @callbacks << :after_destroy
+  end
+end
+
+class PreventsDeletion
+  include CouchPotato::Persistence
+  property :data
+
+  before_destroy do
+    false
+  end
 end
 
 class Prod
@@ -55,18 +107,11 @@ end
 class F
   include CouchPotato::Persistence
 
-  #depends_on 'd' => D
-
   property :d
-
   property :f
-
   property :a # should be an instance of A
-
   property :perss # should be an Array of instances of Pers
-
-  property :h # should be a Hash
-  
+  property :h # should be a Hash  
 end
 
 class G
@@ -142,6 +187,10 @@ class TestCouch < Test::Unit::TestCase
     CouchPotato.database.view v
   end
 
+  def destroy(doc)
+    CouchPotato.database.destroy_document doc
+  end
+
   def update(id)
     doc = load id
     yield doc
@@ -153,6 +202,52 @@ class TestCouch < Test::Unit::TestCase
       recreate_db()
     end
 
+    should "invoke callbacks" do
+      o = Hanswurst.new
+      o.pers = Pers.new( :lastname => 'Duck' )
+      save o
+      assert_equal [:before_save, :before_create, :after_create, :after_save], o.pers.callbacks
+
+      o = load o._id
+      o.pers.lastname = 'Doc'
+      save o
+      assert_equal [:before_save, :before_update, :after_update, :after_save], o.pers.callbacks
+
+      id = o._id
+      o = load o._id
+      pers = o.pers
+      destroy o
+      assert_equal [:before_destroy, :after_destroy], pers.callbacks
+
+      o = load id
+      assert_equal nil, o
+
+      o = Hanswurst.new
+      o.pers = Pers.new( :lastname => 'Duck' )
+      save o
+
+      o = load o._id
+      pers = o.pers
+      o.pers = nil
+      assert_equal [:before_destroy, :after_destroy], pers.callbacks
+
+      o = Hanswurst.new
+      o.prevents = PreventsDeletion.new :data => 'something'
+      save o
+      o = load o._id
+      o.prevents = nil
+      assert_equal 'something', o.prevents.data
+
+      o = Hanswurst.new
+      o.prevents = PreventsDeletion.new :data => 'something'
+      save o
+      id = o._id
+      o = load o._id
+      destroy o
+      o = load id
+      assert_equal 'something', o.prevents.data
+    end
+
     should "save stuff" do
       o = Hanswurst.new
       o.product = Prod.new( :article_number => 'xyz', :name => 'prod1' )
@@ -241,11 +336,19 @@ class TestCouch < Test::Unit::TestCase
       assert_equal 'hiho', o.thing.a
     end
 
+    should "destroy a doc" do
+      o = Hanswurst.new
+      o.pers = Pers.new
+      o.pers.lastname = "hiho"
+      save o
+      o = load(o._id)
+      destroy o
+    end
 
     should "not save when validation fails" do
       o = Hanswurst.new
       o.product = Prod.new( :article_number => 'xyz')
-      assert_raises Hanswurst::RoleNotValid do
+      assert_raises CouchPotato::Database::ValidationsFailedError do
         save o
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hanswurst
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.5.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-19 00:00:00.000000000Z
+date: 2012-01-20 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: couch_potato
-  requirement: &19722520 !ruby/object:Gem::Requirement
+  requirement: &15523120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *19722520
+  version_requirements: *15523120
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &19721800 !ruby/object:Gem::Requirement
+  requirement: &15522500 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: 0.6.0
   type: :development
   prerelease: false
-  version_requirements: *19721800
+  version_requirements: *15522500
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &19720980 !ruby/object:Gem::Requirement
+  requirement: &15521920 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *19720980
+  version_requirements: *15521920
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &19720300 !ruby/object:Gem::Requirement
+  requirement: &15521320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 1.5.2
   type: :development
   prerelease: false
-  version_requirements: *19720300
+  version_requirements: *15521320
 - !ruby/object:Gem::Dependency
   name: rcov
-  requirement: &19719700 !ruby/object:Gem::Requirement
+  requirement: &15520780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *19719700
+  version_requirements: *15520780
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &19719020 !ruby/object:Gem::Requirement
+  requirement: &15520200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +76,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *19719020
+  version_requirements: *15520200
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &19686960 !ruby/object:Gem::Requirement
+  requirement: &15495700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,10 +87,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *19686960
+  version_requirements: *15495700
 - !ruby/object:Gem::Dependency
   name: linecache19
-  requirement: &19686300 !ruby/object:Gem::Requirement
+  requirement: &15495060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -98,10 +98,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *19686300
+  version_requirements: *15495060
 - !ruby/object:Gem::Dependency
   name: ruby-debug19
-  requirement: &19685720 !ruby/object:Gem::Requirement
+  requirement: &15494420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -109,10 +109,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *19685720
+  version_requirements: *15494420
 - !ruby/object:Gem::Dependency
   name: couch_potato
-  requirement: &19685160 !ruby/object:Gem::Requirement
+  requirement: &15493800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -120,7 +120,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *19685160
+  version_requirements: *15493800
 description: flexible enhancement of couch potato
 email: ! 'Base64.decode64(''bGludXhAbWFyY3JlbmVhcm5zLmRl
 
@@ -138,6 +138,14 @@ files:
 - Rakefile
 - VERSION
 - lib/hanswurst.rb
+- lib/hanswurst/as.rb
+- lib/hanswurst/callbacks.rb
+- lib/hanswurst/class_methods.rb
+- lib/hanswurst/delegates.rb
+- lib/hanswurst/instance_methods.rb
+- lib/hanswurst/method_missing.rb
+- lib/hanswurst/shares.rb
+- lib/hanswurst/validator.rb
 - test/helper.rb
 - test/test_hanswurst.rb
 homepage: http://github.com/metakeule/hanswurst
@@ -155,7 +163,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3336574218003098224
+      hash: -1349200765658973839
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: