strokedb 0.0.2.1 → 0.0.2.2

data/lib/{data_structures → strokedb/data_structures}/skiplist.rb

@@ -160,7 +160,7 @@ module StrokeDB
 
  	  def each
   	  n = @head.forward[0]
-  	  until TailNode === n
+  	  until n.is_a?(TailNode)
   	    yield n
   	    n = n.forward[0]
       end

data/lib/{document → strokedb}/document.rb

@@ -1,3 +1,11 @@
+require 'document/dsl'
+require 'document/util'
+require 'document/meta'
+require 'document/callback'
+require 'document/delete'
+require 'document/slot'
+require 'document/versions'
+
 module StrokeDB
   # Slots which contain references to another documents are matched
   # with these regexps.
@@ -17,23 +25,23 @@ module StrokeDB
     def initialize(slotname)
       @slotname = slotname
     end
-    
+
     def message
       "Can't find slot #{@slotname}"
     end
-    
+
     def inspect
       "#<#{self.class.name}: #{message}>"
     end
   end
-  
+
   #
-  # Raised when Document#save! is called on an invalid document 
+  # Raised when Document#save! is called on an invalid document
   # (for which doc.valid? returns false)
   #
   class InvalidDocumentError < StandardError #:nodoc:
     attr_reader :document
-    
+
     def initialize(document)
       @document = document
     end
@@ -41,7 +49,7 @@ module StrokeDB
     def message
       "Validation failed: #{@document.errors.messages.join(", ")}"
     end
-    
+
     def inspect
       "#<#{self.class.name}: #{message}>"
     end
@@ -62,9 +70,17 @@ module StrokeDB
   #    authors: ["Yurii Rashkovskii","Oleg Andreev"]
   #
   class Document
-    include Validations::InstanceMethods
+    include StrokeDB::Validations::InstanceMethods
 
-    attr_reader :store, :callbacks  #:nodoc:
+    attr_reader :callbacks  #:nodoc:
+
+    def store
+      if (txns = Thread.current[:strokedb_transactions]) && !txns.nil? && !txns.empty?
+        txns.last
+      else
+        @store
+      end
+    end
 
     def marshal_dump #:nodoc:
       (@new ? '1' : '0') + (@saved ? '1' : '0') + to_raw.to_json
@@ -82,13 +98,34 @@ module StrokeDB
       def initialize(document)
         @document = document
         _meta = document[:meta]
-        concat [_meta].flatten.compact.map{|v| v.is_a?(DocumentReferenceValue) ? v.load : v}
+        concat _meta.to_a
       end
 
       def <<(meta)
         add_meta(meta, :call_initialization_callbacks => true)
       end
 
+      alias :_delete :delete
+      def delete(meta)
+        case meta
+        when Document
+          _delete meta
+          _module = StrokeDB::Document.collect_meta_modules(@document.store, meta).first
+        when Meta
+          _delete meta.document(@document.store)
+          _module = meta
+        else
+          raise ArgumentError, "Meta should be either document or meta module"
+        end
+
+        @document[:meta] = self
+
+        if _module
+          @document.unextend(_module)
+        end
+
+      end
+
       def add_meta(meta, opts = {})
         opts = opts.stringify_keys
         _module = nil
@@ -110,10 +147,8 @@ module StrokeDB
 
         if _module
           @document.extend(_module)
-          
-          _module.send!(:setup_callbacks, @document) rescue nil
-          
-          if opts['call_initialization_callbacks'] 
+
+          if opts['call_initialization_callbacks']
             @document.send!(:execute_callbacks_for, _module, :on_initialization)
             @document.send!(:execute_callbacks_for, _module, :on_new_document) if @document.new?
           end
@@ -168,6 +203,7 @@ module StrokeDB
     # If slot was not found, it will return <tt>nil</tt>
     #
     def [](slotname)
+      slotname = slotname.document.uuid if (slotname.is_a?(Meta) && slotname.is_a?(Module)) || (slotname == Meta)
       @slots[slotname.to_s].value rescue nil
     end
 
@@ -177,11 +213,12 @@ module StrokeDB
     #   document[:slot_1] = "some value"
     #
     def []=(slotname, value)
+      slotname = slotname.document.uuid  if (slotname.is_a?(Meta) && slotname.is_a?(Module)) || (slotname == Meta)
       slotname = slotname.to_s
 
       (@slots[slotname] ||= Slot.new(self, slotname)).value = value
       update_version!(slotname)
-      
+
       value
     end
 
@@ -206,7 +243,7 @@ module StrokeDB
     #
     def remove_slot!(slotname)
       slotname = slotname.to_s
-      
+
       @slots.delete slotname
       update_version! slotname
 
@@ -233,9 +270,9 @@ module StrokeDB
 
     def pretty_print #:nodoc:
       slots = to_raw.except('meta')
-      
-      s = is_a?(ImmutableDocument) ? "#<(imm)" : "#<"
-      
+
+      s = is_a?(ImmutableDocument) ? "#<^" : "#<"
+
       Util.catch_circular_reference(self) do
         if self[:meta] && name = meta[:name]
           s << "#{name} "
@@ -245,9 +282,13 @@ module StrokeDB
 
         slots.keys.sort.each do |k|
           if %w(version previous_version).member?(k) && v = self[k]
-            s << "#{k}: #{v.gsub(/^(0)+/,'')[0,4]}..., "
+            s << "#{k}: #{v[0,4]}..., "
           else
-            s << "#{k}: #{self[k].inspect}, "
+            if k.match(/^#{UUID_RE}$/)
+              s << "[#{store.find(k).name}]: #{self[k].inspect}, " rescue s << "#{k}: #{self[k].inspect}, "
+            else
+              s << "#{k}: #{self[k].inspect}, "
+            end
           end
         end
 
@@ -255,7 +296,7 @@ module StrokeDB
         s.chomp!(' ')
         s << ">"
       end
-      
+
       s
     rescue Util::CircularReferenceCondition
       "#(#{(self[:meta] ? "#{meta}" : "Doc")} #{('@#'+uuid)[0,5]}...)"
@@ -287,8 +328,8 @@ module StrokeDB
       @slots.each_pair do |k,v|
         raw_slots[k.to_s] = v.to_raw
       end
-      
-      raw_slots
+
+      raw_slots.to_raw
     end
 
     def to_optimized_raw #:nodoc:
@@ -298,14 +339,12 @@ module StrokeDB
     #
     # Creates a document from a serialized representation
     #
-    def self.from_raw(store, raw_slots, opts = {}) #:nodoc:
-      doc = new(store, raw_slots, true)
+    def self.from_raw(store, raw_slots, opts = {}, &block) #:nodoc:
+      doc = new(store, raw_slots, true, &block)
 
       collect_meta_modules(store, raw_slots['meta']).each do |meta_module|
         unless doc.is_a? meta_module
           doc.extend(meta_module)
-
-          meta_module.send!(:setup_callbacks, doc) rescue nil
         end
       end
 
@@ -330,10 +369,14 @@ module StrokeDB
     # If first argument is Store, that particular store will be used; otherwise default store will be assumed.
     def self.find(*args)
       store = nil
-      if args.empty? || args.first.is_a?(String) || args.first.is_a?(Hash)
-        store = StrokeDB.default_store
+      if (txns = Thread.current[:strokedb_transactions]) && !txns.nil? && !txns.empty?
+        store = txns.last
       else
-        store = args.shift
+        if args.empty? || args.first.is_a?(String) || args.first.is_a?(Hash) || args.first.nil?
+          store = StrokeDB.default_store
+        else
+          store = args.shift
+        end
       end
       raise NoDefaultStoreError.new unless store
       query = args.first
@@ -343,7 +386,7 @@ module StrokeDB
       when Hash
         store.search(query)
       else
-        raise TypeError
+        raise ArgumentError, "use UUID or query to find document(s)"
       end
     end
 
@@ -386,30 +429,42 @@ module StrokeDB
       store.save!(self)
       @new = false
       @saved = true
-     
+
       execute_callbacks :after_save
-      
+
       self
     end
 
-    #
-    # Updates slots with specified <tt>hash</tt> and returns itself.
-    #
+    # Updates slots with a specified <tt>hash</tt> and returns itself.
     def update_slots(hash)
       hash.each do |k, v|
-        self[k] = v
+        send("#{k}=", v) unless self[k] == v
       end
-      
       self
     end
 
-    #
     # Same as update_slots, but also saves the document.
-    #
     def update_slots!(hash)
       update_slots(hash).save!
     end
 
+
+    # Updates nil/false slots with a specified <tt>hash</tt> and returns itself.
+    # Already set slots are not modified (<tt>||=</tt> is used).
+    # Acts like <tt>hash1.reverse_merge(hash2)</tt> (<tt>hash2.merge(hash1)</tt>).
+    #
+    def reverse_update_slots(hash)
+      hash.each do |k, v|
+        self[k] ||= v
+      end
+      self
+    end
+
+    # Same as reverse_update_slots, but also saves the document.
+    def reverse_update_slots!(hash)
+      reverse_update_slots(hash).save!
+    end
+
     #
     # Returns document's metadocument (if any). In case if document has more than one metadocument,
     # it will combine all metadocuments into one 'virtual' metadocument
@@ -419,14 +474,14 @@ module StrokeDB
         # simple case
         return m || Document.new(@store)
       end
-      
+
       return m.first if m.size == 1
 
       mm = m.clone
       collected_meta = mm.shift.clone
 
       names = collected_meta[:name].split(',') rescue []
-      
+
       mm.each do |next_meta|
         next_meta = next_meta.clone
         collected_meta += next_meta
@@ -455,7 +510,7 @@ module StrokeDB
     # Please not that it accept both meta modules and their documents, there is no difference
     #
     def metas
-      Metas.new(self)
+      @metas ||= Metas.new(self)
     end
 
     #
@@ -472,6 +527,10 @@ module StrokeDB
       @uuid ||= self[:uuid]
     end
 
+    def raw_uuid #:nodoc:
+      @raw_uuid ||= uuid.to_raw_uuid
+    end
+
     #
     # Returns document's previous version (which is stored in <tt>previous_version</tt> slot)
     #
@@ -498,7 +557,7 @@ module StrokeDB
       case doc
       when Document, DocumentReferenceValue
         doc = doc.load if doc.kind_of? DocumentReferenceValue
-        
+
         # we make a quick UUID check here to skip two heavy to_raw calls
         doc.uuid == uuid && doc.to_raw == to_raw
       else
@@ -526,16 +585,16 @@ module StrokeDB
 
     def method_missing(sym, *args) #:nodoc:
       sym = sym.to_s
-      
+
       return send(:[]=, sym.chomp('='), *args) if sym.ends_with? '='
       return self[sym]                         if slotnames.include? sym
       return !!send(sym.chomp('?'), *args)     if sym.ends_with? '?'
-            
+
       raise SlotNotFoundError.new(sym) if (callbacks['when_slot_not_found'] || []).empty?
 
       r = execute_callbacks(:when_slot_not_found, sym)
       raise r if r.is_a? SlotNotFoundError # TODO: spec this behavior
- 
+
       r
     end
 
@@ -568,21 +627,21 @@ module StrokeDB
       end
     end
 
-    # initialize the document. initialize_raw is true when 
+    # initialize the document. initialize_raw is true when
     # document is initialized from a raw serialized form
     def do_initialize(store, slots={}, initialize_raw = false) #:nodoc:
       @callbacks = {}
       @store = store
 
       if initialize_raw
-        initialize_raw_slots slots 
+        initialize_raw_slots slots
         @saved = true
       else
         @new = true
         initialize_slots slots
 
         self[:uuid] = Util.random_uuid unless self[:uuid]
-        generate_new_version!          unless self[:version]
+        self[:version] ||= NIL_UUID
       end
     end
 
@@ -591,24 +650,23 @@ module StrokeDB
       @slots = {}
       slots = slots.stringify_keys
 
-      # there is a reason for meta slot is initialized separately — 
+      # there is a reason for meta slot is initialized separately —
       # we need to setup coercions before initializing actual slots
       if meta = slots['meta']
         meta = [meta] unless meta.is_a?(Array)
         meta.each {|m| metas.add_meta(m) }
       end
-     
-      slots.except('meta').each {|name,value| self[name] = value }
+
+      slots.except('meta').each {|name,value| send("#{name}=", value) }
 
       # now, when we have all slots initialized, we can run initialization callbacks
       execute_callbacks :on_initialization
       execute_callbacks :on_new_document
     end
-    
+
     # initialize slots from a raw representation
     def initialize_raw_slots(slots) #:nodoc:
       @slots = {}
-
       slots.each do |name,value|
         s = Slot.new(self, name)
         s.raw_value = value
@@ -617,26 +675,73 @@ module StrokeDB
       end
     end
 
-    # returns an array of meta modules (as constants) for a given something
-    # (a document reference, a document itself, or an array of the former)
-    def self.collect_meta_modules(store, meta) #:nodoc:
-      meta_names = []
 
-      case meta
-      when VERSIONREF
-        if m = store.find($1, $2)
-          meta_names << m[:name]
+    class MetaModulesCollector
+      def initialize(store, subject)
+        @store   = store
+        @subject = subject
+      end
+
+      def resolve_module_name(uuid)
+        if metadoc = @store.find(uuid, self.lookup_version_for_meta(@subject))
+          mod = Module.find_by_nsurl(metadoc[:nsurl])
+
+          if self.has_defined_constant_for_meta?(mod, metadoc)
+            at_top_level?(mod) ? "::#{metadoc[:name]}" : "#{mod.name}::#{metadoc[:name]}"
+          else
+            Meta.resolve_uuid_name(metadoc[:nsurl], metadoc[:name])
+          end
         end
-      when DOCREF
-        if m = store.find($1)
-          meta_names << m[:name]
+      end
+
+      def at_top_level?(mod)
+        mod == Module || mod.nil?
+      end
+
+      def collect!
+        meta_names = []
+
+        case @subject
+        when VERSIONREF, DOCREF
+          meta_names << resolve_module_name($1)
+        when Array
+          meta_names = @subject.map { |subj| subj = MetaModulesCollector.new(@store, subj).collect! }.flatten
+        when Document
+          meta_names << @subject[:name]
         end
-      when Array
-        meta_names = meta.map { |m| collect_meta_modules(store, m) }.flatten
-      when Document
-        meta_names << meta[:name]
+
+        meta_names
+      end
+
+      def lookup_version_for_meta(meta)
+        version = case meta
+                  when VERSIONREF then $2
+                  else nil
+                  end
+        version
+      end
+
+      def has_defined_constant_for_meta?(mod, metadoc)
+        top_level_meta?(mod, metadoc) || has_meta_definition?(mod, metadoc)
       end
 
+      def top_level_meta?(mod, doc)
+        (mod == Module && Object.constants.include?(doc[:name]))
+      end
+
+      def has_meta_definition?(mod, metadoc)
+        (mod && mod.constants.include?(metadoc[:name]))
+      end
+    end
+
+
+
+    # returns an array of meta modules (as constants) for a given something
+    # (a document reference, a document itself, or an array of the former)
+    def self.collect_meta_modules(store, meta) #:nodoc:
+      @collector = MetaModulesCollector.new(store, meta)
+      meta_names = @collector.collect!
+
       meta_names.map { |m| m.is_a?(String) ? (m.constantize rescue nil) : m }.compact
     end
 
@@ -649,7 +754,7 @@ module StrokeDB
         self[:previous_version] = version unless version.nil?
 
         generate_new_version!
-        
+
         @saved = nil
       end
     end
@@ -680,5 +785,9 @@ module StrokeDB
     def save!
       self
     end
+
+    def make_mutable!
+      unextend(ImmutableDocument)
+    end
   end
 end