eternity 0.0.1

data/lib/eternity/commit.rb

@@ -0,0 +1,151 @@
+module Eternity
+  class Commit
+
+    attr_reader :id
+
+    def initialize(id)
+      @id = id
+    end
+
+    def short_id
+      id ? id[0,7] : nil
+    end
+
+    def time
+      Time.parse(data['time']) if data['time']
+    end
+
+    def author
+      data['author']
+    end
+
+    def message
+      data['message']
+    end
+
+    def parent_ids
+      data['parents'] || [nil]
+    end
+
+    def parents
+      parent_ids.map { |id| Commit.new id }
+    end
+
+    def with_index
+      index = data['index'] ? Index.read_blob(data['index']) : Index.new
+      yield index
+    ensure
+      index.destroy if index
+    end
+
+    def delta
+      data['delta'] ? Blob.read(:delta, data['delta']) : {}
+    end
+
+    def base
+      Commit.new data['base']
+    end
+
+    def base_delta
+      data['base_delta'] ? Blob.read(:delta, data['base_delta']) : {}
+    end
+
+    def history_times
+      data['history_times'] ? Blob.read(:history_times, data['history_times']) : {}
+    end
+
+    def history
+      history_times.sort_by { |id, time| time }
+                   .map { |id, time| Commit.new id }
+                   .reverse
+    end
+
+    def fast_forward?(commit)
+      return commit.nil? if first?
+      parent_ids.any? { |id| id == commit.id } || parents.map { |c| c.fast_forward?(commit) }.inject(:|)
+    end
+
+    def base_history_at(commit)
+      return [] unless commit
+      history = [base]
+      history += base.base_history_at commit unless base.id == commit.id
+      raise "History not include commit #{commit.id}" unless history.map(&:id).include? commit.id
+      history
+    end
+
+    def first?
+      parent_ids.compact.empty?
+    end
+
+    def merge?
+      parent_ids.count == 2
+    end
+
+    def nil?
+      id.nil?
+    end
+
+    def ==(commit)
+      commit.class == self.class && 
+      commit.id == id
+    end
+    alias_method :eql?, :==
+
+    def self.create(options)
+      raise 'Author must be present' if options[:author].to_s.strip.empty?
+      raise 'Message must be present' if options[:message].to_s.strip.empty?
+
+      history_times = options[:parents].compact.each_with_object({}) do |id, hash|
+        commit = Commit.new id
+        hash.merge! id => commit.time
+        hash.merge! commit.history_times
+      end
+
+      data = {
+        time:          options.fetch(:time) { Time.now },
+        author:        options.fetch(:author),
+        message:       options.fetch(:message),
+        parents:       options.fetch(:parents),
+        index:         options.fetch(:index),
+        delta:         options.fetch(:delta),
+        base:          options[:parents].count == 2 ? options.fetch(:base) : options[:parents].first,
+        base_delta:    options[:parents].count == 2 ? options.fetch(:base_delta) : options.fetch(:delta),
+        history_times: Blob.write(:history_times, history_times)
+      }
+
+      new Blob.write(:commit, data)
+    end
+
+    def self.base_of(commit_1, commit_2)
+      history_1 = [commit_1.id]
+      history_2 = [commit_2.id]
+
+      base_1 = commit_1
+      base_2 = commit_2
+
+      while (history_1 & history_2).empty?
+        base_1 = base_1.base if base_1
+        base_2 = base_2.base if base_2
+        
+        history_1 << base_1.id if base_1
+        history_2 << base_2.id if base_2
+      end
+
+      Commit.new (history_1 & history_2).first
+    end
+
+    def self.exists?(id)
+      Blob.read :commit, id
+      true
+    rescue
+      false
+    end
+
+    private
+
+    def data
+      @data ||= id ? Blob.read(:commit, id) : {}
+    end
+
+  end
+end

data/lib/eternity/conflict_resolver.rb

@@ -0,0 +1,40 @@
+module Eternity
+  class ConflictResolver
+
+    Diff = Struct.new :added, :updated, :removed
+
+    attr_reader :current, :target, :base
+    
+    def initialize(current, target, base={})
+      @current = current
+      @target = target
+      @base = base
+    end
+
+    def resolve
+      current_diff = diff current, base
+      target_diff = diff target, base
+      merge(target_diff, target, merge(current_diff, current, base))
+    end
+
+    def self.resolve(current, target, base={})
+      new(current, target, base).resolve
+    end
+
+    private
+
+    def diff(object, base)
+      Diff.new object.keys - base.keys,
+               base.keys.select { |k| base[k] != object[k] },
+               base.keys - object.keys
+    end
+
+    def merge(diff, object, base)
+      base.dup.tap do |result|
+        (diff.added + diff.updated).each { |k| result[k] = object[k] }
+        diff.removed.each { |k| result.delete k }
+      end
+    end
+
+  end
+end

data/lib/eternity/delta.rb

@@ -0,0 +1,45 @@
+module Eternity
+  class Delta
+    class << self
+
+      def union(deltas)
+        deltas.each_with_object({}) do |delta, hash|
+          delta.each do |collection, elements|
+            hash[collection] ||= {}
+            elements.each do |id, change|
+              hash[collection][id] ||= []
+              hash[collection][id] << change
+            end
+          end
+        end
+      end
+
+      def merge(deltas)
+        union(deltas).each_with_object({}) do |(collection, elements), hash|
+          hash[collection] = {}
+          elements.each do |id, changes|
+            change = TrackFlatter.flatten changes
+            hash[collection][id] = TrackFlatter.flatten changes if change
+          end
+        end
+      end
+
+      def revert(delta, commit)
+        commit.with_index do |index|
+          delta.each_with_object({}) do |(collection, changes), hash|
+            hash[collection] = {}
+            changes.each do |id, change|
+              hash[collection][id] = 
+                case change['action']
+                  when INSERT then {'action' => DELETE}
+                  when UPDATE then {'action' => UPDATE, 'data' => index[collection][id].data}
+                  when DELETE then {'action' => INSERT, 'data' => index[collection][id].data}
+                end
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/eternity/index.rb

@@ -0,0 +1,29 @@
+module Eternity
+  class Index < Restruct::NestedHash.new(CollectionIndex)
+
+    def initialize
+      super redis: Eternity.redis,
+            id: Eternity.keyspace[:index][SecureRandom.uuid]
+    end
+
+    def apply(delta)
+      delta.each do |collection, elements|
+        elements.each do |id, change|
+          args = [id, change['data']].compact
+          self[collection].send change['action'], *args
+        end
+      end
+    end
+
+    def write_blob
+      Blob.write :index, dump
+    end
+
+    def self.read_blob(sha1)
+      Index.new.tap do |index|
+        index.restore Blob.read :index, sha1
+      end
+    end
+
+  end
+end

data/lib/eternity/log.rb

@@ -0,0 +1,22 @@
+module Eternity
+  module Log
+
+    private
+
+    def log(method)
+      original_method = "__#{method}_without_log__"
+
+      alias_method original_method, method
+
+      define_method method do |*args, &block|
+        Eternity.logger.info(self.class.name) { "#{method} (Start)" }
+        result = send original_method, *args, &block
+        Eternity.logger.info(self.class.name) { "#{method} (End)" }
+        result
+      end
+
+      private original_method
+    end
+
+  end
+end

data/lib/eternity/object_tracker.rb

@@ -0,0 +1,57 @@
+module Eternity
+  class ObjectTracker
+
+    extend Forwardable
+    def_delegators :changes, :to_a, :to_primitive, :count, :each, :destroy
+
+    def initialize(options)
+      @changes = Restruct::MarshalArray.new options
+    end
+
+    def insert(data)
+      track INSERT, data
+    end
+
+    def update(data)
+      track UPDATE, data
+    end
+
+    def delete
+      track DELETE
+    end
+
+    def revert
+      locker.lock! :revert do
+        changes.destroy
+      end
+    end
+
+    def flatten
+      TrackFlatter.flatten changes
+    end
+
+    private
+
+    attr_reader :changes
+
+    def track(action, data=nil)
+      locker.lock :track do
+        change = {'action' => action}
+        change['blob'] = Blob.write(:data, data) if data
+
+        Eternity.logger.debug(self.class) { "#{changes.id} - #{change} - #{data}" }
+        
+        changes << change
+      end
+    end
+
+    def locker
+      Locky.new repository_name, Eternity.locker_storage
+    end
+
+    def repository_name
+      changes.id.sections.reverse[3]
+    end
+
+  end
+end

data/lib/eternity/patch.rb

@@ -0,0 +1,129 @@
+module Eternity
+  module Patch
+
+    def self.merge(current_commit, target_commit)
+      Merge.new current_commit, target_commit
+    end
+
+    def self.diff(current_commit, target_commit)
+      Diff.new current_commit, target_commit
+    end
+
+    module Common
+
+      attr_reader :current_commit, :target_commit
+
+      def initialize(current_commit, target_commit)
+        @current_commit = current_commit
+        @target_commit = target_commit
+      end
+
+      def base_commit
+        @base_commit ||= Commit.base_of current_commit, target_commit
+      end
+
+      def delta 
+        @delta ||= TransparentProxy.new { calculate_delta }
+      end
+
+      private
+
+      def current_delta
+        @current_delta ||= base_delta_of current_commit, base_commit
+      end
+
+      def target_delta
+        @target_delta ||= base_delta_of target_commit, base_commit
+      end
+
+      def base_delta_of(commit, base)
+        return {} if commit == base
+        history = [commit] + commit.base_history_at(base)[0..-2]
+        Delta.merge history.reverse.map(&:base_delta)
+      end
+
+    end
+
+
+    class Merge
+      
+      extend Log
+      include Common
+
+      def base_delta
+        @base_delta ||= merged? ? {} : Delta.merge([current_delta, delta])
+      end
+
+      def merged?
+        @merged ||= current_commit == target_commit ||
+                    target_commit.fast_forward?(current_commit) || 
+                    current_commit.fast_forward?(target_commit)
+      end
+
+      private
+
+      def calculate_delta
+        return {} if merged?
+
+        base_commit.with_index do |base_index|
+          target_delta.each_with_object({}) do |(collection, elements), hash|
+            hash[collection] = {}
+           
+            elements.each do |id, change|
+              if change['action'] == INSERT && current_action_for(collection, id) == INSERT
+                data = ConflictResolver.resolve current_delta[collection][id]['data'], 
+                                                change['data']
+                change = {'action' => UPDATE, 'data' => data}
+              
+              elsif change['action'] == UPDATE
+                if current_action_for(collection, id) == UPDATE
+                  data = ConflictResolver.resolve current_delta[collection][id]['data'], 
+                                                  change['data'], 
+                                                  base_index[collection][id].data
+                  change = change.merge 'data' => data
+                elsif current_action_for(collection, id) == DELETE
+                  change = {'action' => INSERT, 'data' => change['data']}
+                end
+              
+              elsif change['action'] == DELETE && current_action_for(collection, id) == DELETE
+                change = nil
+              end
+
+              hash[collection][id] = change if change
+            end
+
+            hash.delete collection if hash[collection].empty?
+          end
+        end
+      end
+
+      def has_current_changes_for?(collection, id)
+        current_delta.key?(collection) && current_delta[collection].key?(id)
+      end
+
+      def current_action_for(collection, id)
+        current_delta[collection][id]['action'] if has_current_changes_for? collection, id
+      end
+
+      log :calculate_delta
+
+    end
+
+
+    class Diff
+      
+      extend Log
+      include Common
+
+      private
+
+      def calculate_delta
+        Delta.merge [Delta.revert(current_delta, base_commit), target_delta]
+      end
+
+      log :calculate_delta
+
+    end
+
+  end
+end