hanswurst 0.4.3 → 0.5.0

data/README.md

@@ -47,16 +47,12 @@ first you have to build your roles as normal couch potato classes
 then you may use them as you like
 
     hw = Hanswurst.new
-    hw.add_role 'person', Person # first role then class
-    hw.add_role 'product', Product
-
-    hw.person___first_name = 'Diederich'
-    hw.person___last_name = 'Hessling' # an RoleNotValid error is raised if person___last_name is missing
+    hw << {:person => Person} # first role then class
+    hw.person.first_name = 'Diederich'
+    hw.person.last_name = 'Hessling' # an RoleNotValid error is raised if person___last_name is missing
 
     # you may also use some syntatic sugar with 'as', the following does the same thing as above
-    person = hw.as :person
-    person.first_name = 'Diederich'
-    person.last_name = 'Hessling'
+    hw = Hanswurst.new :person => Person.new(:first_name => 'Diederich', :last_name => 'Hessling') 
       
     # this is also possible
     hw.product = Product.new :price => 20, :in_stock => 1  
@@ -67,19 +63,11 @@ later...
 
     hw = CouchPotato.database.load_document id
 
-    hw.person___first_name  # => 'Diederich'
-    hw.person___name # => 'Diederich Hessling'
-    hw.product___price       # => 20
-
-    # or with 'as'
-    person = hw.as :person
-    person.first_name  # => 'Diederich'
-    person.last_name   # => 'Hessling'
-    person.name        # => 'Diederich Hessling'
+    hw.person.first_name  # => 'Diederich'
+    hw.person.name # => 'Diederich Hessling'
+    hw.product.price       # => 20
 
-
-you may also declare that roles are depending on other roles
-when you add that role, the others are also automatically added
+you may also set roles as properties of other roles
 
     class Address
       include CouchPotato::Persistence
@@ -91,33 +79,24 @@ when you add that role, the others are also automatically added
 
     class Person
       include CouchPotato::Persistence
-      include Hanswurst::Depends
 
-      depends_on 'address_privat', Address
-      depends_on 'address_work', Address
+      property :address_privat
+      property :address_work
+      
+      # gets invalid if address_privat / address_work are instances of Address
+      validates :address_privat, :hanswurst => {:class => Address}
+      validates :address_work, :hanswurst => {:class => Address}
       
       property :last_name
       property :first_name
     end
 
-    hw = Hanswurst.new
-    hw.add_role 'employee', Person
-    hw.employee___last_name = 'Hessling'
-    hw.employee__address_privat___city = 'Berlin'
-    hw.employee__address_work___city = 'Potsdam'
-
-    # or with 'as'
-    emp = hw.as :employee
-    emp.last_name = 'Hessling'
-
-    privat = emp.as :address_privat
-    privat.city = 'Berlin'
-    
-    work = emp.as :address_work
-    work.city = 'Potsdam'
+    hw = Hanswurst.new :employee => Person.new(:last_name => 'Hessling')
+    emp = hw.employee
+    emp.address_privat = Address.new :city => 'Berlin'
+    emp.address_work = Address.new :city => 'Potsdam'
 
-
-or as shared dependancy without prefix
+or as a shared dependancy
 
     class Address
       include CouchPotato::Persistence
@@ -131,30 +110,16 @@ or as shared dependancy without prefix
       include CouchPotato::Persistence
       include Hanswurst::Shares
 
-      shares 'address_privat', Address
-      shares 'address_work', Address
+      shares :address_privat => Address
+      shares :address_work => Address
       
       property :last_name
       property :first_name
     end
 
-    hw = Hanswurst.new
-    hw.add_role 'employee', Person
-    hw.employee___last_name = 'Hessling'
-    hw.address_privat___city = 'Berlin'
-    hw.address_work___city = 'Potsdam'
-
-    # or with 'as'
-    emp = hw.as :employee
-    emp.last_name = 'Hessling'
-
-    privat = hw.as :address_privat
-    privat.city = 'Berlin'
-    
-    work = hw.as :address_work
-    work.city = 'Potsdam'
-
-
+    hw = Hanswurst.new :employee => Person.new(:last_name => 'Hessling')
+    hw.address_privat.city = 'Berlin'
+    hw.address_work.city = 'Potsdam'
     
 All views are attached to the hanswurst design document
 You may create general views:

data/VERSION

@@ -1 +1 @@
-0.4.3
+0.5.0

data/lib/hanswurst.rb

@@ -1,29 +1,112 @@
 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)
+    klasses.include? value.class
+  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
+
+
 # Each Hanswurst may have a different combination of roles. It's a very flexible way to be a couch potato.
 class Hanswurst
-
-  module Depends
+  module Delegates
     def self.included(mod)
       mod.instance_eval do
-        def depends_on(aliasname, role)
-          @dependancies ||= {}
-          @dependancies[aliasname] = role
+        def delegates(attr_symbol, role)
+          @delegations ||= {}
+          @delegations[attr_symbol] = role
         end
 
-        def dependancies
-          @dependancies || {}
+        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(aliasname, role)
+        def shares(hsh)
+          hsh = {hsh => hsh} if hsh.is_a? Symbol
           @shared_dependancies ||= {}
-          @shared_dependancies[aliasname] = role
+          @shared_dependancies.update hsh
         end
 
         def shared_dependancies
@@ -50,30 +133,27 @@ class Hanswurst
 
   # helper for easy access to role attributes
   class As
-    def initialize(doc, *roles)
+    def initialize(doc, obj)
       @doc = doc
-      @roles = roles
+      @obj = obj
     end
 
     def _id
       @doc._id
     end
 
-    def as(*new_roles)
-      self.class.new(@doc, *@roles.dup.concat(new_roles))
-    end
-
-    def roles_as_string
-      @roles.join('__')
+    def _doc
+      @doc
     end
 
     # we suppose, we have a subrole
-    def method_missing(meth, *args)
-      if meth.to_s =~ /__/
-        @doc.send(:"#{roles_as_string}__#{meth}", *args)
-      else
-        @doc.send(:"#{roles_as_string}___#{meth}", *args)
+    def method_missing(meth, *args, &code)
+      obj = @obj.send(meth, *args)
+      if obj.is_a? CouchPotato::Persistence
+        obj = self.class.new(@doc, @obj.send(meth, *args))
       end
+      obj.instance_eval(&code) if code
+      obj
     end
   end
 
@@ -85,6 +165,18 @@ class Hanswurst
       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
@@ -126,10 +218,15 @@ class Hanswurst
       value = args.first
       case meth
       when /^([^=]+)___([^=]+)(\=)?$/ # obj.role__prop # => we get / set a property
-        role, property, setter = $1, $2, $3
-        return setter ? set_property(role, property, value) : read(role, property, *args)
+        raise "use of ___ methods is deprecated, please use Hanswurst#as"
+      #  role, property, setter = $1, $2, $3
+      #  return setter ? set_property(role, property, value) : read(role, property, *args)
       when /^([^=]+)\=$/ # obj.role = ... # => we set a role
-        return set_role(role, value) if role_exists?(role=$1)
+        role=$1
+        add_role(role, value.class) unless role_exists?(role)
+        return set_role(role, value) if role_exists?(role)
+      else
+        return as(meth) if role_exists?(meth.to_s)
       end
       super
     end
@@ -149,25 +246,48 @@ class Hanswurst
 
   include MethodMissing
 
-  # add a role
-  def add_role(role, klass)
-    add_roles(role => klass)
+  def initialize(hsh={})
+    unless hsh.empty?
+      hsh.each do |role, obj|
+        self.send(:"#{role}=", obj)
+      end
+    end
   end
 
-  def handle_dependancies(role, klass)
-    if klass.respond_to?(:dependancies)
-      deps = {}
-      klass.dependancies.each do |dep_role, dep_class|
-        deps["#{role}__#{dep_role}"] = dep_class
-      end
-      add_roles deps
+  # 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.set role, val
+      obj.send(:"#{role}=", val.dup)
     end
+    obj
+  end
+
+  def <<(hsh)
+    add_roles(hsh)
+  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
@@ -180,9 +300,9 @@ class Hanswurst
     self.hanswurst_roles ||= {}
     hsh.each do |role,klass|
       raise "class expected: #{klass.inspect}" unless klass.is_a? Class
-      handle_dependancies(role, klass)
       handle_shared(role, klass)
       self.hanswurst_roles.update role.to_s => klass.name
+      
     end
     self.hanswurst_roles
   end
@@ -239,28 +359,22 @@ class Hanswurst
 
   # read a property of a role
   def read(role, property, *args)
-    return self.hanswurst_data[role.to_s].send(property.to_sym, *args) if hanswurst_data_exists?(role.to_s)
+    if hanswurst_data_exists?(role.to_s)
+      return self.hanswurst_data[role.to_s].send(property.to_sym, *args)
+    end
     nil
   end
 
-  def as(role)
-    return As.new(self, role)
-  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.set role, val
+  def as(role, &code)
+    unless hanswurst_data[role.to_s]                 
+      create(role.to_s)
     end
-    obj
+    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
 
   # update a property of a role

data/test/test_hanswurst.rb

@@ -32,10 +32,9 @@ end
 
 class D
   include CouchPotato::Persistence
-  include Hanswurst::Depends
 
-  depends_on 'person', Pers
-  depends_on 'prod', Prod
+  property :person # looks into Hanswurst.role_class
+  property :prod  # => Prod
   property :my_prop
   
 end
@@ -44,7 +43,10 @@ class E
   include CouchPotato::Persistence
   include Hanswurst::Shares
 
-  shares 'person', Pers
+  shares :person => :person
+  shares :prod => Prod
+
+  shares :product
 
   property :e
 end
@@ -52,12 +54,53 @@ end
 
 class F
   include CouchPotato::Persistence
-  include Hanswurst::Depends
 
-  depends_on 'd', D
+  #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
   
 end
+
+class G
+  include CouchPotato::Persistence
+  include Hanswurst::Delegates
+
+  #depends_on 'd' => D
+  property :d
+  delegates :my_prop, :d
+
+  property :a_instance # should be an instance of Thing::A
+  property :prod # should be an instance of Prod
+  property :pers # should be an instance of Pers
+  property :prod_doc_id # should be an doc id of a doc with role Prod
+  property :pers_doc_id # should be an doc id of a doc with role Pers
+
+  property :prod_or_pers # could have an instance of Prod or Pers
+  property :prod_or_pers_doc_id # could be a doc with a role of Prod or Pers
+
+  delegates :name, :prod
+  delegates :article_number, :prod
+  delegates :a, :a_instance
+
+  validates :prod, :hanswurst => {:class => Prod}
+  validates :pers, :hanswurst => {:role => :person} # warning this role is from Hanswurst#roles
+  validates :prod_or_pers, :hanswurst => {:class => [Prod, Pers]}
+  validates :prod_or_pers_doc_id, :hanswurst => {:role => [:person, :prod], :fkey => true, :max => 2}
+
+  validates :pers_doc_id, :hanswurst => {:role => :person, :fkey => true} # warning this role is from the added role alias
+  validates :prod_doc_id, :hanswurst => {:class => Prod, :fkey => true}
+end
+
+Hanswurst.register_role(:person => Pers, :product => Prod)
+
 Hanswurst.list_for :pers, :complete_name, %q|
 function(head, req) {
   var row;
@@ -114,68 +157,72 @@ class TestCouch < Test::Unit::TestCase
 
     should "save stuff" do
       o = Hanswurst.new
-      o.add_role 'person', Pers
-      o.add_role 'product', Prod
       o.product = Prod.new( :article_number => 'xyz', :name => 'prod1' )
       o.person = Pers.new( :firstname => 'Donald', :lastname => 'Duck' ) 
       save o
       o = load(o._id)      
       hanswurst_roles = {'person' => 'Pers', 'product' => 'Prod'}
       assert_equal hanswurst_roles, o.hanswurst_roles
-      assert_equal 'prod1', o.hanswurst_data["product"].name
-      assert_equal 'Donald', o.hanswurst_data["person"].firstname
-      assert_equal 'Donald', o.person___firstname
+      assert_equal 'prod1', o.product.name
+      assert_equal 'Donald', o.person.firstname
+      assert_equal 'Donald', o.person.firstname
     end
 
     should "save hanswurst_roles" do
       o = Hanswurst.new
-      o.add_role 'person', Pers
-      o.add_role 'product', Prod
-      o.product___article_number = "abc"
-      o.product___name =  "prod1"
-      o.person___firstname = "Bugs"
-      o.person___lastname = "Bunny"
+      o.person = Pers.new
+      o.product = Prod.new
+      prod = o.product
+      prod.article_number = "abc"
+      prod.name =  "prod1"
+      
+      pers = o.person
+      pers.firstname = "Bugs"
+      pers.lastname = "Bunny"
       save o
       o = load(o._id)
       hanswurst_roles = {'person' => 'Pers', 'product' => 'Prod'}
       assert_equal hanswurst_roles, o.hanswurst_roles
-      assert_equal 'Bugs', o.person___firstname
-      assert_equal 'Bunny', o.person___lastname
-      assert_equal 'abc', o.product___article_number
+      assert_equal 'Bugs', o.person.firstname
+      assert_equal 'Bunny', o.person.lastname
+      assert_equal 'abc', o.product.article_number
 
-      o.product___article_number = "cde"
+      o.product.article_number = "cde"
+      #p o.product._doc
       save o
       o = load(o._id)
-      assert_equal 'prod1', o.product___name
-      assert_equal 'Bugs', o.person___firstname
-      assert_equal 'cde', o.product___article_number
+      assert_equal 'prod1', o.product.name
+      assert_equal 'Bugs', o.person.firstname
+      assert_equal 'abc', o.product.article_number
 
       o.product = nil
       save o
       o = load(o._id)
-      assert_equal nil, o.product___name
+      assert_raise NoMethodError do
+        o.product.name
+      end
       assert !o.hanswurst_roles.has_key?("product")
-      assert_equal 'Bugs', o.person___firstname
-      assert_equal nil, o.product___article_number
-      #p [:person, o.person]
-      assert_equal 'Bunny, Bugs', o.person___name(', ')
+      assert_equal 'Bugs', o.person.firstname
+      assert_raise NoMethodError do
+        o.product.article_number
+      end
+      assert_equal 'Bunny, Bugs', o.person.name(', ')
     end
 
     should "save for moduled classed" do
       o = Hanswurst.new
-      o.add_role 'thing', Thing::A
-      o.thing___a = "hiho"
+      o.thing = Thing::A.new
+      o.thing.a = "hiho"
       save o
       o = load(o._id)
       hanswurst_roles = {'thing' => 'Thing::A'}
       assert_equal hanswurst_roles, o.hanswurst_roles
-      assert_equal 'hiho', o.thing___a
+      assert_equal 'hiho', o.thing.a
     end
 
 
     should "not save when validation fails" do
       o = Hanswurst.new
-      o.add_role 'product', Prod
       o.product = Prod.new( :article_number => 'xyz')
       assert_raises Hanswurst::RoleNotValid do
         save o
@@ -183,118 +230,192 @@ class TestCouch < Test::Unit::TestCase
     end
 
     should "make a view with list" do
-      o = Hanswurst.new
-      o.add_role 'pers', Pers
-      o.pers = Pers.new :firstname => "Donald", :lastname => "Duck"
+      o = Hanswurst.new(:pers => Pers.new(:firstname => "Donald", :lastname => "Duck"))
       save o
       a = Hanswurst.new
-      a.add_role 'pers', Pers
       a.pers = Pers.new :firstname => "Mickey", :lastname => "Mouse"
       save a
       assert_equal "Donald Duck", view(Hanswurst.pers_all_names(:startkey_docid => "Donald")).first.hanswurst_data["pers"].complete_name
       assert_equal "Donald", view(Hanswurst.pers_all_names(:startkey_docid => "Donald")).first.hanswurst_data["pers"].firstname
     end
 
-    should "create dependancies based on definitions" do
-      o = Hanswurst.new
-      o.add_role 'do', D
-      o.do___my_prop = "4AD"
-      o.do__person___firstname = "Dagobert"
-      o.do__person___lastname = "Duck"
-      o.do__prod___name = "Comic Hero"
+    should "allow roles to have roles" do
+      o = Hanswurst.new(:do => D.new)
+      doer = o.do 
+      doer.my_prop = "4AD"
+      doer.person = Pers.new
+      pers = doer.person
+      pers.firstname = "Dagobert"
+      pers.lastname = "Duck"
+      doer.prod = Prod.new
+      doer.prod.name = "Comic Hero"
+    
       save o
       o = load(o._id)
-      assert_equal "4AD", o.do___my_prop
-      assert_equal "Dagobert", o.do__person___firstname
-      assert_equal "Comic Hero", o.do__prod___name
+      assert_equal "4AD", o.do.my_prop
+      assert_equal "Dagobert", o.do.person.firstname
+      assert_equal "Comic Hero", o.do.prod.name
 
       q = Hanswurst.new
-      q.add_role 'done', D
+      q << {'done' => D}
       q.done = D.new( :my_prop => '5AD')
-      q.done__person___firstname = "Dagobert"
-      q.done__person___lastname = "Duck"
-      q.done__prod___name = "Comic Hero"
+      q.done.person = Pers.new
+      q.done.person.firstname = "Dagobert"
+      q.done.person.lastname = "Duck"
+      q.done.prod = Prod.new
+      q.done.prod.name = "Comic Hero"
       save q
       q = load(q._id)
-      assert_equal "5AD", q.done___my_prop
-      assert_equal "Dagobert", q.done__person___firstname
-      assert_equal "Comic Hero", q.done__prod___name
+      assert_equal "5AD", q.done.my_prop
+      assert_equal "Dagobert", q.done.person.firstname
+      assert_equal "Comic Hero", q.done.prod.name
     end
 
-    should "create shared dependancies based on definitions" do
-      o = Hanswurst.new
-      o.add_role 'do', E
-      o.do___e = "4AD"
-      o.person___lastname = "Duck"
+    should "create shared dependancies based on definitions A" do
+      o = Hanswurst.new(:do => E.new)
+      o.do.e = "4AD"
+      #p [:roles, o.hanswurst_roles]
+      o.person.lastname = "Duck"
+      o.prod.name = 'tester'
+      o.product.name = 'tester2'
       save o
       o = load(o._id)
-      assert_equal "4AD", o.do___e
-      assert_equal "Duck", o.person___lastname
+      assert_equal "4AD", o.do.e
+      assert_equal "Duck", o.person.lastname
+      assert_equal "tester", o.prod.name
+      assert_equal "tester2", o.product.name
     end
 
     should "create shared dependancies based on definitions" do
       o = Hanswurst.new
-      o.add_role 'fff', F
-      o.fff__d__person___lastname = "Duck"
-      o.fff__d__prod___name = "testerer"
-      o.fff___f = "FFF"
-      o.fff__d___my_prop = "hiho"
+      o << {'fff' => F}
+      fff = o.fff
+      fff.d = D.new
+      d = fff.d
+      d.person = Pers.new
+      d.person.lastname = "Duck"
+      d.prod = Prod.new
+      d.prod.name = "testerer"
+      fff.f = "FFF"
+      d.my_prop = "hiho"
       save o
       q = load(o._id)
-      assert_equal "FFF", q.fff___f
-      assert_equal "Duck", q.fff__d__person___lastname
-      assert_equal "hiho", q.fff__d___my_prop
-      assert_equal "testerer", q.fff__d__prod___name
+      assert_equal "FFF", q.fff.f
+      assert_equal "Duck", q.fff.d.person.lastname
+      assert_equal "hiho", q.fff.d.my_prop
+      assert_equal "testerer", q.fff.d.prod.name
     end
 
-    should "allow easy access to role specific methods via 'as'" do
+    should "copy docs" do
       o = Hanswurst.new
-      o.add_role 'fff', F
-      f = o.as 'fff'
-      d = f.as "d"
-      person = d.as "person"
+      o << { 'fff' => F }
+      f = o.fff
+      f.d = D.new
+      d = f.d
+      d.person = Pers.new
+      person = d.person
       person.firstname = "Donald"
       person.lastname = "Duck"
       f.f = "FFF"
-      d.prod___name = "testerer"
+      d.prod = Prod.new
+      d.prod.name = "testerer"
       d.my_prop = "hiho"
       save o
       q = load(o._id)
-      assert_equal "FFF", q.fff___f
-      assert_equal "Duck", q.fff__d__person___lastname
-      assert_equal "hiho", q.fff__d___my_prop
-      assert_equal "testerer", q.fff__d__prod___name
-      
-      qf = q.as :fff
-      
-      assert_equal "FFF", qf.f
+      r = q.copy
+      save r
+      s = load(r._id)
+      assert o._id != r._id, "id of source and copy should not be equal"
+      assert_equal "FFF", s.fff.f
+      assert_equal "Duck", s.fff.d.person.lastname
+      assert_equal "hiho", s.fff.d.my_prop
+      assert_equal "testerer", s.fff.d.prod.name
+    end
+
+    should "copy docs with role that has property of another role" do
+      o = Hanswurst.new
+      o << {'f' => F }
+      o.f.a = Thing::A.new :a => 'A'
+      save o
+      q = load(o._id)
+      r = q.copy
+      save r
+      s = load(r._id)
 
-      qpers = qf.as(:d).as :person
-      assert_equal "Duck", qpers.lastname
-      assert_equal "Duck, Donald", qpers.name(', ')
+      assert_equal "A", q.f.a.a      
+      assert o._id != r._id, "id of source and copy should not be equal"
+      assert_equal "A", s.f.a.a 
     end
 
-    should "copy docs" do
+    should "copy docs with role that has property of another role" do
       o = Hanswurst.new
-      o.add_role 'fff', F
-      f = o.as 'fff'
-      d = f.as "d"
-      person = d.as "person"
-      person.firstname = "Donald"
-      person.lastname = "Duck"
-      f.f = "FFF"
-      d.prod___name = "testerer"
-      d.my_prop = "hiho"
+      o << { 'f' => F }
+      o.f.h = {"test" => "hash"}
+      o.f.perss = [Pers.new(:firstname => 'Donald'), Pers.new(:firstname => 'Dagobert')]
       save o
       q = load(o._id)
       r = q.copy
       save r
       s = load(r._id)
+
+      assert_equal "Donald", q.f.perss.first.firstname      
+      assert_equal "Dagobert", q.f.perss.last.firstname      
+      assert_equal({"test" => "hash"}, q.f.h)
       assert o._id != r._id, "id of source and copy should not be equal"
-      assert_equal "FFF", s.fff___f
-      assert_equal "Duck", s.fff__d__person___lastname
-      assert_equal "hiho", s.fff__d___my_prop
-      assert_equal "testerer", s.fff__d__prod___name
+      assert_equal "Donald", s.f.perss.first.firstname      
+      assert_equal "Dagobert", s.f.perss.last.firstname      
+      assert_equal({"test" => "hash"}, s.f.h)
+    end
+
+    should "delegate" do
+      o = Hanswurst.new
+      o << {'g' => G}
+      o.g.d = D.new
+      o.g.my_prop = 'testprop'
+      o.g.a_instance = Thing::A.new(:a => 'My A')
+      o.g.prod = Prod.new
+      o.g.name = "my prod name"
+      o.g.article_number = "my article number"
+      save o
+      q = load(o._id)
+      assert_equal "My A", q.g.a_instance.a
+      assert_equal "testprop", q.g.d.my_prop
+      assert_equal "My A", q.g.a
+      assert_equal "testprop", q.g.d.my_prop
+      assert_equal "testprop", q.g.my_prop
+      assert_equal "my prod name", q.g.name
+      assert_equal "my prod name", q.g.prod.name
+      assert_equal "my article number", q.g.article_number            
+    end
+
+    should "make the right validations" do
+      pers = Hanswurst.new
+      pers << { 'person' => Pers }
+      pers.person.lastname = "Duck"
+      save pers
+      prod = Hanswurst.new :prod => Prod.new
+      prod.prod.name = "Car"
+      save prod
+      o = Hanswurst.new 'g' => G.new
+      g = o.g
+      g.pers = Pers.new(:lastname => "Simpson")
+      g.prod = { :prod => Prod.new(:name => "Automobile")}
+      g.prod_or_pers = [Pers.new(:lastname => "He-Man"), Prod.new(:name => "Superman")]
+      g.prod_or_pers_doc_id = {:pers => pers._id, :prod => prod._id}
+      g.pers_doc_id = pers._id
+      g.prod_doc_id = [prod._id]
+
+      save o
+      q = load(o._id)
+      g = q.g
+      assert_equal "Simpson", g.pers.lastname
+      assert_equal "Automobile", g.prod['prod'].name
+      assert_equal pers._id, g.pers_doc_id
+      assert_equal prod._id, g.prod_doc_id.first
+      assert_equal "He-Man", g.prod_or_pers.first.lastname
+      assert_equal "Superman", g.prod_or_pers.last.name
+      assert_equal pers._id, g.prod_or_pers_doc_id['pers']
+      assert_equal prod._id, g.prod_or_pers_doc_id['prod']
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hanswurst
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-17 00:00:00.000000000Z
+date: 2012-01-18 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: couch_potato
-  requirement: &14466440 !ruby/object:Gem::Requirement
+  requirement: &24934880 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *14466440
+  version_requirements: *24934880
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &14465840 !ruby/object:Gem::Requirement
+  requirement: &24934100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: 0.6.0
   type: :development
   prerelease: false
-  version_requirements: *14465840
+  version_requirements: *24934100
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &14465220 !ruby/object:Gem::Requirement
+  requirement: &24933340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *14465220
+  version_requirements: *24933340
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &14464520 !ruby/object:Gem::Requirement
+  requirement: &24932660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 1.5.2
   type: :development
   prerelease: false
-  version_requirements: *14464520
+  version_requirements: *24932660
 - !ruby/object:Gem::Dependency
   name: rcov
-  requirement: &14463900 !ruby/object:Gem::Requirement
+  requirement: &24932080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *14463900
+  version_requirements: *24932080
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &14463220 !ruby/object:Gem::Requirement
+  requirement: &24931380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +76,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *14463220
+  version_requirements: *24931380
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &14462520 !ruby/object:Gem::Requirement
+  requirement: &24905140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,10 +87,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *14462520
+  version_requirements: *24905140
 - !ruby/object:Gem::Dependency
   name: linecache19
-  requirement: &14461820 !ruby/object:Gem::Requirement
+  requirement: &24904540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -98,10 +98,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *14461820
+  version_requirements: *24904540
 - !ruby/object:Gem::Dependency
   name: ruby-debug19
-  requirement: &14461100 !ruby/object:Gem::Requirement
+  requirement: &24903960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -109,10 +109,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *14461100
+  version_requirements: *24903960
 - !ruby/object:Gem::Dependency
   name: couch_potato
-  requirement: &14429280 !ruby/object:Gem::Requirement
+  requirement: &24903340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -120,7 +120,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *14429280
+  version_requirements: *24903340
 description: flexible enhancement of couch potato
 email: ! 'Base64.decode64(''bGludXhAbWFyY3JlbmVhcm5zLmRl
 
@@ -155,7 +155,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1650791006262531453
+      hash: 542468889761003364
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: