meangirls 0.1.0

data/lib/meangirls/lww_set.rb

@@ -0,0 +1,168 @@
+class Meangirls::LWWSet < Meangirls::Set
+  require 'time'
+
+  class Pair
+    attr_accessor :add, :remove
+    def initialize(add, remove)
+      @add = add
+      @remove = remove
+    end
+
+    def ==(o)
+      o.kind_of? Pair and
+      add == o.add and
+      remove == o.remove
+    end
+
+    def exists_a?
+      return false unless @add
+      return true unless @remove
+      @add >= @remove
+    end
+    
+    def exists_r?
+      return false unless @add
+      return true unless @remove
+      @add > @remove
+    end
+
+    def inspect
+      "(#{add.inspect}, #{remove.inspect})"
+    end
+
+    # Merge with another pair, taking the largest add and largest delete stamp.
+    def merge(other)
+      unless other
+        return clone
+      end
+
+      Pair.new(
+        [add, other.add].compact.max, 
+        [remove, other.remove].compact.max
+      )
+    end
+    alias | merge
+  end
+
+  def self.biases
+    ['a', 'r']
+  end
+
+  attr_accessor :e
+  attr_accessor :bias
+  def initialize(hash = nil)
+    @e = {}
+    @bias = 'a'
+
+    if hash
+      raise ArgumentError, "hash must contain e" unless hash['e']
+      @bias = hash['bias'] if hash['bias']
+      hash['e'].each do |list|
+        element, add, delete = list
+        @e[element] = Pair.new(add, delete).merge(@e[element])
+      end    
+    end
+  end
+
+  # Inserts e into the set with a default generated timestamp.
+  # Your clocks ARE synchronized, right? WRONG!
+  def <<(e)
+    add(e, timestamp)
+  end
+
+  # Strict equality: both adds and removes are equal.
+  def ==(other)
+    other.kind_of? self.class and
+    e == other.e
+  end
+
+  # Add e, with an optional timestamp.
+  def add(e, time = timestamp)
+    merge_element! e, Pair.new(time, nil)
+    self
+  end
+
+  def as_json
+    {
+      'type' => type,
+      'e' => @e.map { |e, pair|
+        [e, pair.add, pair.remove]
+      }
+    }
+  end
+
+  def clone
+    c = super
+    c.e = e.clone
+    c
+  end
+
+  # Delete e from self, with optional timestamp.
+  def delete(e, time = timestamp)
+    merge_element! e, Pair.new(nil, time)
+    e
+  end
+
+  # Is e an element of the set?
+  def include?(e)
+    return false unless pair = @e[e]
+    case bias
+      when 'a'
+        pair.exists_a?
+      when 'r'
+        pair.exists_r?
+      else
+        raise RuntimeError, "unsupported bias #{bias.inspect}"
+     end
+  end
+
+  # Merge with another lww-set
+  def merge(other)
+    unless other.kind_of? self.class
+      raise ArgumentError, "other must be a #{self.class}"
+    end
+
+    c = clone
+    other.e.each do |element, pair|
+      c.merge_element!(element, pair)
+    end
+    c
+  end
+
+  # Mutates self to update the value for e with the given pair.
+  def merge_element!(e, pair)
+    if cur = @e[e]
+      @e[e] = cur | pair
+    else
+      @e[e] = pair
+    end
+  end
+
+  def to_set
+    case bias
+      when 'a'
+        @e.inject(Set.new) do |s, l|
+          element, pair = l
+          s << element if pair.exists_a?
+          s
+        end
+      when 'r'
+        @e.inject(Set.new) do |s, l|
+          element, pair = l
+          s << element if pair.exists_r?
+          s
+        end
+    end
+  end
+
+  # Default timestamps are the present time in UTC as ISO 8601 strings, WITH a
+  # seconds fraction guaranteed to be unique and monotonically increasing for
+  # all use of Meangirls.
+  def timestamp
+    Meangirls.timestamp
+  end
+
+  def type
+    'lww-set'
+  end
+end

data/lib/meangirls/or_set.rb

@@ -0,0 +1,134 @@
+class Meangirls::ORSet < Meangirls::Set
+  class Pair
+    attr_accessor :adds, :removes
+    def initialize(adds = [], removes = [])
+      @adds = adds
+      @removes = removes
+    end
+
+    def to_s
+      inspect
+    end
+
+    def inspect
+      "(#{adds.inspect}, #{removes.inspect})"
+    end
+  end
+  
+  def self.biases
+    ['a']
+  end
+
+  attr_accessor :e
+  def initialize(hash = nil)
+    @e = {}
+
+    if hash
+      raise ArgumentError, 'hash must contain e' unless hash['e']
+      hash['e'].each do |list|
+        element, adds, removes = list
+        merge_internal! element, Pair.new(adds, removes)
+      end 
+    end
+  end
+
+  # Inserts e into the set.
+  def <<(e)
+    add e
+  end
+
+  # Strict equality: all adds/removes match for every element.
+  # TODO: slow
+  def ==(other)
+    other.kind_of? self.class and
+    (@e.keys | other.e.keys).all? do |e, pair|
+      a = @e[e] and b = other.e[e] and
+      uaeq(a.adds, b.adds) and
+      uaeq(a.removes, b.removes)
+    end
+  end
+
+  # Inserts e into the set. Tag will be randomly generated if not given.
+  def add(e, tag = Meangirls.tag)
+    pair = (@e[e] ||= Pair.new)
+    pair.adds |= [tag]
+    self
+  end
+
+  def as_json
+    {
+      'type' => type,
+      'e' => @e.map do |e, pair|
+        [e, pair.adds, pair.removes]
+      end
+    }
+  end
+
+  def bias
+    'a'
+  end
+
+  # UGH defensive copying
+  def clone
+    c = super
+    c.e = {}
+    @e.each do |e, pair|
+      c.merge_internal! e, pair.clone
+    end
+    c
+  end
+
+  # Deletes e from self by cancelling all known tags (or a specific tag if
+  # given.) Returns nil if no changes, e otherwise.
+  def delete(e, tag = nil)
+    pair = @e[e] or return
+    new = pair.adds - pair.removes
+    return if new.empty?
+    pair.removes += new
+    e
+  end
+
+  # Merge with another OR-Set and return the merged copy.
+  def merge(other)
+    unless other.kind_of? self.class
+      raise ArgumentError, "other must be a #{self.class}"
+    end
+
+    copy = clone
+    @e.each do |e, pair|
+      copy.merge_internal! e, pair
+    end
+    other.e.each do |e, pair|
+      copy.merge_internal! e, pair
+    end
+    copy
+  end
+
+  # Updates self with new adds and removes for an element.
+  def merge_internal!(element, pair)
+    if my = @e[element]
+      my.adds |= pair.adds
+      my.removes |= pair.removes
+    else
+      @e[element] = pair
+    end
+  end
+
+  def to_set
+    s = Set.new
+    @e.each do |element, pair|
+      s << element unless (pair.adds - pair.removes).empty?
+    end
+    s
+  end
+
+  def type
+    'or-set'
+  end
+
+  # Unordered array equality
+  # TODO: slow
+  def uaeq(a, b)
+    (a - b).empty? and (b - a).empty?
+  end
+end

data/lib/meangirls/set.rb

@@ -0,0 +1,63 @@
+class Meangirls::Set < Meangirls::CRDT
+  require 'meangirls/two_phase_set'
+  require 'meangirls/lww_set'
+  require 'meangirls/or_set'
+
+  include Enumerable
+
+  # Add all elements of other to a copy of self.
+  def |(other)
+    other.inject(clone) do |copy, e|
+      copy << e
+    end
+  end
+
+  # Return a copy of self where [all elements not present in other] have been
+  # deleted.
+  def &(other)
+    (to_set - other.to_set).inject(clone) do |copy, e|
+      copy.delete e
+      copy
+    end
+  end
+
+  # Add all elements of other to a copy of self.
+  def +(other)
+    other.inject(clone) do |copy, e|
+      copy << e
+    end
+  end
+
+  # Remove all elements of other from a copy of self.
+  def -(other)
+    other.inject(clone) do |copy, e|
+      copy.delete e
+      copy
+    end
+  end
+
+  # Loose equality: present elements of each set are equal
+  def ===(other)
+    to_set == other.to_set
+  end
+
+  # Iterate over all present elements
+  def each(&block)
+    to_set.each(&block)
+  end
+
+  # Are there no elements present?
+  def empty?
+    size == 0
+  end
+
+  # How many elements are present in the set?
+  def size
+    to_set.size
+  end
+
+  # Convert to an array  
+  def to_a
+    to_set.to_a
+  end
+end

data/lib/meangirls/two_phase_set.rb

@@ -0,0 +1,92 @@
+class Meangirls::TwoPhaseSet < Meangirls::Set
+  def self.biases
+    ['r']
+  end
+  
+  attr_accessor :a, :r
+  def initialize(hash = nil)
+    if hash
+      raise ArgumentError, "hash must contain a" unless hash['a']
+      raise ArgumentError, "hash must contain r" unless hash['r']
+
+      @a = Set.new hash['a']
+      @r = Set.new hash['r']
+    else
+      # Empty set
+      @a = Set.new
+      @r = Set.new
+    end
+  end
+
+  # Inserts e into the set. Raises ReinsertNotAllowed if e was previously
+  # deleted.
+  def <<(e)
+    if @r.include? e
+      raise Meangirls::ReinsertNotAllowed
+    end
+
+    @a << e
+    self
+  end
+  alias add <<
+
+  # Strict equality: both adds and removes for both 2p-sets are equal.
+  def ==(other)
+    other.kind_of? self.class and
+    a == other.a and
+    r == other.r
+  end
+
+  def as_json
+    {
+      'type' => type,
+      'a' => a.to_a,
+      'r' => r.to_a 
+    }
+  end
+
+  def bias
+    'r'
+  end
+
+  def clone
+    c = super
+    c.a = a.clone
+    c.r = r.clone
+    c
+  end
+
+  # Deletes e from self. Raises DeleteNotAllowed if e does not presently
+  # exist.
+  def delete(e)
+    unless @a.include? e
+      raise Meangirls::DeleteNotAllowed
+    end
+    @r << e
+    e
+  end
+ 
+  # Merge with another 2p-set.
+  def merge(other)
+    unless other.kind_of? self.class
+      raise ArgumentError, "other must be a #{self.class}"
+    end
+
+    self.class.new(
+      'a' => (a | other.a),
+      'r' => (r | other.r)
+    )
+  end
+
+  def include?(e)
+    @a.include? e and not @r.include? e
+  end
+
+  def to_set
+    @a - @r
+  end
+
+  def type
+    '2p-set'
+  end
+end