thingtank 0.0.1

data/examples/second_marriage.rb

@@ -0,0 +1,78 @@
+require_relative 'marriage_improvement.rb'
+
+class Dead
+
+  # all callbacks of roles are called and defined like corresponding callbacks of the doc
+  before_save do
+    if _doc.is?(Spouse) && _doc['married_state'] == 'married'
+      Spouse.get(_doc.last_role(Married, 'married').spouse).widowed(self["date_of_death"])
+    end
+    true
+  end
+
+end
+
+class Person
+  def dies(date)
+    _doc.is(Dead) do |d|
+      d.date_of_death = date
+    end
+  end
+end
+
+class Married
+  def widow(date)
+    self["state"] = 'widowed'
+    self['end'] = date
+    _doc.save
+  end
+end
+
+class Spouse
+  def widowed(date)
+    self["married_state"] = 'widowed'
+    married { |m| m.widow(date) }
+  end
+end
+
+
+def test_second_marriage()
+  julius = test_improved_marriage()
+  julius.as(Person).marry "68-65 BC", :gender => "f", :name => 'Pompeia'
+
+  assert_equal 2, julius["married"].size
+  assert_equal 'Cornelia', Person.get(julius["married"].first["spouse"]).name
+  assert_equal 'Pompeia', Person.get(julius["married"].last["spouse"]).name
+  assert_equal 'Pompeia', julius.has(Spouse).name
+  assert_equal 'married', julius["married"].first["state"]
+  assert_equal 'married', julius["married"].last["state"]
+
+  return julius
+end
+
+def test_second_marriage_after_conny_died()
+  julius = test_bear_julius()
+  conny = create(:gender => "f", :name => 'Cornelia')
+  conny.is(Person)
+  julius.as(Person).marry "84 BC", conny
+  julius.save
+  julius.reload
+
+  conny = load(julius["married"]["spouse"])
+  conny.save
+  conny.reload
+  conny.as(Person).dies "68-65 BC"
+  conny.save
+
+  julius.reload
+
+  julius.as(Person).marry "68-65 BC", :gender => "f", :name => 'Pompeia'
+
+  assert_equal 2, julius["married"].size
+  assert_equal 'Cornelia', Person.get(julius["married"].first["spouse"]).name
+  assert_equal 'widowed', julius["married"].first["state"]
+  assert_equal 'Pompeia', Person.get(julius["married"].last["spouse"]).name
+  assert_equal 'married', julius["married"].last["state"]
+  assert_equal 'Pompeia', julius.has(Spouse).name
+end
+

data/lib/couchrest/extensions/view.rb

@@ -0,0 +1,17 @@
+# https://github.com/couchrest/couchrest_model/blob/master/lib/couchrest/model/designs/view.rb overwritten
+
+class CouchRest::Model::Designs::DesignMapper
+
+  # generate a view to show only ThingTanks of a certain role, define them all in a ThingTank subclass (not in a role)
+  def role_view(klass, name, opts={})
+    name = "#{klass.to_s.downcase}_#{name}"
+    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']))"
+    view(name, opts)
+  end
+
+end
+
+

data/lib/thingtank/callbacks.rb

@@ -0,0 +1,32 @@
+class ThingTank 
+  module Callbacks
+    def self.included(klass)
+      klass.class_eval do
+
+        before_validation do
+          # update_attributes seems to be intentionally broken for mass_assign_any_attribute, see
+          # http://groups.google.com/group/couchrest/browse_thread/thread/3b6aeb6469a0ea35?pli=1
+          # try to fix it be changing a property (ugly hack), also see https://github.com/couchrest/couchrest_model/issues/114
+          #disable_dirty #true
+          couchrest_attribute_will_change!('update_me') # or update_me_will_change!
+        end
+
+        before_save do
+          @dependencies.save_all()
+        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["roles"] || []).each do |klass|
+            document = self.as(klass.constantize)
+            (ok = false) if false == document.run_callbacks(:destroy) do
+              true
+            end
+          end
+          ok
+        end
+      end
+    end
+  end
+end

data/lib/thingtank/dependencies.rb

@@ -0,0 +1,94 @@
+class ThingTank 
+
+  # tracks the dependencies of a ThingTank, such as saving of roles, children ThingTanks, registration of roles
+  class Dependencies
+    def initialize(doc)
+      @doc = doc
+      @registration = []
+      @save = []
+      @children = {}
+    end
+
+    attr_reader :parent
+
+    def register_roles
+      @registration.each { |role| @doc.register_role(role) }
+    end
+
+    def save_all()
+      refresh true
+      @save.each { |role_instance| role_instance.save }
+    end
+
+    def add_role(role)
+      @registration << role
+    end
+
+    def remove_role(role)
+      @registration.delete(role) if has_role?(role)
+    end
+
+    def has_role?(klass)
+      @registration.include? klass
+    end
+
+    def save_role(role_instance)
+      @save << role_instance unless @save.include? role_instance
+    end
+
+    def already_saved(role_instance)
+      @save.delete role_instance
+    end
+
+    def refresh(save=false, with_parent=true)
+      register_roles
+      @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
+          end
+        else
+          child.dependencies.refresh(save, false)
+          child.save if save
+          child.to_role_hash
+        end
+      end
+      refresh_parent() if with_parent
+    end
+
+    def refresh_parent() 
+      @parent.dependencies.refresh if @parent
+    end
+   
+    def add_child(key,child)
+      raise "something wrong here #{key} #{child.inspect}" unless child.is_a?(ThingTank) || child.is_a?(Array)
+      if child.is_a? Array
+        child.each do |c|
+          c.dependencies.set_parent(@doc)
+        end
+      else
+        child.dependencies.set_parent(@doc)
+      end      
+      @children[key] = child
+    end
+
+    def find_root_doc()
+      return @doc unless @parent
+      _d = @doc
+      doc = _d
+      while doc.dependencies.parent do
+        doc = doc.dependencies.parent
+      end
+      return doc
+    end
+
+    protected
+
+    def set_parent(parent)
+      @parent = parent
+    end
+  end
+end

data/lib/thingtank/fakebase.rb

@@ -0,0 +1,66 @@
+# a replacement database for roles
+class ThingTank::FakeBase
+
+  def initialize(doc, role)
+    @db = doc.database
+    @doc = doc
+    @role = role
+    @doc.dependencies.add_role(role)
+  end
+
+  def method_missing(meth, *args)
+    raise "don't call #{self.class}: #{meth.inspect}(#{args.inspect})"
+  end
+
+  def is_a?(klass)
+    return true if klass == CouchRest::Database
+    super
+  end
+
+  def to_role(klass)
+    self.class.new(@doc, klass).get()
+  end
+
+  def result(ok=true)
+    {"ok" => ok}
+  end
+
+  def save_doc(role_doc)
+    if role_doc.is_a? ThingTank # I dunno why this happens
+      @doc.dependencies.refresh_parent()
+    else
+      @doc.save_role_attributes(role_doc) if role_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
+      # for each doc we will need to identify the remaining attributes
+      doc, save = (role_doc["_id"].nil? || role_doc["_id"] == @doc.id) ?
+        [@doc, false] : 
+        [@db.get(role_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
+    end
+    @doc.save if @doc.changed?
+    result()
+  end
+
+  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)
+  end
+
+  def _role_doc
+    @doc
+  end
+
+  def _doc
+    @doc._root
+  end
+end
+

data/lib/thingtank/force_update.rb

@@ -0,0 +1,24 @@
+class ThingTank
+
+  # update_attributes seems to be broken for mass_assign_any_attribute, see
+  # http://groups.google.com/group/couchrest/browse_thread/thread/3b6aeb6469a0ea35?pli=1
+  # try to fix it be changing a property (ugly hack), also see https://github.com/couchrest/couchrest_model/issues/114
+  module ForceUpdate
+
+    def self.included(base)
+
+      base.class_eval do
+
+        property :update_me
+
+        before_validation do
+          couchrest_attribute_will_change!('update_me') # or update_me_will_change! will also do
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/thingtank/instance_methods.rb

@@ -0,0 +1,45 @@
+class ThingTank
+
+  module InstanceMethods
+
+    def self.included(base)
+
+      base.class_eval do
+
+        def initialize(*args)
+          super
+          @dependencies = ThingTank::Dependencies.new(self)
+        end
+
+        def dependencies
+          @dependencies
+        end
+
+        def first(key)
+          [self[key.to_s]].flatten.last
+        end
+      
+        def last(key)
+          [self[key.to_s]].flatten.first
+        end
+
+        # export a property to its own document and replaces the original reference with the doc["_id"]
+        def export(property)
+          raise ArgumentError, "doc.database required for extracting" unless database
+          new_doc = self[property.to_s]
+          raise ArgumentError, "#{new_doc.inspect} is no CouchRest::Document or Hash" unless new_doc.is_a?(CouchRest::Document) or new_doc.is_a?(Hash)
+          result = database.save_doc new_doc
+          if result['ok']
+            self["#{property}_id"] = result["id"]
+            self[property.to_s] = nil
+          end
+          result['ok']
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/thingtank/role.rb

@@ -0,0 +1,110 @@
+
+class ThingTank
+
+  class Role < CouchRest::Model::Base
+
+    include ThingTank::ForceUpdate
+    include ThingTank::SharedMethods
+
+    class << self
+
+      def property(name, *args)
+        @role_properties ||= []
+        @role_properties << name.to_s
+        super
+      end
+
+      def role_properties
+        @role_properties
+      end
+
+      def -(key)
+        [self,key]
+      end
+
+      def get(id, db = database)
+        doc = ThingTank.get(id)
+        return nil if doc.nil?
+        return doc.to_role(self)
+      end
+
+      def get!(id, db = database)
+        doc = ThingTank.get!(id)
+        doc.to_role(self)
+      end
+
+      def wants(*modules)
+        @wishes ||= []
+        @wishes = @wishes.concat modules
+      end
+
+      def wishes
+        @wishes
+      end
+
+      def design
+        raise "design is not supported in ThingTank::Role, please use the 'role_view' method in a ThingTank subclass design definition"
+      end
+
+      def view_by(*args)
+        raise "view_by is not supported in ThingTank::Role, please use the 'role_view_by' method in a ThingTank subclass"
+      end
+
+    end
+
+    def -(key)
+      [self,key]
+    end
+
+    def _doc
+      if database.is_a?(FakeBase) 
+        database._doc
+      else
+        nil
+      end
+    end
+
+    # the virtual _doc that contains me, you should not need it normally
+    def _role_doc
+      if database.is_a?(FakeBase) 
+        database._role_doc
+      else
+        nil
+      end
+    end
+
+    def flush_to_doc
+      if changed?
+        changed_to_role_hash().each do |k,v|
+          _role_doc[k] = v
+        end
+        _role_doc.save
+        @changed_attributes.clear        
+      end
+    end
+
+    def reload
+      attrs = _role_doc.as(self.class).to_role_hash
+      prepare_all_attributes(attrs, :directly_set_attributes => true)
+      @changed_attributes.clear
+      self
+    end
+
+    def to_role(klass, key, &code)
+      _role_doc.to_role(klass, key, &code)
+    end
+
+    def first(key)
+      _role_doc.first(key)
+    end
+
+    def last(key)
+      _role_doc.last(key)
+    end
+
+    def add_role(klass, key=nil, &code)
+      _role_doc.add_role(klass, key, &code)
+    end
+  end
+
+end

data/lib/thingtank/role_handling.rb

@@ -0,0 +1,198 @@
+class ThingTank 
+  module RoleHandling
+    def self.included(klass)
+      klass.class_eval do
+
+        def properties_of_role(klass)
+          hsh = {}
+          (klass.role_properties || []).each do |k| 
+            hsh.update(k.to_s => self[k.to_s])  unless self[k.to_s].nil?
+          end
+          hsh
+        end
+
+        def get_role(klass, db)
+          hsh = properties_of_role(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_role(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_role(key, klass)
+          case self[key]
+          when Hash
+            with(key).to_role(klass)
+          when Array
+            with_all(key).collect { |doc| doc.to_role(klass) }
+          end
+        end
+
+        # register a role
+        def register_role(klass)
+          self['roles'] ||= []
+          self['roles'] << klass.to_s unless self['roles'].include? klass.to_s
+        end
+
+        def unregister_role(role)
+          if has?(role)
+            self["roles"] ||= []
+            self["roles"].delete role.to_s
+          end
+        end
+
+        def add_role(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_role(klass, key, &code)
+            else
+              self[key] = {}
+              to_role(klass, key, &code)
+            end
+          else
+            to_role(klass, &code)
+          end
+        end
+
+        def _root
+          @dependencies.find_root_doc
+        end
+
+        def delete_role(role_doc)
+          klass = role_doc.class
+          deleteable_attributes(klass).each { |k| delete(k) ; role_doc[k] = nil }
+          @dependencies.already_saved(role_doc) # prevent an endless loop      
+          unregister_role(klass)
+          @dependencies.remove_role(klass)
+          @dependencies.refresh_parent()
+        end
+
+        def deleteable_attributes(klass)
+          role_attrs = attributes_by_roles
+          role = klass.to_s
+          deleteable_attrs = klass.role_properties.select do |prop|
+            role_attrs[prop].empty? || (role_attrs[prop].size == 1 && role_attrs[prop].first == role)
+          end
+          %w| _id _rev type update_me roles|.each{ |k|  deleteable_attrs.delete k }
+          return deleteable_attrs
+        end
+
+        def attributes_by_roles()
+          attributes = {}
+          self["roles"].each do |role|
+            role.constantize.role_properties.each do |prop|
+              attributes[prop] ||= []
+              attributes[prop] << role
+            end
+          end
+          return attributes
+        end
+    
+        def to_role(klass, key=nil, add_role=true, &code)
+          @dependencies.add_role(klass) if add_role && key.nil?
+          role = key ? property_to_role(key, klass) : FakeBase.new(self, klass).get()
+          (code.call(role) ; role.flush_to_doc) if code
+          role
+        end
+
+        alias :as :to_role
+        alias :has :to_role
+        alias :act_as :to_role
+        alias :be :to_role
+        alias :have :to_role
+        alias :are :to_role
+        alias :is :to_role
+
+        def save_role_attributes(role_doc)
+          @dependencies.already_saved(role_doc) # prevent an endless loop          
+          attributes = role_doc.to_role_hash(true)
+          unsavebales = attributes.keys - (role_doc.class.role_properties || [])
+          raise "role #{role_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 role
+        def had?(klass)
+          return false unless self["roles"] and self["roles"].include? klass.name
+          return true
+        end
+
+        # has the document the role, is it supposed to have it and does it have the necessary properties
+        def has?(klass)
+          return true if @dependencies.has_role?(klass)
+          return false unless self["roles"] and self["roles"].include? klass.name
+          could_be? klass
+        end
+        alias :is? :has?
+
+        # could the document have the role
+        def could_have?(klass)
+          to_role(klass, nil, false).valid?
+        end
+        alias :could_be? :could_have?
+
+        # roles that are not valid
+        def invalid_roles
+          (self["roles"] || []).select { |role| !self.as(role.constantize).valid? }
+        end
+
+      end
+    end
+  end
+end