strokedb 0.0.2

data/lib/util/inflect.rb

@@ -0,0 +1,217 @@
+# from the English gem (http://english.rubyforge.org/)
+# http://english.rubyforge.org/rdoc/classes/English/Inflect.html
+#
+# last updated from http://english.rubyforge.org/svn/trunk/lib/english/inflect.rb on 3-31-2008
+
+module English
+
+  # = English Nouns Number Inflection.
+  #
+  # This module provides english singular <-> plural noun inflections.
+  module Inflect
+
+    @singular_of = {}
+    @plural_of = {}
+
+    @singular_rules = []
+    @plural_rules = []
+
+    class << self
+      # Define a general exception.
+      def word(singular, plural=nil)
+        plural = singular unless plural
+        singular_word(singular, plural)
+        plural_word(singular, plural)
+      end
+
+      # Define a singularization exception.
+      def singular_word(singular, plural)
+        @singular_of[plural] = singular
+      end
+
+      # Define a pluralization exception.
+      def plural_word(singular, plural)
+        @plural_of[singular] = plural
+      end
+
+      # Define a general rule.
+      def rule(singular, plural)
+        singular_rule(singular, plural)
+        plural_rule(singular, plural)
+      end
+
+      # Define a singularization rule.
+      def singular_rule(singular, plural)
+        @singular_rules << [singular, plural]
+      end
+
+      # Define a plurualization rule.
+      def plural_rule(singular, plural)
+        @plural_rules << [singular, plural]
+      end
+
+      # Read prepared singularization rules.
+      def singularization_rules
+        return @singularization_rules if @singularization_rules
+        sorted = @singular_rules.sort_by{ |s, p| "#{p}".size }.reverse
+        @singularization_rules = sorted.collect do |s, p|
+          [ /#{p}$/, "#{s}" ]
+        end
+      end
+
+      # Read prepared pluralization rules.
+      def pluralization_rules
+        return @pluralization_rules if @pluralization_rules
+        sorted = @plural_rules.sort_by{ |s, p| "#{s}".size }.reverse
+        @pluralization_rules = sorted.collect do |s, p|
+          [ /#{s}$/, "#{p}" ]
+        end
+      end
+
+      #
+      def plural_of
+        @plural_of
+      end
+
+      #
+      def singular_of
+        @singular_of
+      end
+
+      # Convert an English word from plurel to singular.
+      #
+      #   "boys".singular      #=> boy
+      #   "tomatoes".singular  #=> tomato
+      #
+      def singular(word)
+        if result = singular_of[word]
+          return result.dup
+        end
+        result = word.dup
+        singularization_rules.each do |(match, replacement)|
+          break if result.gsub!(match, replacement)
+        end
+        return result
+      end
+
+      # Alias for #singular (a Railism).
+      #
+      alias_method(:singularize, :singular)
+
+      # Convert an English word from singular to plurel.
+      #
+      #   "boy".plural     #=> boys
+      #   "tomato".plural  #=> tomatoes
+      #
+      def plural(word)
+        if result = plural_of[word]
+          return result.dup
+        end
+        #return self.dup if /s$/ =~ self # ???
+        result = word.dup
+        pluralization_rules.each do |(match, replacement)|
+          break if result.gsub!(match, replacement)
+        end
+        return result
+      end
+
+      # Alias for #plural (a Railism).
+      alias_method(:pluralize, :plural)
+    end
+
+    # One argument means singular and plural are the same.
+
+    word 'equipment'
+    word 'information'
+    word 'money'
+    word 'species'
+    word 'series'
+    word 'fish'
+    word 'sheep'
+    word 'moose'
+    word 'hovercraft'
+
+    # Two arguments defines a singular and plural exception.
+
+    word 'Swiss'     , 'Swiss'
+    word 'life'      , 'lives'
+    word 'wife'      , 'wives'
+    word 'virus'     , 'viri'
+    word 'octopus'   , 'octopi'
+    word 'goose'     , 'geese'
+    word 'criterion' , 'criteria'
+    word 'alias'     , 'aliases'
+    word 'status'    , 'statuses'
+    word 'axis'      , 'axes'
+    word 'crisis'    , 'crises'
+    word 'testis'    , 'testes'
+    word 'child'     , 'children'
+    word 'person'    , 'people'
+    word 'potato'    , 'potatoes'
+    word 'tomato'    , 'tomatoes'
+    word 'buffalo'   , 'buffaloes'
+    word 'torpedo'   , 'torpedoes'
+    word 'quiz'      , 'quizes'
+    word 'matrix'    , 'matrices'
+    word 'vertex'    , 'vetices'
+    word 'index'     , 'indices'
+    word 'ox'        , 'oxen'
+    word 'mouse'     , 'mice'
+    word 'louse'     , 'lice'
+    word 'thesis'    , 'theses'
+    word 'thief'     , 'thieves'
+    word 'analysis'  , 'analyses'
+
+    # One-way singularization exception (convert plural to singular).
+
+    singular_word 'cactus', 'cacti'
+
+    # General rules.
+
+    rule 'hive' , 'hives'
+    rule 'rf'   , 'rves'
+    rule 'af'   , 'aves'
+    rule 'ero'  , 'eroes'
+    rule 'man'  , 'men'
+    rule 'ch'   , 'ches'
+    rule 'sh'   , 'shes'
+    rule 'ss'   , 'sses'
+    rule 'ta'   , 'tum'
+    rule 'ia'   , 'ium'
+    rule 'ra'   , 'rum'
+    rule 'ay'   , 'ays'
+    rule 'ey'   , 'eys'
+    rule 'oy'   , 'oys'
+    rule 'uy'   , 'uys'
+    rule 'y'    , 'ies'
+    rule 'x'    , 'xes'
+    rule 'lf'   , 'lves'
+    rule 'us'   , 'uses'
+    rule ''     , 's'
+
+    # One-way singular rules.
+
+    singular_rule 'of' , 'ofs' # proof
+    singular_rule 'o'  , 'oes' # hero, heroes
+    singular_rule 'f'  , 'ves'
+
+    # One-way plural rules.
+
+    plural_rule 'fe' , 'ves' # safe, wife
+    plural_rule 's'  , 'ses'
+
+  end
+end
+
+
+class String
+  def singular
+    English::Inflect.singular(self)
+  end
+  alias_method(:singularize, :singular)
+
+  def plural
+    English::Inflect.plural(self)
+  end
+  alias_method(:pluralize, :plural)
+end

data/lib/util/java_util.rb

@@ -0,0 +1,9 @@
+require 'java'
+# Some java overrides
+module StrokeDB
+  module Util
+    def self.random_uuid
+      java.util.UUID.random_uuid.to_s
+    end
+  end
+end

data/lib/util/lazy_array.rb

@@ -0,0 +1,54 @@
+module StrokeDB
+  # Lazy loads items from array.
+  #
+  # Lazy arrays are backed by Proc returning regular array
+  # on first call retrieving it from @load_with_proc.
+  #
+  # Example:
+  #
+  #   ary = LazyArray.new.load_with { Time.now.to_s.split(/\s/) }
+  #
+  # On first attempt to access <tt>ary</tt> (including <tt>inspect</tt>) it will
+  # evaluate load_with's Proc and update own content with its result:
+  #
+  #   ary
+  #     # ==> ["Mon", "Mar", "17", "10:35:52", "+0200", "2008"]
+  #
+  class LazyArray < BlankSlate
+    def initialize(*args)
+      @load_with_proc = proc {|v| v}
+      @array = Array.new(*args)
+    end
+
+    # Proc to execute lazy loading
+    def load_with(&block)
+      @load_with_proc = block
+      self
+    end
+
+    # Make it look like array for outer world
+    def class
+      Array
+    end
+
+    def method_missing sym, *args, &blk
+      if @array.respond_to? sym
+        load!
+        @array.__send__ sym, *args, &blk
+      else
+        super
+      end
+    end
+
+    private
+
+    def load!
+      if @load_with_proc
+        @array.clear
+        @array.concat @load_with_proc.call(@array)
+        @load_with_proc = nil
+      end
+    end
+
+  end
+end

data/lib/util/lazy_mapping_array.rb

@@ -0,0 +1,64 @@
+module StrokeDB
+  # Lazy loads items from array applying procs on each read and write.
+  #
+  # Example:
+  #
+  # @ary[i] = 10
+  #
+  # applies "unmap proc" to new item value.
+  #
+  # @ary.at(i)
+  #
+  # applies "map proc" to value just have been read.
+  #
+  # StrokeDB uses this class to "follow" links to other documents
+  # found in slots in a lazy manner.
+  #
+  # player:
+  #   model: [@#8b195509-f9c4-4fea-90c9-425b38bdda3e.ea5eda78-d410-44be-8b14-f4e33f6fa047]
+  #   generation: 4
+  #
+  # when model collection item is fetched, reference followed and turned into document
+  # instance with mapping proc of lazy mapping array.
+  class LazyMappingArray < BlankSlate(Array)
+    def initialize(*args)
+      @map_proc = proc {|v| v}
+      @unmap_proc = proc {|v| v}
+      super(*args)
+    end
+
+    def map_with(&block)
+      @map_proc = block
+      self
+    end
+
+    def unmap_with(&block)
+      @unmap_proc = block
+      self
+    end
+
+    def class
+      Array
+    end
+
+    def method_missing sym, *args, &blk
+      super if sym.to_s =~ /^__/
+      mname = "__#{::BlankSlate::MethodMapping[sym.to_s] || sym}"
+
+      case sym
+      when :push, :unshift, :<<, :[]=, :index, :-
+        last = args.pop
+        last = last.is_a?(Array) ? last.map{|v| @unmap_proc.call(v) } : @unmap_proc.call(last)
+        args.push last
+
+        __send__(mname, *args, &blk)
+
+      when :[], :slice, :at, :map, :shift, :pop, :include?, :last, :first, :zip, :each, :inject, :each_with_index
+        __map{|v| @map_proc.call(v) }.__send__(sym, *args, &blk)
+
+      else
+        __send__(mname, *args, &blk)
+      end
+    end
+  end
+end

data/lib/util/lazy_mapping_hash.rb

@@ -0,0 +1,46 @@
+module StrokeDB
+  class LazyMappingHash < BlankSlate(Hash)
+    def initialize(original = {}, decoder = nil, encoder = nil)
+      @decoder = decoder || proc {|v| v}
+      @encoder = encoder || proc {|v| v}
+      super(default)
+      original.each {|k,v| self.__squarebracket_set(k,v) }
+    end
+    
+    def map_with(&block)
+      @encoder = block
+      self
+    end
+
+    def unmap_with(&block)
+      @decoder = block
+      self
+    end
+
+    def class
+      Hash
+    end
+
+    def method_missing sym, *args, &blk
+      super if sym.to_s =~ /^__/
+      mname = "__#{::BlankSlate::MethodMapping[sym.to_s] || sym}"
+
+      case sym
+      when :keys, :values
+        __send__(mname, *args, &blk).map{|v| @encoder.call(v) }
+
+      when :each
+        self.__each do |k,v|
+          yield @encoder.call(k), @encoder.call(v)
+        end
+
+      when :[], :[]=
+        args.map!{|v| @decoder.call(v) }
+        @encoder.call __send__(mname, *args, &blk)
+
+      else
+        __send__(mname, *args, &blk)
+      end
+    end
+  end
+end

data/lib/util/serialization.rb

@@ -0,0 +1,29 @@
+module StrokeDB
+  module JsonSerializationMethod
+    def serialize(x)
+      x.to_json
+    end
+    def deserialize(x)
+      JSON.parse(x)
+    end
+  end
+
+  module MarshalSerializationMethod
+    def serialize(x)
+      x = x.to_raw if x.respond_to?(:to_raw)
+      Marshal.dump(x)
+    end
+    def deserialize(x)
+     Marshal.load(x)
+    end
+  end
+
+  
+  def self.serialization_method=(method_name)
+    StrokeDB.extend StrokeDB.const_get("#{method_name.to_s.camelize}SerializationMethod")
+  end
+  
+  self.serialization_method = :marshal
+  
+  
+end

data/lib/util/trigger_partition.rb

@@ -0,0 +1,136 @@
+module Enumerable
+  class TriggerPartitionContext
+    def initialize(enum, &block)
+      @enum = enum
+      @cont = block
+    end
+    def fill(&block)
+      @fill = block
+      self
+    end
+    def emit
+      partitions = []
+      cont = @cont
+      fill = @fill
+      p = @enum.inject(nil) do |part, elem|
+        if part && cont.call(part, elem)
+          fill.call(part, elem)
+          part
+        else
+          partitions << part if part
+          yield(elem)
+        end
+      end
+      partitions << p if p
+      partitions
+    end
+  end
+  def trigger_partition(&block)
+    TriggerPartitionContext.new(self, &block)
+  end
+  
+  class TriggerPartitions
+    def self.partition(list)
+      partitions = []
+      p = list.inject(nil) do |part, elem|
+        if part && continue?(part, elem)
+          fill(part, elem)
+          part
+        else
+          partitions << part if part
+          emit(elem)
+        end
+      end
+      partitions << p if p
+      partitions
+    end
+    def self.continue?(p, e)
+      true
+    end
+    def self.emit(e)
+      [e]
+    end
+    def self.fill(p, e)
+      p << e
+    end
+  end
+end
+
+if __FILE__ == $0
+  arr = [1,2,3,4,5, -1, -4, -3, 5, 6, 7, 8, -6, -7]
+  parr = arr.trigger_partition do |partition, element|
+    partition[0] > 0 && element > 0 || partition[0] < 0 && element < 0
+  end.fill do |p, e|
+    p << e
+  end.emit do |e|
+    [e]
+  end
+  
+  p arr
+  p parr
+  
+  # Class might be faster
+  class SignPartitions < Enumerable::TriggerPartitions
+    def self.continue?(partition, element)
+      partition[0] > 0 && element > 0 || partition[0] < 0 && element < 0
+    end
+  end
+  
+  p Enumerable::TriggerPartitions.partition(arr)
+  p SignPartitions.partition(arr)
+  
+  require 'benchmark'
+  include Benchmark
+  n = 1000
+  bm(32) do |x|
+    x.report("#{n} times:" ) do
+      n.times do
+        arr.trigger_partition do |partition, element|
+          partition[0] > 0 && element > 0 || partition[0] < 0 && element < 0
+        end.fill do |p, e|
+          p << e
+        end.emit do |e|
+          [e]
+        end
+      end
+    end
+    arrL = arr*28
+    x.report("#{n} times (x28 larger data):" ) do
+      n.times do
+        arrL.trigger_partition do |partition, element|
+          partition[0] > 0 && element > 0 || partition[0] < 0 && element < 0
+        end.fill do |p, e|
+          p << e
+        end.emit do |e|
+          [e]
+        end
+      end
+    end
+    # 35% faster
+    x.report("#{n} times (SignPartitions):" ) do
+      (n/5).times do
+        SignPartitions.partition(arrL)
+        SignPartitions.partition(arrL)
+        SignPartitions.partition(arrL)
+        SignPartitions.partition(arrL)
+        SignPartitions.partition(arrL)
+      end
+    end
+    # + 17% faster (relative to SignPartitions)
+    x.report("#{n} times (raw code):" ) do
+      n.times do
+        parts = []
+        p = arrL.inject(nil) do |partition, element|
+          if partition && (partition[0] > 0 && element > 0 || partition[0] < 0 && element < 0)
+            partition << element
+            partition
+          else
+            parts << partition if partition
+            [element]
+          end
+        end
+        parts << p if p
+      end
+    end
+  end
+end

data/lib/util/util.rb

@@ -0,0 +1,38 @@
+module StrokeDB
+  module Util
+
+    class ::Object
+      # Uses references to documents (compared to to_raw using hashes instead)
+      def to_optimized_raw
+        case self
+        when Array
+          map{|v| v.to_optimized_raw }
+        when Hash
+          new_hash = {}
+          each_pair{|k,v| new_hash[k.to_optimized_raw] = v.to_optimized_raw}
+          new_hash
+        else
+          self
+        end
+      end
+    end
+
+    unless RUBY_PLATFORM =~ /java/
+      require 'uuidtools'
+      def self.random_uuid
+        ::UUID.random_create.to_s
+      end
+    end
+
+    class CircularReferenceCondition < Exception ; end
+    class << self
+      def catch_circular_reference(value,name = 'StrokeDB.reference_stack')
+        stack = Thread.current[name] ||= []
+        raise CircularReferenceCondition if stack.find{|v| value == v}
+        stack << value
+        yield
+        stack.pop
+      end
+    end
+  end
+end

data/lib/util/xml.rb

@@ -0,0 +1,6 @@
+class Object #:nodoc:
+  def to_xml(options = {})
+    xml = options[:builder]
+    xml.tag!(options[:root], options[:skip_types] ? {} : {:type => self.class.to_s.underscore},to_s)
+  end
+end

data/lib/view/view.rb

@@ -0,0 +1,55 @@
+module StrokeDB
+  View = Meta.new(:uuid => VIEW_UUID) do
+    attr_accessor :map_with_proc
+    attr_reader :reduce_with_proc
+
+    on_initialization do |view|
+      view.map_with_proc = proc {|doc, *args| doc } 
+    end
+
+    def reduce_with(&block)
+      @reduce_with_proc = block
+      self
+    end
+
+    def map_with(&block)
+      @map_with_proc = block
+      self
+    end
+
+    def emit(*args) 
+      ViewCut.new(store, :view => self, :args => args, :timestamp_state => LTS.zero.counter).emit
+    end
+
+  end
+  ViewCut = Meta.new(:uuid => VIEWCUT_UUID) do
+
+    on_new_document do |cut|
+      cut.instance_eval do
+        if view.is_a?(View)
+          @map_with_proc = view.map_with_proc
+          @reduce_with_proc = view.reduce_with_proc
+        end
+      end
+    end
+
+    before_save do |cut|
+      view = cut.view
+      view.last_cut = cut if view[:last_cut].nil? or (cut[:previous] && view.last_cut == cut.previous)
+      view.save!
+    end
+
+
+    def emit
+      mapped = []
+      store.each(:after_timestamp => timestamp_state, :include_versions => view[:include_versions]) do |doc| 
+        mapped << @map_with_proc.call(doc,*args) 
+      end
+      documents = (@reduce_with_proc ? mapped.select {|doc| @reduce_with_proc.call(doc,*args) } : mapped).map{|d| d.is_a?(Document) ? d.extend(VersionedDocument) : d}
+      ViewCut.new(store, :documents => documents, :view => view, :args => args, :timestamp_state => store.timestamp.counter, :previous => timestamp_state == 0 ? nil : self)
+    end
+    def to_a
+      documents
+    end
+  end
+end