strokedb 0.0.2

data/lib/document/meta.rb

@@ -0,0 +1,261 @@
+module StrokeDB
+  # Meta is basically a type. Imagine the following document:
+  #
+  # some_apple:
+  #   weight: 3oz
+  #   color: green
+  #   price: $3
+  #
+  # Each apple is a fruit and a product in this case (because it has price).
+  #
+  # we can express it by assigning metas to document like this:
+  #
+  # some_apple:
+  #   meta: [Fruit, Product]
+  #   weight: 3oz
+  #   color: green
+  #   price: $3
+  #
+  # In document slots metas store references to metadocument.
+  #
+  # Document class will be extended by modules Fruit and Product.
+  module Meta
+
+    class << self
+      def new(*args, &block)
+        mod = Module.new
+        args = args.unshift(nil) if args.empty? || args.first.is_a?(Hash)
+        args << {} unless args.last.is_a?(Hash)
+        mod.module_eval do
+          @args = args
+          @meta_initialization_procs = []
+          @metas = [self]
+          extend Meta
+          extend Associations
+          extend Validations
+          extend Coercions
+          extend Virtualizations
+          extend Util
+        end
+        mod.module_eval(&block) if block_given?
+        mod.module_eval do
+          initialize_associations
+          initialize_validations
+          initialize_coercions
+          initialize_virtualizations
+        end
+        if meta_name = extract_meta_name(*args)
+          Object.const_set(meta_name, mod)
+        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)
+        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
+      end
+
+    end
+
+    def +(meta)
+      if is_a?(Module) && meta.is_a?(Module)
+        new_meta = Module.new
+        instance_variables.each do |iv|
+          new_meta.instance_variable_set(iv, instance_variable_get(iv) ? instance_variable_get(iv).clone : nil)
+        end
+        new_meta.instance_variable_set(:@metas, @metas.clone)
+        new_meta.instance_variable_get(:@metas) << meta
+        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
+      elsif is_a?(Document) && meta.is_a?(Document)
+        (Document.new(store, self.to_raw.except('uuid','version','previous_version'), true) +
+        Document.new(store, meta.to_raw.except('uuid','version','previous_version'), true)).extend(Meta).make_immutable!
+      else
+        raise "Can't + #{self.class} and #{meta.class}"
+      end
+    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.each do |callback_name|
+      module_eval %{
+        def #{callback_name}(uid=nil, &block)
+          add_callback('#{callback_name}', uid, &block)
+        end
+      }
+    end
+
+    def new(*args, &block)
+      args = args.clone
+      args << {} unless args.last.is_a?(Hash)
+      args.last[:meta] = @metas
+      doc = Document.new(*args, &block)
+      doc
+    end
+
+    def create!(*args, &block)
+      new(*args, &block).save!
+    end
+ 
+    #
+    # Finds all documents matching given parameters. The simplest form of
+    # +find+ call is without any parameters. This returns all documents
+    # belonging to the meta as an array.
+    #
+    #   User = Meta.new
+    #   all_users = User.find
+    # 
+    # Another form is to find a document by its UUID:
+    #
+    #   specific_user = User.find("1e3d02cc-0769-4bd8-9113-e033b246b013")
+    #
+    # If the UUID is not found, nil is returned.
+    #
+    # Most prominent search uses slot values as criteria:
+    #
+    #   short_fat_joes = User.find(:name => "joe", :weight => 110, :height => 167)
+    # 
+    # All matching documents are returned as an array.
+    #
+    # In all described cases the default store is used. You may also specify
+    # another store as the first argument:
+    #
+    #   all_my_users = User.find(my_store)
+    #   all_my_joes  = User.find(my_store, :name => "joe")
+    #   oh_my        = User.find(my_store, "1e3d02cc-0769-4bd8-9113-e033b246b013")
+    #
+    def find(*args)
+      if args.empty? || !args.first.respond_to?(:search)
+        raise NoDefaultStoreError unless StrokeDB.default_store
+        
+        args = args.unshift(StrokeDB.default_store) 
+      end
+
+      unless args.size == 1 || args.size == 2
+        raise ArgumentError, "Invalid arguments for find"
+      end
+
+      store = args[0]
+      opt = { :meta => @metas.map {|m| m.document(store)} }
+
+      case args[1]
+      when String
+        raise ArgumentError, "Invalid UUID" unless args[1].match(UUID_RE)
+
+        store.search(opt.merge({ :uuid => args[1] })).first
+      when Hash
+        store.search opt.merge(args[1])
+      when nil
+        store.search opt
+      else
+        raise ArgumentError, "Invalid search criteria for find"
+      end
+    end
+
+    #
+    # Similar to +find+, but a creates document with appropriate slot values if
+    # not found.
+    #
+    # If found, returned is only the first result.
+    #
+    def find_or_create(*args)
+      result = find(*args)
+      result.empty? ? create!(*args) : result.first
+    end
+
+    def inspect
+      if is_a?(Module)
+        name
+      else
+        pretty_print
+      end
+    end
+
+    alias :to_s :inspect
+
+    def document(store=nil)
+      metadocs = @metas.map do |m|
+        @args = m.instance_variable_get(:@args)
+        make_document(store)
+      end
+      metadocs.size > 1 ? metadocs.inject { |a, b| a + b }.make_immutable! : metadocs.first
+    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[:meta] = Meta.document(store)
+      values[:name] ||= name
+      
+      if meta_doc = find_meta_doc(values, store)
+        values[:version] = meta_doc.version
+        values[:uuid] = meta_doc.uuid
+        args = [store, values]
+        meta_doc = updated_meta_doc(args) if changed?(meta_doc, args)
+      else
+        args = [store, values]
+        meta_doc = Document.new(*args)
+        meta_doc.extend(Meta)
+        meta_doc.save!
+      end
+      meta_doc
+    end
+
+    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
+
+    def changed?(meta_doc, args)
+      !(Document.new(*args).to_raw.except('previous_version') == meta_doc.to_raw.except('previous_version'))
+    end
+    
+    def updated_meta_doc(args)
+      new_doc = Document.new(*args)
+      new_doc.instance_variable_set(:@saved, true)
+      new_doc.send!(:update_version!, nil)
+      new_doc.save!
+    end
+
+    def add_callback(name,uid=nil, &block)
+      @callbacks ||= []
+      @callbacks << Callback.new(self, name, uid, &block)
+    end
+
+    def setup_callbacks(doc)
+      return unless @callbacks
+      @callbacks.each do |callback|
+        doc.callbacks[callback.name] ||= []
+        doc.callbacks[callback.name] << callback
+      end
+    end
+
+  end
+
+end

data/lib/document/slot.rb

@@ -0,0 +1,199 @@
+module StrokeDB
+  class HashSlotValue < LazyMappingHash
+    def with_modification_callback(&block)
+      @modification_callback = block
+      self
+    end
+    def []=(*args)
+      super(*args)
+      @modification_callback.call if @modification_callback
+    end
+  end
+
+  class ArraySlotValue < LazyMappingArray
+    def with_modification_callback(&block)
+      @modification_callback = block
+      self
+    end
+    def []=(*args)
+      super(*args)
+      @modification_callback.call if @modification_callback
+    end
+    def push(*args)
+      super(*args)
+      @modification_callback.call if @modification_callback
+    end
+    def <<(*args)
+      super(*args)
+      @modification_callback.call if @modification_callback
+    end
+    def unshift(*args)
+      super(*args)
+      @modification_callback.call if @modification_callback
+    end
+
+    def include?(v) 
+      case v
+      when VersionedDocument
+        super(v)
+      when Document
+        v.versions.all.find{|d| super(d)} # FIXME: versions.all could be pretty slow
+      else
+        super(v)
+      end
+    end
+
+  end
+
+  class DocumentReferenceValue < String
+    attr_reader :str
+    attr_accessor :doc
+    def initialize(str, doc, __cached_value = nil)
+      @str, @doc = str, doc
+      @cached_value = __cached_value
+      super(str)
+    end
+    def load
+      case self
+      when VERSIONREF
+        if doc.head?
+          @cached_value || @cached_value = doc.store.find($1) || self
+        else
+          @cached_value || @cached_value = doc.store.find($1,$2) || self
+        end
+      end
+    end
+    def inspect
+      "#<DocRef #{self[0,5]}..>"
+    end
+    alias :to_raw :str
+
+    def ==(v)
+      case v
+      when DocumentReferenceValue
+        v.str == str
+      when Document
+        v == self
+      else
+        str == v
+      end
+    end
+
+
+  end
+
+  class Slot
+    attr_reader :doc, :value, :name
+
+    def initialize(doc, name = nil)
+      @doc, @name = doc, name
+      @decoded = {}
+    end
+
+    def value=(v)
+      v = doc.send!(:execute_callbacks, :on_set_slot, name, v) || v unless name == 'meta'
+      @value = decode_value(enforce_collections(encode_value(v, true), true))
+    end
+
+    def value
+      @value.is_a?(DocumentReferenceValue) ? @value.load : @value
+    end
+
+    def to_raw
+      raw_value.to_optimized_raw
+    end
+
+
+
+    def raw_value=(v)
+      self.value = decode_value(v)
+    end
+
+    private
+
+    def raw_value
+      result = encode_value(@value)
+      enforce_collections(result)
+    end
+
+    def encode_value(v, skip_documents=false)
+      case v
+      when Document
+        skip_documents ? v : DocumentReferenceValue.new(v.__reference__, doc, v) 
+      when Module
+        if v.respond_to?(:document)
+          v.document(doc.store) 
+        else
+          raise ArgumentError, "#{v.class} is not a valid slot value type"
+        end
+      when Array
+        LazyMappingArray.new(v).map_with do |element| 
+          encode_value(element, skip_documents)
+        end.unmap_with do |element|
+          decode_value(element)
+        end
+      when Hash
+        LazyMappingHash.new(v).map_with do |element| 
+          encode_value(element, skip_documents)
+        end.unmap_with do |element|
+          decode_value(element)
+        end
+      when Range, Regexp
+        "@!Dump:#{StrokeDB::serialize(v)}"
+      when Symbol
+        v.to_s
+      when Time, String, Numeric, TrueClass, FalseClass, NilClass
+        v
+      else
+        raise ArgumentError, "#{v.class} is not a valid slot value type"
+      end
+    end
+
+    def decode_value(v)
+      case v
+      when VERSIONREF
+        DocumentReferenceValue.new(v, doc)
+      when /^@!Dump:/
+        StrokeDB::deserialize(v[7, v.length-7])
+      when Array
+        ArraySlotValue.new(v).map_with do |element| 
+          decoded = decode_value(element)
+          @decoded[decoded] ||= decoded.is_a?(DocumentReferenceValue) ? decoded.load : decoded
+        end.unmap_with do |element|
+          encode_value(element)
+        end.with_modification_callback do
+          doc.send!(:update_version!, nil)
+        end
+      when Hash
+        HashSlotValue.new(v).map_with do |element|
+          decoded = decode_value(element)
+          @decoded[decoded] ||= decoded.is_a?(DocumentReferenceValue) ? decoded.load : decoded
+        end.unmap_with do |element|
+          encode_value(element)
+        end.with_modification_callback do
+          doc.send!(:update_version!, nil)
+        end
+      when Symbol
+        v.to_s
+      else
+        v
+      end
+    end
+
+    def enforce_collections(v, skip_documents = false)
+      return v unless v.is_a?(Array) || v.is_a?(Hash)
+      case v
+      when Array
+        v.map{|v| enforce_collections(encode_value(v, skip_documents))}
+      when Hash
+        h = {}
+        v.each_pair do |k, v|
+          h[enforce_collections(encode_value(k, skip_documents))] = enforce_collections(encode_value(v, skip_documents))
+        end
+        h
+      end
+    end
+
+  end
+
+end

data/lib/document/util.rb

@@ -0,0 +1,27 @@
+module StrokeDB
+  module Meta
+    module Util
+      def grep_slots(doc, prefix)
+        doc.meta.slotnames.each do |slotname|
+          if slotname[0..(prefix.length - 1)] == prefix
+            yield slotname[prefix.length..-1], slotname
+          end
+        end
+      end
+
+      def check_condition(condition)
+        case condition
+        when Symbol, String then return
+        else
+          raise ArgumentError, ":if/:unless clauses need to be either a symbol or string (slotname or method name)"
+        end
+      end
+
+      def evaluate_condition(condition, doc)
+        case condition
+        when String then doc.send(condition)
+        end
+      end
+    end
+  end
+end