strokedb 0.0.2

data/lib/sync/stroke_diff/array.rb

@@ -0,0 +1,102 @@
+module StrokeDB
+  class ::Array
+    SDATPTAGS = {
+      '-' => PATCH_MINUS,
+      '+' => PATCH_PLUS,
+      '!' => PATCH_DIFF
+    }.freeze
+    def stroke_diff(to)
+      return super(to) unless Array === to
+      return nil if self == to
+      
+      # sdiff:  +   -   !   = 
+      lcs_sdiff = ::Diff::LCS.sdiff(self, to)
+      patchset = lcs_sdiff.inject([]) do |patchset, change|
+        a = SDATPTAGS[change.action]
+        if a == PATCH_DIFF
+          patchset << [a, change.new_position, change.old_element.stroke_diff(change.new_element)]
+        elsif a == PATCH_MINUS
+          patchset << [a, change.new_position]
+        elsif a == PATCH_PLUS
+          patchset << [a, change.new_position, change.new_element]
+        end
+        patchset
+      end
+      patchset.empty? ? nil : patchset
+    end
+    
+    def stroke_patch(patch)
+      return self unless patch
+      return patch[1] if patch[0] == PATCH_REPLACE
+      res = self.dup
+      patch.each do |change|
+        _stroke_elementary_patch(res, change[1], change)
+      end
+      res
+    end
+    
+    def stroke_merge(patch1, patch2)
+      unless patch1 && patch2
+        return _stroke_automerged(stroke_patch(patch1 || patch2))
+      end
+      
+      patch1 = patch1.dup
+      patch2 = patch2.dup
+      
+      c1 = patch1.shift
+      c2 = patch2.shift
+      
+      offset1 = 0
+      offset2 = 0
+      result = self.dup
+      result1 = nil
+      result2 = nil
+      
+      while c1 && c2
+        while c1 && (p1 = c1[1] + offset1) && (p2 = c2[1] + offset2) && p1 < p2
+          offset2 += _stroke_elementary_patch(result, p1, c1)
+          c1 = patch1.shift
+        end
+        
+        if p1 == p2
+          raise "TODO conflict resolution!"
+          
+          c1 = patch1.shift
+        end
+        
+        while c1 && c2 && (p1 = c1[1] + offset1) && (p2 = c2[1] + offset2) && p2 < p1
+          offset1 += _stroke_elementary_patch(result, p2, c2)
+          c2 = patch2.shift
+        end
+      end
+
+      # Tail (one of two) 
+      while c1
+        offset2 += _stroke_elementary_patch(result, c1[1] + offset1, c1)
+        c1 = patch1.shift
+      end
+      while c2
+        offset1 += _stroke_elementary_patch(result, c2[1] + offset2, c2)
+        c2 = patch2.shift
+      end
+      result ? _stroke_automerged(result) : _stroke_conflicted(result1, result2)
+    end
+    
+  private
+    def _stroke_elementary_patch(result, pos, change)
+      a = change[0]
+      case a
+      when PATCH_MINUS
+        result.delete_at(pos)
+        -1
+      when PATCH_PLUS
+        result[pos, 0] = [change[2]]
+        +1
+      when PATCH_DIFF
+        result[pos] = result[pos].stroke_patch(change[2])
+        0
+      end
+    end
+      
+  end
+end

data/lib/sync/stroke_diff/default.rb

@@ -0,0 +1,21 @@
+module StrokeDB
+  class ::Object
+    def stroke_diff(to)
+      self == to ? nil : [PATCH_REPLACE, to]
+    end
+    def stroke_patch(patch)
+      patch ? patch[1] : self
+    end
+    def stroke_merge(patch1, patch2) # => is_conflict, result1, result2
+      r1 = self.stroke_patch(patch1)
+      r2 = self.stroke_patch(patch2)
+      [r1 != r2, r1, r2]
+    end
+    def _stroke_automerged(r)
+      [false, r, r]
+    end
+    def _stroke_conflicted(r1, r2)
+      [true, r1, r2]
+    end
+  end
+end

data/lib/sync/stroke_diff/hash.rb

@@ -0,0 +1,186 @@
+module StrokeDB
+  class ::Hash
+    def stroke_diff(to)
+      return super(to) unless Hash === to
+      return nil if self == to
+      
+      all_keys = self.keys | to.keys
+      
+      deleted_slots  = []
+      inserted_slots = {}
+      diffed_slots   = {}
+      
+      all_keys.each do |k|
+        unless to.key?(k)
+          deleted_slots << k
+        else
+          unless self.key?(k)
+            inserted_slots[k] = to[k] 
+          else
+            diff = self[k].stroke_diff(to[k]) 
+            diffed_slots[k] = diff if diff
+          end
+        end
+      end
+      [deleted_slots, inserted_slots, diffed_slots]
+    end
+    
+    def stroke_patch(patch)
+      return self unless patch
+      return patch[1] if patch[0] == PATCH_REPLACE
+      res = self.dup
+      deleted_slots, inserted_slots, diffed_slots = patch
+      deleted_slots.each {|k| res.delete(k) }
+      res.merge!(inserted_slots)
+      diffed_slots.each {|k,v| res[k] = self[k].stroke_patch(v) }
+      res
+    end
+    
+    # Hash conflict may occur:
+    # 1) If key accures in conflicting groups 
+    #    (e.g. deleted v.s. inserted, deleted vs. diffed)
+    # 2) If slot diff yields conflict
+    #
+    def stroke_merge(patch1, patch2)
+      unless patch1 && patch2
+        return _stroke_automerged(stroke_patch(patch1 || patch2))
+      end
+      
+      del1, ins1, dif1 = patch1[0].dup, patch1[1].dup, patch1[2].dup
+      del2, ins2, dif2 = patch2[0].dup, patch2[1].dup, patch2[2].dup
+      
+      # TEMPORARY: inconsistency check
+      conflict_d1i2 = del1 & ins2.keys
+      conflict_d2i1 = del2 & ins1.keys
+      conflict_i1f2 = ins1.keys & dif2.keys
+      conflict_i2f1 = ins2.keys & dif1.keys
+      
+      unless conflict_d1i2.empty? && conflict_d2i1.empty? && 
+             conflict_i1f2.empty? && conflict_i2f1.empty? 
+        raise "Fatal inconsistency on stroke_merge detected!"
+      end
+      
+      overlapping_keys = ((del1 + ins1.keys + dif1.keys) & 
+                          (del2 + ins2.keys + dif2.keys))
+      # make hash for faster inclusion tests
+      overlapping_keys_hash = overlapping_keys.inject({}) do |h, k|
+        h[k] = 1; h
+      end
+      
+      result  = self.dup
+      
+      # 1. Merge non-overlapping updates
+      (del1 + del2 - overlapping_keys).each do |k|
+        del1.delete(k)
+        del2.delete(k)
+        result.delete(k)
+      end
+      ins1.dup.each do |k, v|
+        unless overlapping_keys_hash[k]
+          result[k] = v 
+          ins1.delete(k)
+        end
+      end
+      ins2.dup.each do |k, v|
+        unless overlapping_keys_hash[k]
+          result[k] = v 
+          ins2.delete(k)
+        end
+      end
+      dif1.dup.each do |k, diff|
+        unless overlapping_keys_hash[k]
+          result[k] = stroke_patch(diff)
+          dif1.delete(k)
+        end
+      end
+      dif2.dup.each do |k, diff|
+        unless overlapping_keys_hash[k]
+          result[k] = stroke_patch(diff)
+          dif2.delete(k)
+        end
+      end
+    
+      # 2. Resolve overlapping keys
+      #
+      # Overlapping key may be in such pairs:
+      #
+      #  [dif, dif] <- possible conflict
+      #  [dif, ins] <- anomaly
+      #  [ins, ins] <- possible conflict
+      #  [del, ins] <- anomaly
+      #  [del, dif] <- conflict
+      #  [del, del] <- not a conflict
+      #
+      #  (and in reverse order as well)
+      
+      result1 = nil
+      result2 = nil
+      del1.each do |k|
+        if ins2.key?(k)
+          raise "Fatal inconsistency on stroke_merge detected: delete + insert"
+        elsif dif2.key?(k) 
+          # Conflict. Split result if not splitted.
+          result1, result2, result = _stroke_split_merge_result(result) if result
+          result1.delete(k)
+          result2[k] = result2[k].stroke_patch(dif2[k])
+        else # [del, del]
+          if result
+            result.delete(k)
+          else
+            result1.delete(k)
+            result2.delete(k)
+          end
+        end
+      end
+      dif1.each do |k, diff|
+        if ins2.key?(k)
+          raise "Fatal inconsistency on stroke_merge detected: diff + insert"
+        elsif dif2.key?(k) # possible conflict
+          conflict, r1, r2 = self[k].stroke_merge(diff, dif2[k])
+          if conflict
+            result1, result2, result = _stroke_split_merge_result(result) if result
+            result1[k] = r1
+            result2[k] = r2
+          else
+            if result
+              result[k] = r2
+            else
+              result1[k] = r2
+              result2[k] = r2
+            end
+          end
+        else # [dif, del] <- conflict
+          # Conflict. Split result if not splitted.
+          result1, result2, result = _stroke_split_merge_result(result) if result
+          result1[k] = result1[k].stroke_patch(diff)
+          result2.delete(k)
+        end
+      end
+      ins1.each do |k, obj|
+        if ins2.key?(k) # possible conflict
+          if obj != ins2[k]
+            result1, result2, result = _stroke_split_merge_result(result) if result
+            result1[k] = obj
+            result2[k] = ins2[k]
+          else
+            if result
+              result[k] = obj
+            else
+              result1[k] = obj
+              result2[k] = obj
+            end
+          end
+        else # delete or diff
+          raise "Fatal inconsistency on stroke_merge detected: insert + (delete|diff)"
+        end
+      end
+      
+      result ? _stroke_automerged(result) : _stroke_conflicted(result1, result2)
+    end
+    
+    # In case of conflict, result is copied to result{1,2} and nullified.
+    def _stroke_split_merge_result(result)
+      return [result.dup, result.dup, nil]
+    end
+  end
+end

data/lib/sync/stroke_diff/string.rb

@@ -0,0 +1,116 @@
+module StrokeDB
+  class ::String
+    def stroke_diff(to)
+      return super(to) unless String === to
+      return nil if self == to
+      
+      _f = self[0,2]
+      _t = to[0,2]
+      pfx = "@#"
+      # both are refs
+      return super(to) if _f == _t && _t == pfx
+      # one of items is ref, another is not.
+      return super(to) if _f == pfx || _t == pfx
+            
+      lcs_diff = ::Diff::LCS.diff(self, to)
+      patchset = lcs_diff.map do |changes| 
+        parts = []
+        last_part = changes.inject(nil) do |part, change|
+          if part && part[0] == change.action && part[3] == change.position - 1
+            part[3] += 1
+            part[2] << change.element
+            part
+          else
+            parts << part if part
+            # emit
+            [change.action, change.position, change.element, change.position]
+          end
+        end
+        parts << last_part if last_part
+        parts.empty? ? nil : parts
+      end.compact.inject([]) do |patches, ps|
+        ps.map do |p|
+          patches << if p[0] == '+'
+            [PATCH_PLUS,  p[1], p[2]]      # [+  position_in_b  substr]
+          else
+            [PATCH_MINUS, p[1], p[2].size] # [-  position_in_a  length]
+          end
+        end
+        patches
+      end
+      #p patchset
+      patchset.empty? ? nil : patchset
+    end
+    
+    def stroke_patch(patch)
+      return self unless patch
+      return patch[1] if patch[0] == PATCH_REPLACE
+      
+      # Patch is a list of insertions and deletions.
+      # Deletion is indexed relative to base.
+      # Insertion is indexed relative to new string.
+      res = ""
+      ai = bj = 0
+      patch.each do |change|
+        action, position, element = change
+        case action
+        when PATCH_MINUS
+          d = position - ai
+          if d > 0
+            res << self[ai, d]
+            ai += d
+            bj += d
+          end
+          ai += element # element == length
+        when PATCH_PLUS
+          d = position - bj
+          if d > 0
+            res << self[ai, d]
+            ai += d
+            bj += d
+          end
+          bj += element.size
+          res << element
+        end
+      end
+      d = self.size - ai
+      res << self[ai, d] if d > 0
+      res
+    end
+    
+    def stroke_merge(patch1, patch2)
+      # One patch is missing (i.e. no changes)
+      unless patch1 && patch2
+        return _stroke_automerged(stroke_patch(patch1 || patch2))
+      end
+
+      # Patch could be either PATCH_REPLACE or regular string diff.
+      # Thus, 4 cases:
+      #
+      # [replace, replace] -> possible conflict
+      # [replace, diff]    -> conflict
+      # [diff,    replace] -> conflict
+      # [diff,    diff]    -> possible conflict
+
+      # Code is verbose to be fast and clear
+      if patch1[0] == PATCH_REPLACE
+        if patch2[0] == PATCH_REPLACE # [replace, replace]
+          if patch1[1] != patch2[1]
+            return _stroke_conflicted(stroke_patch(patch1), stroke_patch(patch2))
+          else
+            return _stroke_automerged(stroke_patch(patch1))
+          end
+        else # [replace, diff]
+           return _stroke_conflicted(stroke_patch(patch1), stroke_patch(patch2))
+        end
+      else
+        if patch1[0] == PATCH_REPLACE # [diff, replace]
+          return _stroke_conflicted(stroke_patch(patch1), stroke_patch(patch2))
+        else
+          nil # [diff, diff] - see below
+        end
+      end
+	  # TODO: ...
+    end
+  end
+end

data/lib/sync/stroke_diff/stroke_diff.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'diff/lcs'
+
+module StrokeDB
+  PATCH_REPLACE = 'R'.freeze
+  PATCH_PLUS    = '+'.freeze
+  PATCH_MINUS   = '-'.freeze
+  PATCH_DIFF    = 'D'.freeze
+end

data/lib/util/blankslate.rb

@@ -0,0 +1,42 @@
+unless defined?(BlankSlate)
+  class BlankSlate < BasicObject; end if defined?(BasicObject)
+
+  class BlankSlate
+    instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+  end
+end
+
+class BlankSlate
+  MethodMapping = {
+    '[]' => 'squarebracket',
+    '[]=' => 'squarebracket_set',
+    '<<' => 'leftarrow',
+    '*' => 'star',
+    '+' => 'plus',
+    '-' => 'minus',
+    '&' => 'bitwiseand',
+    '|' => 'bitwiseor',
+    '<=>' => 'spaceship',
+    '==' => 'equalequal',
+    '===' => 'tripleequal',
+    '=~' => 'regexmatch',
+    '`'  => 'backtick',
+  } unless defined? MethodMapping
+end
+
+def BlankSlate superclass = nil
+  if superclass
+    (@blank_slates ||= {})[superclass] ||= Class.new(superclass) do
+      instance_methods.sort.each { |m|
+        unless m =~ /^__/
+          mname = "__#{::BlankSlate::MethodMapping[m.to_s] || m}"
+          class_eval "alias :'#{mname}' :'#{m}'" 
+          
+          undef_method m
+        end
+      }
+    end
+  else
+    BlankSlate
+  end
+end

data/lib/util/ext/blank.rb

@@ -0,0 +1,50 @@
+class Object
+  # An object is blank if it's nil, empty, or a whitespace string.
+  # For example, "", "   ", nil, [], and {} are blank.
+  #
+  # This simplifies
+  #   if !address.nil? && !address.empty?
+  # to
+  #   if !address.blank?
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+end
+
+class NilClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class FalseClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class TrueClass #:nodoc:
+  def blank?
+    false
+  end
+end
+
+class Array #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class Hash #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class String #:nodoc:
+  def blank?
+    self !~ /\S/
+  end
+end
+
+class Numeric #:nodoc:
+  def blank?
+    false
+  end
+end

data/lib/util/ext/enumerable.rb

@@ -0,0 +1,36 @@
+# extracted from ActiveRecord (http://rubyforge.org/projects/activesupport/)
+
+module Enumerable
+  # Collect an enumerable into sets, grouped by the result of a block. Useful,
+  # for example, for grouping records by date.
+  def group_by
+    inject({}) do |groups, element|
+      (groups[yield(element)] ||= []) << element
+      groups
+    end
+  end if RUBY_VERSION < '1.9'
+
+  # Map and each_with_index combined.
+  def map_with_index
+    collected=[]
+    each_with_index {|item, index| collected << yield(item, index) }
+    collected
+  end
+
+  alias :collect_with_index :map_with_index
+
+  def each_consecutive_pair
+    first = true
+    prev = nil
+
+    each do |val|
+      unless first
+        yield prev, val
+      else
+        first = false
+      end
+
+      prev = val
+    end
+  end
+end

data/lib/util/ext/fixnum.rb

@@ -0,0 +1,16 @@
+# extracted and adapted from ActiveSupport (http://rubyforge.org/projects/activesupport/)
+
+class Fixnum
+  def multiple_of?(number)
+    self % number == 0
+  end
+  
+  def even?
+    multiple_of? 2
+  end
+  
+  def odd?
+    !even?
+  end
+end
+

data/lib/util/ext/hash.rb

@@ -0,0 +1,22 @@
+# extracted and adapted from ActiveRecord (http://rubyforge.org/projects/activesupport/)
+
+class Hash
+  def stringify_keys
+    inject({}) do |options, (key, value)|
+      options[key.to_s] = value
+      options
+    end
+  end
+
+  def except(*keys)
+    reject { |key,| keys.include?(key.to_sym) or keys.include?(key.to_s) }
+  end
+
+  def reverse_merge(other_hash)
+    other_hash.merge(self)
+  end
+
+  def reverse_merge!(other_hash)
+    replace(reverse_merge(other_hash))
+  end
+end

data/lib/util/ext/object.rb

@@ -0,0 +1,8 @@
+# extracted from ActiveRecord (http://rubyforge.org/projects/activesupport/)
+
+class Object
+  unless respond_to?(:send!)
+    # Anticipating Ruby 1.9 neutering send
+    alias send! send
+  end
+end

data/lib/util/ext/string.rb

@@ -0,0 +1,35 @@
+# extracted and adapted from ActiveRecord (http://rubyforge.org/projects/activesupport/)
+
+class String
+  def ends_with?(suffix)
+    suffix = suffix.to_s
+    self[-suffix.length, suffix.length] == suffix
+  end
+
+  def camel_case
+    split('_').map{|e| e.capitalize}.join
+  end
+  alias :camelize :camel_case
+
+  def snake_case
+    gsub(/\B[A-Z][^A-Z]/, '_\&').downcase.gsub(' ', '_')
+  end
+
+  def tableize
+    words = snake_case.split('_')
+    words.last.replace words.last.plural
+    words.join('_')
+  end
+
+  def demodulize
+    gsub(/^.*::/, '')
+  end
+
+  def constantize
+    unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ self
+      raise NameError, "#{self.inspect} is not a valid constant name!"
+    end
+
+    Object.module_eval("::#{$1}", __FILE__, __LINE__)
+  end
+end