strokedb 0.0.2.1 → 0.0.2.2

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

@@ -3,7 +3,7 @@ module StrokeDB
   class DocumentDeletionError < StandardError
   end
   
-  DeletedDocument = Meta.new(:uuid => DELETED_DOCUMENT_UUID) do
+  DeletedDocument = Meta.new do
     on_load do |doc|
       doc.make_immutable!
     end
@@ -11,7 +11,7 @@ module StrokeDB
     def undelete!
       deleted_version = versions.previous
       store.save_as_head!(deleted_version)
-      self.class.find(uuid)
+      store.find(uuid)
     end
   end
   

data/lib/strokedb/document/dsl.rb

@@ -0,0 +1,4 @@
+require 'document/dsl/validations'
+require 'document/dsl/virtualize'
+require 'document/dsl/associations'
+require 'document/dsl/coercions'

data/lib/strokedb/document/dsl/meta_dsl.rb

@@ -0,0 +1,7 @@
+module StrokeDB
+  module MetaDSL
+    def on_initialize(&block)
+      store_dsl_options("on_initialize", block)
+    end
+  end
+end

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

@@ -15,6 +15,8 @@ module StrokeDB
       :too_short         => '#{slotname} is too short (minimum is %d characters)',
       :too_long          => '#{slotname} is too long (maximum is %d characters)',
       :invalid           => '#{slotname} is invalid',
+      :must_be_integer   => '#{slotname} must be integer',
+      :not_a_number      => '#{slotname} is not a number',
     }.freeze unless defined? ERROR_MESSAGES
 
     # Validates that the specified slot exists in the document. Happens by default on save. Example:
@@ -541,13 +543,13 @@ module StrokeDB
     end
 
     NUMERICALITY_ERRORS = { 
-      'greater_than' => '#{slotname} must be greater than %d', 
+      'greater_than'             => '#{slotname} must be greater than %d', 
       'greater_than_or_equal_to' => '#{slotname} must be greater than or equal to %d',
-      'equal_to' => '#{slotname} must be equal to %d', 
-      'less_than' => '#{slotname} must be less than %d',
-      'less_than_or_equal_to' => '#{slotname} must be less than or equal to %d',
-      'odd' => '#{slotname} must be odd',
-      'even' => '#{slotname} must be even'
+      'equal_to'                 => '#{slotname} must be equal to %d', 
+      'less_than'                => '#{slotname} must be less than %d',
+      'less_than_or_equal_to'    => '#{slotname} must be less than or equal to %d',
+      'odd'                      => '#{slotname} must be odd',
+      'even'                     => '#{slotname} must be even',
     }.freeze unless defined? NUMERICALITY_ERRORS
 
     def initialize_validations
@@ -572,23 +574,23 @@ module StrokeDB
       end
       
       install_validations_for(:validates_uniqueness_of) do |doc, validation, slotname|
-        meta = Kernel.const_get(doc.meta.name)
-
-        !(found = meta.find(slotname.to_sym => doc[slotname])) || 
-        (found.size == 0) || 
-        (found.first.uuid == doc.uuid)
+        not doc.metas.detect do |meta|
+          found = Kernel.const_get(meta.name).find(slotname.to_sym => doc[slotname]) unless meta.name == 'StrokeDB::DeletedDocument'
+          
+          found && found.detect { |item| item.uuid != doc.uuid }
+        end
       end
-      
+
       # using lambda here enables us to use return
       numericality = lambda do |doc, validation, slotname|
         value = doc[slotname]
 
         if validation[:only_integer]
-          return (validation[:message] || "#{slotname} must be integer") unless value.to_s =~ /\A[+-]?\d+\Z/
+          return (validation[:message] || :must_be_integer) unless value.to_s =~ /\A[+-]?\d+\Z/
           value = value.to_i
         else
           value = Kernel.Float(value) rescue false
-          return (validation[:message] || "#{slotname} is not a number") unless value
+          return (validation[:message] || :not_a_number) unless value
         end
 
         errors = []
@@ -680,15 +682,18 @@ module StrokeDB
           next if validation[:allow_nil] && value.nil?
           next if validation[:allow_blank] && value.blank?
 
+          msg = nil
+
           case validation_result = block.call(doc, validation, slotname_to_validate)
-            when true then next
-            when false
-              add_error(doc, validation, slotname_to_validate, validation[:message])
-            when String
-              add_error(doc, validation, slotname_to_validate, validation_result)
-            when Array
+            when true   then next
+            when false  then msg = validation[:message] 
+            when Symbol then msg = ERROR_MESSAGES[validation_result]
+            when String then msg = validation_result
+            when Enumerable
               validation_result.each { |message| add_error(doc, validation, slotname_to_validate, message) }
           end
+          
+          add_error(doc, validation, slotname_to_validate, msg) if msg
         end
       end
     end
@@ -701,4 +706,4 @@ module StrokeDB
       doc.errors.add(slotname, os.instance_eval("\"#{message}\""))
     end
   end  
-end
+end

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

@@ -1,4 +1,7 @@
 module StrokeDB
+  
+  META_CACHE = {}
+  
   # Meta is basically a type. Imagine the following document:
   #
   # some_apple:
@@ -20,8 +23,21 @@ module StrokeDB
   #
   # Document class will be extended by modules Fruit and Product.
   module Meta
-
+    
     class << self
+
+      def resolve_uuid_name(nsurl,name)
+        "meta:#{nsurl}##{name}"
+      end
+
+      def make_uuid_from_fullname(full_name)
+        ::StrokeDB::Util.sha1_uuid(full_name)
+      end
+      
+      def make_uuid(nsurl, name)
+        ::StrokeDB::Util.sha1_uuid("meta:#{nsurl}##{name}")
+      end
+      
       def new(*args, &block)
         mod = Module.new
         args = args.unshift(nil) if args.empty? || args.first.is_a?(Hash)
@@ -44,32 +60,43 @@ module StrokeDB
           initialize_coercions
           initialize_virtualizations
         end
-        if meta_name = extract_meta_name(*args)
-          Object.const_set(meta_name, mod)
+        if name = args.last.stringify_keys['name']
+          META_CACHE[make_uuid(args.last.stringify_keys['nsurl'],args.last.stringify_keys['name'])] = mod 
+          mod.instance_eval %{
+            def name 
+              '#{name}'
+            end
+          }
         end
         mod
       end
 
       def document(store=nil)
         raise NoDefaultStoreError.new unless store ||= StrokeDB.default_store
-        unless meta_doc = store.find(NIL_UUID)
-          meta_doc = Document.create!(store, :name => Meta.name, :uuid => NIL_UUID)
+        unless meta_doc = store.find(uuid)
+          meta_doc = Document.create!(store, :name => Meta.name.demodulize, :uuid => uuid, :nsurl => StrokeDB.nsurl)
         end
         meta_doc
       end
+      
 
       private
 
-      def extract_meta_name(*args)
-        if args.first.is_a?(Hash)
-          args.first[:name]
-        else
-          args[1][:name] unless args.empty?
-        end
+      def uuid
+        @uuid ||= ::StrokeDB::Util.sha1_uuid("meta:#{StrokeDB.nsurl}##{Meta.name.demodulize}")
       end
 
     end
 
+    def implements(another_meta)
+      values = @args.find{|a| a.is_a?(Hash) }
+      values.merge!(another_meta.document.to_raw.delete_if {|k,v| ['name','uuid','version','previous_version','meta'].member?(k) })
+      values[:implements_metas] ||= []
+      values[:implements_metas] << another_meta.document
+      include(another_meta)
+      self
+    end
+    
     def +(meta)
       if is_a?(Module) && meta.is_a?(Module)
         new_meta = Module.new
@@ -81,9 +108,10 @@ module StrokeDB
         new_meta.module_eval do
           extend Meta
         end
-        new_meta_name = new_meta.instance_variable_get(:@metas).map{|m| m.name}.join('__')
-        Object.send(:remove_const, new_meta_name) rescue nil
-        Object.const_set(new_meta_name, new_meta)
+        new_meta_name = new_meta.instance_variable_get(:@metas).map{|m| m.name.demodulize}.join('__')
+        mod = self.name.modulize.constantize rescue Object
+        mod.send(:remove_const, new_meta_name) rescue nil
+        mod.const_set(new_meta_name, new_meta)
         new_meta
       elsif is_a?(Document) && meta.is_a?(Document)
         (Document.new(store, self.to_raw.except('uuid','version','previous_version'), true) +
@@ -92,9 +120,30 @@ module StrokeDB
         raise "Can't + #{self.class} and #{meta.class}"
       end
     end
+    
+    def named(*args,&block)
+      args.unshift StrokeDB.default_store unless args.first.is_a?(StrokeDB::Store)
+      args << {} unless args.last.is_a?(Hash)
+      raise ArgumentError, "you should specify name" unless args[1].is_a?(String)
+      name = args[1]
+      uuid = ::StrokeDB::Util.sha1_uuid("#{document.uuid}:#{name}")
+      unless doc = find(args[0],uuid,&block)
+        doc = create!(args[0],args.last.reverse_merge(:uuid => uuid),&block)
+      else
+        doc.update_slots!(args.last)
+      end
+      doc
+    end
 
-    CALLBACKS = %w(on_initialization on_load before_save after_save when_slot_not_found on_new_document on_validation 
-      after_validation on_set_slot)
+    CALLBACKS = %w(on_initialization 
+                   on_load 
+                   before_save 
+                   after_save 
+                   when_slot_not_found 
+                   on_new_document 
+                   on_validation 
+                   after_validation 
+                   on_set_slot)
 
     CALLBACKS.each do |callback_name|
       module_eval %{
@@ -143,7 +192,7 @@ module StrokeDB
     #   all_my_joes  = User.find(my_store, :name => "joe")
     #   oh_my        = User.find(my_store, "1e3d02cc-0769-4bd8-9113-e033b246b013")
     #
-    def find(*args)
+    def find(*args, &block)
       if args.empty? || !args.first.respond_to?(:search)
         raise NoDefaultStoreError unless StrokeDB.default_store
         
@@ -160,8 +209,7 @@ module StrokeDB
       case args[1]
       when String
         raise ArgumentError, "Invalid UUID" unless args[1].match(UUID_RE)
-
-        store.search(opt.merge({ :uuid => args[1] })).first
+        store.find(args[1], &block)
       when Hash
         store.search opt.merge(args[1])
       when nil
@@ -172,14 +220,19 @@ module StrokeDB
     end
 
     #
-    # Similar to +find+, but a creates document with appropriate slot values if
-    # not found.
+    # Convenience alias for Meta#find.
+    #
+    alias :all :find
+
+    #
+    # Similar to +find+, but creates a document with an appropriate 
+    # slot values if document was not found.
     #
     # If found, returned is only the first result.
     #
-    def find_or_create(*args)
+    def find_or_create(*args, &block)
       result = find(*args)
-      result.empty? ? create!(*args) : result.first
+      result.empty? ? create!(*args, &block) : result.first
     end
 
     def inspect
@@ -200,15 +253,28 @@ module StrokeDB
       metadocs.size > 1 ? metadocs.inject { |a, b| a + b }.make_immutable! : metadocs.first
     end
     
+  
+  
+    def extended(obj)
+      setup_callbacks(obj) if obj.is_a?(Document)
+    end
+    
+    
     private
-
+    
     def make_document(store=nil)
       raise NoDefaultStoreError.new unless store ||= StrokeDB.default_store
       @meta_initialization_procs.each {|proc| proc.call }.clear
 
-      values = @args.clone.select{|a| Hash === a}.first
+      values = @args.clone.select{|a| a.is_a?(Hash) }.first
       values[:meta] = Meta.document(store)
-      values[:name] ||= name
+      values[:name] ||= name.demodulize
+
+      raise ArgumentError, "meta can't be nameless" if values[:name].blank?
+
+      values[:nsurl] ||= name.modulize.empty? ? Module.nsurl : name.modulize.constantize.nsurl 
+      values[:uuid] ||= Meta.make_uuid(values[:nsurl],values[:name])
+      
       
       if meta_doc = find_meta_doc(values, store)
         values[:version] = meta_doc.version
@@ -218,7 +284,6 @@ module StrokeDB
       else
         args = [store, values]
         meta_doc = Document.new(*args)
-        meta_doc.extend(Meta)
         meta_doc.save!
       end
       meta_doc
@@ -227,8 +292,6 @@ module StrokeDB
     def find_meta_doc(values, store)
       if uuid = values[:uuid]
         store.find(uuid)
-      else
-        store.search({ :name => values[:name], :meta => Meta.document(store) }).first
       end
     end
 

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

@@ -1,3 +1,6 @@
+require 'util/lazy_mapping_hash'
+require 'util/lazy_mapping_array'
+
 module StrokeDB
   class HashSlotValue < LazyMappingHash
     def with_modification_callback(&block)
@@ -8,6 +11,7 @@ module StrokeDB
       super(*args)
       @modification_callback.call if @modification_callback
     end
+    
   end
 
   class ArraySlotValue < LazyMappingArray
@@ -67,6 +71,7 @@ module StrokeDB
       "#<DocRef #{self[0,5]}..>"
     end
     alias :to_raw :str
+    alias :to_s :str
 
     def ==(v)
       case v
@@ -84,7 +89,10 @@ module StrokeDB
 
   class Slot
     attr_reader :doc, :value, :name
-
+    
+    DUMP_PREFIX    = "@!Dump:".freeze
+    DUMP_PREFIX_RE = /^#{DUMP_PREFIX}/.freeze
+    
     def initialize(doc, name = nil)
       @doc, @name = doc, name
       @decoded = {}
@@ -139,11 +147,13 @@ module StrokeDB
           decode_value(element)
         end
       when Range, Regexp
-        "@!Dump:#{StrokeDB::serialize(v)}"
+        DUMP_PREFIX + StrokeDB::serialize(v)
       when Symbol
         v.to_s
-      when Time, String, Numeric, TrueClass, FalseClass, NilClass
+      when String, Numeric, TrueClass, FalseClass, NilClass
         v
+      when Time
+        v.xmlschema(6)
       else
         raise ArgumentError, "#{v.class} is not a valid slot value type"
       end
@@ -152,8 +162,8 @@ module StrokeDB
     def decode_value(v)
       case v
       when VERSIONREF
-        DocumentReferenceValue.new(v, doc)
-      when /^@!Dump:/
+        DocumentReferenceValue.new(v.to_s, doc)
+      when DUMP_PREFIX_RE
         StrokeDB::deserialize(v[7, v.length-7])
       when Array
         ArraySlotValue.new(v).map_with do |element| 
@@ -175,6 +185,8 @@ module StrokeDB
         end
       when Symbol
         v.to_s
+      when XMLSCHEMA_TIME_RE
+        Time.xmlschema(v).localtime # localtime is for compliance with local time objects
       else
         v
       end

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

@@ -39,7 +39,7 @@ module StrokeDB
       # Get first version of document
       #
       def first
-        document.new? ? document.clone.extend(VersionedDocument) : self[all_preceding_versions.last]
+        document.new? ? document.clone.extend(VersionedDocument) : self[NIL_UUID]
       end
 
 
@@ -51,7 +51,7 @@ module StrokeDB
       # Returns <tt>nil</tt> if there is no previous version
       #
       def previous
-        self[document.previous_version]
+        document.previous_version ? self[document.previous_version] : nil
       end
 
       #

data/lib/strokedb/index.rb

@@ -0,0 +1,2 @@
+module StrokeDB
+end

data/lib/strokedb/nsurl.rb

@@ -0,0 +1,24 @@
+Module.module_eval do
+  
+  def self.reset_nsurls
+    @@nsurls = {}
+    ::Module.nsurl ''
+    ::StrokeDB.nsurl StrokeDB::STROKEDB_NSURL    
+  end
+  def self.find_by_nsurl(url)
+    @@nsurls[url]
+  end
+  
+  def nsurl(url = nil)
+    return @nsurl unless url
+    @@nsurls ||= {}
+    mod = @@nsurls[url]
+    raise ArgumentError, "nsurl #{url.inspect} is already referenced by #{mod.inspect} module" if mod && mod != self
+    @@nsurls.delete(url)
+    @@nsurls[url] = self
+    @nsurl = url
+  end
+  
+end
+
+Module.reset_nsurls