strokedb 0.0.2

data/lib/data_structures/skiplist.rb

@@ -0,0 +1,302 @@
+module StrokeDB
+  class Skiplist
+  	include Enumerable
+	
+  	attr_accessor :default, :head, :tail, :cut_level, :unique_keys
+	  
+  	def initialize(data = {}, default = nil, cut_level = nil, unique_keys = true)
+  		@default, @cut_level, @unique_keys = default, cut_level, unique_keys
+
+  		@head = HeadNode.new
+  		@tail = TailNode.new
+  		@head.forward[0] = @tail
+  		data.each{|k, v| insert(k, v) }
+  	end
+
+  	def insert(key, value, __cheaters_level = nil, __timestamp = nil)
+  	  @size_cache = nil
+  	  update = Array.new(@head.level)
+  	  x = @head
+  	  # We have to choose between < and <= only,
+  	  # but we go into different branches to keep things fast.  
+  	  if @unique_keys
+  	    @head.level.downto(1) do |i|
+  	      x = x.forward[i-1] while x.forward[i-1] < key
+  	      update[i-1] = x
+  	    end
+	    else
+	      @head.level.downto(1) do |i|
+  	      x = x.forward[i-1] while x.forward[i-1] <= key
+  	      update[i-1] = x
+  	    end
+      end
+  	  x = x.forward[0]
+  	  if x.key == key && @unique_keys
+  	    x.value = value
+  	    x.timestamp = __timestamp
+  	    value.skiplist_node_container = x if value.respond_to? :skiplist_node_container=
+  	  else
+  	    newlevel = __cheaters_level || random_level
+  	    newlevel = 1 if empty?
+  	    if newlevel > @head.level 
+  	      (@head.level + 1).upto(newlevel) do |i|
+  	        update[i-1] = @head
+          end
+        end
+        
+        x = Node.new(newlevel, key, value, __timestamp)
+        value.skiplist_node_container = x if value.respond_to? :skiplist_node_container=
+        
+        if cut?(newlevel, update[0])
+          return new_chunks!(x, update)
+        else
+          newlevel.times do |i|
+            x.forward[i] = update[i].forward[i] || @tail
+            update[i].forward[i] = x
+          end
+        end
+      end
+  		return self
+  	end
+
+    # Finders
+    
+    def find_node(key = nil)
+      x = @head
+      @head.level.downto(1) do |i|
+  	    x = x.forward[i-1] while x.forward[i-1] < key
+  	  end
+  	  x = x.forward[0]
+	    return (x.key && yield(x.key, key) ? x : nil) if block_given?
+  	  return x if x.key == key
+  	  nil
+    end
+    
+    def find(key, default = nil)
+      (i = find_node(key)) && i.value || default || @default
+    end
+
+    def find_nearest_node(key)
+      x = @head
+      @head.level.downto(1) do |i|
+  	    x = x.forward[i-1] while x.forward[i-1] < key
+      end
+      x = x.forward[0] if (x.forward[0].key == key || x == @head)
+      x
+    end
+    
+    def find_nearest(key, default = nil)
+      find_nearest_node(key).value || default || @default
+    end
+        
+    def find_all_with_prefix(key)
+      results = []
+      x = @head
+      @head.level.downto(1) do |i|
+        x = x.forward[i-1] while x.forward[i-1] < key
+      end
+      x = x.forward[0]
+      # got first 
+      while x.key && x.key[0, key.size] == key 
+        results << x.value
+        x = x.forward[0]
+      end
+      results
+    end
+    
+        
+    def delete(key, default = nil)
+      @size_cache = nil
+      default ||= @default
+      update = Array.new(@head.level)
+      x = @head
+  	  @head.level.downto(1) do |i|
+  	    x = x.forward[i-1] while x.forward[i-1] < key
+  	    update[i-1] = x
+  	  end
+  	  x = x.forward[0]
+  	  if x.key == key
+        @head.level.times do |i|
+          break if update[i].forward[i] != x
+          update[i].forward[i] = x.forward[i]
+        end
+        true while (y = @head.forward.pop) == @tail
+        @head.forward.push(y || @tail)
+        x.free(self)
+        x.value
+      else
+        default
+      end
+    end
+    
+    def first_node
+      @head.forward[0]
+    end
+    
+    def size
+  		@size_cache ||= inject(0){|c,k| c + 1}
+  	end
+	
+  	def empty?
+  	  @head.forward[0] == @tail
+  	end
+
+  	# Returns a string representation of the Skiplist.
+  	def to_s
+  		"#<#{self.class.name} " + 
+  		[@head.to_s, map{|node| node.to_s }, @tail.to_s].flatten.join(', ') +
+  		">"
+  	end
+  	def to_s_levels
+  		"#<#{self.class.name}:levels " + 
+  		[@head.to_s, map{|node| node.level.to_s }, @tail.to_s].flatten.join(', ') +
+  		">"
+  	end
+  	
+  	def eql?(skiplist)
+  	  zip(skiplist) {|a, b| return false unless a.key == b.key && a.value == b.value }
+  	  true
+	  end
+
+ 	  def each
+  	  n = @head.forward[0]
+  	  until TailNode === n
+  	    yield n
+  	    n = n.forward[0]
+      end
+  	end
+
+    # Only for empty list!
+    def raw_insert(data)
+      n = @head
+      sn = nil
+      update = []
+      data.each do |item|
+        key, value, level, timestamp = yield(item)
+        sn = Node.new(level, key, value, timestamp)
+        level.times do |i| 
+          update[i] ||= @head
+          update[i].forward[i] = sn
+          sn.forward[i] = @tail 
+          update[i] = sn
+        end
+      end
+    end
+
+  private
+
+    # 1/E is a fastest search value
+  	PROBABILITY = 1/Math::E
+  	MAX_LEVEL   = 32
+  
+  	def random_level
+  		l = 1
+  		l += 1 while rand < PROBABILITY && l < MAX_LEVEL
+  		return l
+  	end
+  	
+  	def cut?(l, prev)
+    	@cut_level && !empty? && l >= @cut_level && prev != @head
+  	end
+
+  	def new_chunks!(newnode, update)
+  	  # Transposed picture:
+  	  #
+  	  # head level 8:     - - - - - - - -
+  	  # update.size 8:    - - - - - - - -
+  	  # ...
+  	  # newnode.level 5:  - - - - -
+  	  # cut level 3:      - - - 
+   	  # regular node:     - 
+  	  # regular node:     - -
+  	  # ...                        
+  	  # tail node:        T T T T T T T T   
+  	  #           refs:   A B C D E F G H 
+  	  #
+  	  # How to cut?
+  	  #
+      # 0) tail1 = TailNode.new; list2 = Skiplist.new
+  	  # 1) newnode.{A, B, C, D, E} := update{A,B,C,D,E}.forward
+  	  # 2) update.{all} := tail1 (for current chunk)
+  	  # 3) list2.head.{A, B, C, D, E} = new_node.{A, B, C, D, E}
+  	  # 4) tail1.next_list = list2
+  	  
+  	  list2 = Skiplist.new({}, @default, @cut_level)
+  	  tail1 = TailNode.new
+  	  
+  	  newnode.level.times do |i|
+  	    # add '|| @tail' because update[i] may be head of a lower level
+  	    # without forward ref to tail.
+  	    newnode.forward[i] = update[i].forward[i] || @tail
+  	    list2.head.forward[i] = newnode
+	    end
+	    @head.level.times do |i|
+	      update[i].forward[i] = tail1
+        end
+	    tail1.next_list = list2
+  	  # return the current chunk and the next chunk
+  	  return self, list2
+  	end
+
+  	class Node
+  		attr_accessor :key, :value, :forward, :timestamp
+  		attr_accessor :_serialized_index
+  		def initialize(level, key, value,timestamp=nil)
+  			@key, @value, @timestamp = key, value, timestamp
+  			@forward = Array.new(level)
+  		end
+  		# this is called when node is thrown out of the list
+  		# note, that node.value is called immediately after node.free
+  		def free(list)
+  		  # do nothing
+  		end
+  		def level
+  		  @forward.size
+  		end
+  		def <(key)
+  		  @key < key
+  	  end
+  	  def <=(key)
+  		  @key <= key
+  	  end
+  	  def next
+  	    forward[0]
+  	  end
+  	  def to_s
+  	    "[#{level}]#{@key}: #{@value}"
+  	  end
+  	end
+
+  	class HeadNode < Node
+  		def initialize
+  			super 1, nil, nil
+  		end
+  		def <(key)
+  		  true
+  	  end
+  	  def <=(key)
+  		  true
+  	  end
+      def to_s
+  	    "head(#{level})"
+  	  end
+  	end
+	
+  	# also proxy-to-next-chunk node
+  	class TailNode < Node
+  	  attr_accessor :next_list
+  		def initialize
+  			super 1, nil, nil
+  		end
+  		def <(key)
+  		  false
+  	  end
+  	  def <=(key)
+  		  false
+  	  end
+  	  def to_s
+  	    "tail(#{level})"
+  	  end
+  	end
+  end
+end

data/lib/document/associations.rb

@@ -0,0 +1,107 @@
+module StrokeDB
+
+  module Associations
+
+    module HasManyAssociation
+      attr_reader :association_owner, :association_slotname
+      def new(slots={})
+        association_meta.constantize.new(association_owner.store, slots.merge({association_reference_slotname => association_owner}))
+      end
+      alias :build :new
+
+      def create!(slots={})
+        new(slots).save!
+      end
+      
+      def find(query={})
+        association_owner._has_many_association(association_slotname,query)
+      end
+      def <<(doc)
+        doc.update_slots! association_reference_slotname => association_owner
+        self
+      end
+      
+      private 
+
+      def association_reference_slotname
+        association_owner.meta["has_many_#{association_slotname}"][:reference_slotname]
+      end
+
+      def association_meta
+        association_owner.meta["has_many_#{association_slotname}"][:meta]
+      end
+
+    end
+
+    def has_many(slotname, opts={}, &block)
+      opts = opts.stringify_keys
+
+      reference_slotname = opts['foreign_reference']
+      through = opts['through'] || []
+      through = [through] unless through.is_a?(Array)
+      meta = (through.shift || slotname).to_s.singularize.camelize
+      query = opts['conditions'] || {}
+
+      extend_with = opts['extend'] || block
+
+      @meta_initialization_procs << Proc.new do
+        case extend_with
+        when Proc
+          extend_with_proc = extend_with
+          extend_with = "HasMany#{slotname.to_s.camelize}"
+          const_set(extend_with, Module.new(&extend_with_proc))
+          extend_with = "#{self.name}::HasMany#{slotname.to_s.camelize}"
+        when Module
+          extend_with = extend_with.name
+        when NilClass
+        else
+          raise "has_many extension should be either Module or Proc"
+        end
+        reference_slotname = reference_slotname || name.demodulize.tableize.singularize
+        if name.index('::') # we're in namespaced meta
+          _t = name.split('::')
+          _t.pop
+          _t << meta
+          meta = _t.join('::') 
+        end
+        @args.last.reverse_merge!({"has_many_#{slotname}" => { :reference_slotname => reference_slotname, :through => through, :meta => meta, :query => query, :extend_with => extend_with } })
+        define_method(slotname) do 
+          _has_many_association(slotname,{})
+        end
+
+      end
+
+    end 
+
+    private 
+
+    def initialize_associations
+      define_method(:_has_many_association) do |slotname, additional_query|
+        slot_has_many = meta["has_many_#{slotname}"]
+        reference_slotname = slot_has_many[:reference_slotname]
+        through = slot_has_many[:through]
+        meta = slot_has_many[:meta]
+        query = slot_has_many[:query]
+        effective_query = query.merge(:meta => meta.constantize.document, reference_slotname => self).merge(additional_query)
+
+        result = LazyArray.new.load_with do |lazy_array|
+          store.search(effective_query).map do |d| 
+            begin
+              through.each { |t| d = d.send(t) }
+            rescue SlotNotFoundError
+              d = nil
+            end
+            d
+          end.compact
+        end
+        if extend_with = slot_has_many[:extend_with] 
+          result.extend(extend_with.constantize) 
+        end
+        result.instance_variable_set(:@association_owner, self)
+        result.instance_variable_set(:@association_slotname, slotname)
+        result.extend(HasManyAssociation)
+        result
+      end
+    end
+  end
+end  

data/lib/document/callback.rb

@@ -0,0 +1,11 @@
+module StrokeDB
+  class Callback
+    attr_reader :origin, :name, :uid
+    def initialize(origin, name, uid=nil, &block)
+      @origin, @name, @uid, @block = origin, name, uid, block
+    end
+    def call(*args)
+      @block.call(*args)
+    end
+  end
+end

data/lib/document/coercions.rb

@@ -0,0 +1,57 @@
+module StrokeDB
+  module Coercions
+    def coerces(slotnames, opts = {})
+      opts = opts.stringify_keys
+      raise ArgumentError, "coerces should have :to specified" unless opts['to']
+
+      check_condition(opts['if']) if opts['if']
+      check_condition(opts['unless']) if opts['unless']
+      
+      slotnames = [slotnames] unless slotnames.is_a?(Array)
+      slotnames.each {|slotname| register_coercion(slotname, opts)}
+    end
+
+    private
+
+    def initialize_coercions
+      on_set_slot(:coerces) do |doc, slotname, value|
+        if coercion = doc.meta["coerces_#{slotname}"] 
+          should_call = (!coercion[:if] || evaluate_condition(coercion[:if], doc)) &&
+          (!coercion[:unless] || !evaluate_condition(coercion[:unless], doc))
+          if should_call 
+            case coercion[:to]
+            when 'number'
+              if value.to_i.to_s == value
+                value.to_i
+              else
+                value
+              end
+            when 'string'
+              value.to_s
+            end
+          end
+        end
+      end
+    end
+
+    def register_coercion(slotname, opts)
+      slotname = slotname.to_s
+      to = opts['to'].to_s 
+
+      options_hash = { 
+        :slotname => slotname, 
+        :if => opts['if'],  
+        :unless => opts['unless'],
+        :to => to
+      }
+
+      # options_hash.merge!(yield(opts)) if block_given?
+
+      coercion_slot = "coerces_#{slotname}"
+
+      @meta_initialization_procs << Proc.new do
+        @args.last.reverse_merge!(coercion_slot => { :meta => name }.merge(options_hash))
+      end
+    end
+  end  
+end

data/lib/document/delete.rb

@@ -0,0 +1,28 @@
+module StrokeDB
+
+  class DocumentDeletionError < StandardError
+  end
+  
+  DeletedDocument = Meta.new(:uuid => DELETED_DOCUMENT_UUID) do
+    on_load do |doc|
+      doc.make_immutable!
+    end
+    
+    def undelete!
+      deleted_version = versions.previous
+      store.save_as_head!(deleted_version)
+      self.class.find(uuid)
+    end
+  end
+  
+  class Document
+    
+    def delete!
+      raise DocumentDeletionError, "can't delete non-head document" unless head?
+      metas << DeletedDocument
+      save!
+      make_immutable!
+    end
+    
+  end
+end