thingtank 0.1.0 → 0.2.0

data/lib/thingtank/character_handling.rb

@@ -0,0 +1,198 @@
+class ThingTank 
+  module CharacterHandling
+    def self.included(klass)
+      klass.class_eval do
+
+        def properties_of_character(klass)
+          hsh = {}
+          (klass.character_properties || []).each do |k| 
+            hsh.update(k.to_s => self[k.to_s])  unless self[k.to_s].nil?
+          end
+          hsh
+        end
+
+        def get_character(klass, db)
+          hsh = properties_of_character(klass)
+          hsh.update "_id" => self["_id"], "_rev" => self["_rev"] if (had?(klass) && !hsh.empty?)
+          inst = klass.new hsh, :directly_set_attributes => true, :database => db
+          @dependencies.save_character(inst)
+          inst
+        end
+
+        # get property as pseudo doc to play with
+        def with(key, &code)
+          self[key] ||= {}
+          case self[key]
+          when String # assume we got a doc id
+            doc = ThingTank.get(self[key])
+            (code.call(doc) ; doc.save) if code
+            doc
+          when Hash
+            doc = self.class.new self[key], :directly_set_attributes => true, :database => FakeBase.new(self, nil)
+            @dependencies.add_child(key, doc)
+            @dependencies.refresh(false)
+            (code.call(doc) ; doc.save) if code
+            doc
+          when Array
+            with_all(key)
+          else
+            raise "not supported: #{self[key].inspect}"
+          end
+        end
+
+        def with_all(key, props=nil)
+          self[key] ||= []
+          props ||= [self[key]].flatten
+          docs = props.collect { |prop| self.class.new prop, :directly_set_attributes => true, :database => FakeBase.new(self, nil) }
+          @dependencies.add_child(key, docs)
+          docs.each { |doc| yield doc ; doc.save } if block_given?
+          docs
+        end
+
+        def with_nth(key,n)
+          self[key] ||= []
+          props = [self[key]].flatten
+          n = 0 if n == :first
+          n = props.size-1 if n == :last
+          n = 0 if n < 0
+          while n > props.size - 1
+            props << {}
+          end
+          docs = with_all(key, props)
+          (yield docs[n] ; docs[n].save) if block_given?
+          docs[n]
+        end
+
+        def with_first(key,&code)
+          with_nth(key,:first, &code)
+        end
+
+        def with_last(key,&code)
+          with_nth(key,:last, &code)
+        end
+
+        def property_to_character(key, klass)
+          case self[key]
+          when Hash
+            with(key).to_character(klass)
+          when Array
+            with_all(key).collect { |doc| doc.to_character(klass) }
+          end
+        end
+
+        # register a character
+        def register_character(klass)
+          self['characters'] ||= []
+          self['characters'] << klass.to_s unless self['characters'].include? klass.to_s
+        end
+
+        def unregister_character(character)
+          if has?(character)
+            self["characters"] ||= []
+            self["characters"].delete character.to_s
+          end
+        end
+
+        def add_character(klass, key=nil, &code)
+          if key
+            key = key.to_s
+            if val = self[key]
+              self[key] = [val] unless val.is_a? Array
+              self[key] << {}
+              last_character(klass, key, &code)
+            else
+              self[key] = {}
+              to_character(klass, key, &code)
+            end
+          else
+            to_character(klass, &code)
+          end
+        end
+
+        def _root
+          @dependencies.find_root_doc
+        end
+
+        def delete_character(character_doc)
+          klass = character_doc.class
+          deleteable_attributes(klass).each { |k| delete(k) ; character_doc[k] = nil }
+          @dependencies.already_saved(character_doc) # prevent an endless loop      
+          unregister_character(klass)
+          @dependencies.remove_character(klass)
+          @dependencies.refresh_parent()
+        end
+
+        def deleteable_attributes(klass)
+          character_attrs = attributes_by_characters
+          character = klass.to_s
+          deleteable_attrs = klass.character_properties.select do |prop|
+            character_attrs[prop].empty? || (character_attrs[prop].size == 1 && character_attrs[prop].first == character)
+          end
+          %w| _id _rev type update_me characters|.each{ |k|  deleteable_attrs.delete k }
+          return deleteable_attrs
+        end
+
+        def attributes_by_characters()
+          attributes = {}
+          self["characters"].each do |character|
+            character.constantize.character_properties.each do |prop|
+              attributes[prop] ||= []
+              attributes[prop] << character unless attributes[prop].include?(character)
+            end
+          end
+          return attributes
+        end
+    
+        def to_character(klass, key=nil, add_character=true, &code)
+          @dependencies.add_character(klass) if add_character && key.nil?
+          character = key ? property_to_character(key, klass) : FakeBase.new(self, klass, add_character).get()
+          (code.call(character) ; character.flush_to_doc) if code
+          character
+        end
+
+        alias :as :to_character
+        alias :has :to_character
+        alias :act_as :to_character
+        alias :be :to_character
+        alias :have :to_character
+        alias :are :to_character
+        alias :is :to_character
+
+        def save_character_attributes(character_doc)
+          @dependencies.already_saved(character_doc) # prevent an endless loop          
+          attributes = character_doc.to_character_hash(true)
+          unsavebales = attributes.keys - (character_doc.class.character_properties || [])
+          raise "character #{character_doc.class} tried to save properties that it does not have: #{unsavebales.inspect}" unless unsavebales.empty?
+          self.update_attributes attributes
+          @dependencies.refresh_parent()
+        end
+
+        # if the doc when coming from db already had this character
+        def had?(klass)
+          return false unless self["characters"] and self["characters"].include? klass.name
+          return true
+        end
+
+        # has the document the character, is it supposed to have it and does it have the necessary properties
+        def has?(klass)
+          return true if @dependencies.has_character?(klass)
+          return false unless self["characters"] and self["characters"].include? klass.name
+          could_be? klass
+        end
+        alias :is? :has?
+
+        # could the document have the character
+        def could_have?(klass)
+          to_character(klass, nil, false).valid?
+        end
+        alias :could_be? :could_have?
+
+        # characters that are not valid
+        def invalid_characters
+          (self["characters"] || []).select { |character| !self.as(character.constantize).valid? }
+        end
+
+      end
+    end
+  end
+end

data/lib/thingtank/dependencies.rb

@@ -1,6 +1,6 @@
 class ThingTank 
 
-  # tracks the dependencies of a ThingTank, such as saving of roles, children ThingTanks, registration of roles
+  # tracks the dependencies of a ThingTank, such as saving of characters, children ThingTanks, registration of characters
   class Dependencies
     def initialize(doc)
       @doc = doc
@@ -15,49 +15,49 @@ class ThingTank
       { :registration => @registration, :save => @save, :children => @children }.inspect
     end
 
-    def register_roles
-      @registration.each { |role| @doc.register_role(role) }
+    def register_characters
+      @registration.each { |character| @doc.register_character(character) }
     end
 
     def save_all()
       refresh true
-      @save.each { |role_instance| role_instance.save }
+      @save.each { |character_instance| character_instance.save }
     end
 
-    def add_role(role)
-      @registration << role
+    def add_character(character)
+      @registration << character
     end
 
-    def remove_role(role)
-      @registration.delete(role) if has_role?(role)
+    def remove_character(character)
+      @registration.delete(character) if has_character?(character)
     end
 
-    def has_role?(klass)
+    def has_character?(klass)
       @registration.include? klass
     end
 
-    def save_role(role_instance)
-      @save << role_instance unless @save.include? role_instance
+    def save_character(character_instance)
+      @save << character_instance unless @save.include? character_instance
     end
 
-    def already_saved(role_instance)
-      @save.delete role_instance
+    def already_saved(character_instance)
+      @save.delete character_instance
     end
 
     def refresh(save=false, with_parent=true)
-      register_roles
+      register_characters
       @children.each do |key,child|
         @doc[key] = case child
         when Array
           child.collect do |d|
             d.dependencies.refresh(save, false)
             d.save if save
-            d.to_role_hash
+            d.to_character_hash
           end
         else
           child.dependencies.refresh(save, false)
           child.save if save
-          child.to_role_hash
+          child.to_character_hash
         end
       end
       refresh_parent() if with_parent

data/lib/thingtank/fakebase.rb

@@ -1,11 +1,11 @@
-# a replacement database for roles
+# a replacement database for characters
 class ThingTank::FakeBase
 
-  def initialize(doc, role, add_dep = true)
+  def initialize(doc, character, add_dep = true)
     @db = doc.database
     @doc = doc
-    @role = role
-    @doc.dependencies.add_role(role) if add_dep
+    @character = character
+    @doc.dependencies.add_character(character) if add_dep
   end
 
   def method_missing(meth, *args)
@@ -17,7 +17,7 @@ class ThingTank::FakeBase
     super
   end
 
-  def to_role(klass)
+  def to_character(klass)
     self.class.new(@doc, klass).get()
   end
 
@@ -25,25 +25,25 @@ class ThingTank::FakeBase
     {"ok" => ok}
   end
 
-  def save_doc(role_doc)
-    if role_doc.is_a? ThingTank # I dunno why this happens
+  def save_doc(character_doc)
+    if character_doc.is_a? ThingTank # I dunno why this happens
       @doc.dependencies.refresh_parent()
     else
-      @doc.save_role_attributes(role_doc) if role_doc.changed?
+      @doc.save_character_attributes(character_doc) if character_doc.changed?
     end
     result
   end
 
-  def delete_doc(*role_docs)    
-    role_docs.each do |role_doc|
-      # delete only the attributes from me that are no part of another role, since we will have different doc ids
+  def delete_doc(*character_docs)    
+    character_docs.each do |character_doc|
+      # delete only the attributes from me that are no part of another character, since we will have different doc ids
       # for each doc we will need to identify the remaining attributes
-      doc, save = (role_doc["_id"].nil? || role_doc["_id"] == @doc.id) ?
+      doc, save = (character_doc["_id"].nil? || character_doc["_id"] == @doc.id) ?
         [@doc, false] : 
-        [@db.get(role_doc["_id"]), true]
+        [@db.get(character_doc["_id"]), true]
 
-      doc.delete_role(role_doc)
-      doc.save if save # if all roles are from our doc, only save once: at the end
+      doc.delete_character(character_doc)
+      doc.save if save # if all characters are from our doc, only save once: at the end
     end
     @doc.save if @doc.changed?
     result()
@@ -52,10 +52,10 @@ class ThingTank::FakeBase
   def get(id=:doc_id)
     id = @doc.id if id == :doc_id
     doc = id == @doc.id ? @doc : @db.get(id)
-    doc.get_role(@role, self)
+    doc.get_character(@character, self)
   end
 
-  def _role_doc
+  def _character_doc
     @doc
   end
 

data/lib/thingtank/shared_methods.rb

@@ -4,8 +4,8 @@ class ThingTank
       klass.class_eval do
 
         # only export the changed properties
-        def changed_to_role_hash(exclude_roles=false)
-          skips = skip_keys(exclude_roles)
+        def changed_to_character_hash(exclude_characters=false)
+          skips = skip_keys(exclude_characters)
           hsh = {}
           changes.each do |key,arr|
             _old, _new = arr
@@ -16,22 +16,22 @@ class ThingTank
           hsh
         end
 
-        def skip_keys(exclude_roles=false)
+        def skip_keys(exclude_characters=false)
           arr = %w|_id _rev type update_me updated_at created_at|
-          arr << 'roles' if exclude_roles
+          arr << 'characters' if exclude_characters
           arr
         end
 
-        def to_role_hash(exclude_roles=false)
+        def to_character_hash(exclude_characters=false)
           hsh = to_hash
-          skip_keys(exclude_roles).each{ |k|  hsh.delete k }
+          skip_keys(exclude_characters).each{ |k|  hsh.delete k }
           hsh
         end
 
-        def nth_role(klass, key, n, &code)
-          orig_role = to_role(klass, key)
-          list = [orig_role].flatten
-          role = case n
+        def nth_character(klass, key, n, &code)
+          orig_character = to_character(klass, key)
+          list = [orig_character].flatten
+          character = case n
           when :last
             list.last
           when :first
@@ -40,21 +40,21 @@ class ThingTank
             list[n]
           end
           if code
-            code.call(role)
-            role.flush_to_doc
+            code.call(character)
+            character.flush_to_doc
           end
-          if orig_role.is_a?(Array)
-            role._role_doc.dependencies.refresh_parent
+          if orig_character.is_a?(Array)
+            character._character_doc.dependencies.refresh_parent
           end
-          role
+          character
         end
 
-        def last_role(klass, key, &code)
-          nth_role(klass, key, :last, &code)
+        def last_character(klass, key, &code)
+          nth_character(klass, key, :last, &code)
         end
 
-        def first_role(klass, key, &code)
-          nth_role(klass, key, :first, &code)
+        def first_character(klass, key, &code)
+          nth_character(klass, key, :first, &code)
         end
 
       end

data/lib/thingtank/shortcuts.rb

@@ -6,27 +6,27 @@ class ThingTank
         def >(klass_or_hash)
           case klass_or_hash
           when Array
-            last_role(klass_or_hash.first, klass_or_hash.last)
+            last_character(klass_or_hash.first, klass_or_hash.last)
           else
-            to_role(klass_or_hash)
+            to_character(klass_or_hash)
           end
         end
 
         def <(klass_or_hash)
           case klass_or_hash
           when Array
-            first_role(klass_or_hash.first, klass_or_hash.last)
+            first_character(klass_or_hash.first, klass_or_hash.last)
           else
-            to_role(klass_or_hash)
+            to_character(klass_or_hash)
           end
         end
 
         def << (arr)
           klass, key, code= arr.flatten
           if code
-            add_role(klass, key, &code)
+            add_character(klass, key, &code)
           else
-            add_role(klass, key)
+            add_character(klass, key)
           end
         end
 

data/lib/thingtank/thingtank.rb

@@ -7,12 +7,12 @@ class ThingTank < CouchRest::Model::Base
   mass_assign_any_attribute true # should always allow to set non defined arbitrary properties
   timestamps!
 
-  def role_view_by(klass, *keys)
+  def character_view_by(klass, *keys)
     opts = keys.pop if keys.last.is_a?(Hash)
     opts ||= {}
     opts[:guards] ||= []
     # there is no "inArray" like function in couchdb, see http://stackoverflow.com/questions/3740464/i-have-to-write-every-function-i-need-for-couchdb
-    opts[:guards] << "((doc['roles'] !== undefined) && (function (item,arr) { for(p=0;p<arr.length;p++) if (item == arr[p]) return true; return false;})('#{klass.to_s}',doc['roles']))"
+    opts[:guards] << "((doc['characters'] !== undefined) && (function (item,arr) { for(p=0;p<arr.length;p++) if (item == arr[p]) return true; return false;})('#{klass.to_s}',doc['characters']))"
     keys << opts
     view_by(*keys)
   end

data/lib/thingtank.rb

@@ -2,6 +2,11 @@ if RUBY_VERSION =~ /1.8/
   require 'backports'
 end 
 
+# TODO
+# - check if we could get useful inspiration from https://github.com/givmo/couch_record
+# - improve views
+# - validation for characters
+
 require_relative File.join('thingtank', 'thingtank.rb')
 require_relative File.join('couchrest', 'extensions', 'view.rb')
 require_relative File.join('thingtank', 'dependencies.rb')
@@ -10,19 +15,19 @@ require_relative File.join('thingtank', 'force_update.rb')
 require_relative File.join('thingtank', 'shared_methods.rb')
 require_relative File.join('thingtank', 'instance_methods.rb')
 require_relative File.join('thingtank', 'shortcuts.rb')
-require_relative File.join('thingtank', 'role_handling.rb')
-require_relative File.join('thingtank', 'role.rb')
+require_relative File.join('thingtank', 'character_handling.rb')
+require_relative File.join('thingtank', 'character.rb')
 require_relative File.join('thingtank', 'fakebase.rb')
 
 # TODO: 
-# role validator
+# character validator
 
 class ThingTank
 
   include ThingTank::ForceUpdate
   include ThingTank::SharedMethods
   include ThingTank::InstanceMethods
-  include ThingTank::RoleHandling
+  include ThingTank::CharacterHandling
   include ThingTank::Shortcuts
   include ThingTank::Callbacks