eternity 0.0.1

data/lib/eternity/repository.rb

@@ -0,0 +1,235 @@
+module Eternity
+  class Repository
+
+    extend Log
+
+    attr_reader :name, :id, :branches
+    
+    def initialize(name, options={})
+      @name = name.to_s
+      @id = Eternity.keyspace[:repository][@name]
+      @tracker = Tracker.new self
+      @current = Restruct::Hash.new redis: Eternity.redis, id: id[:current]
+      @branches = Restruct::Hash.new redis: Eternity.redis, id: id[:branches]
+      @locker = Locky.new @name, Eternity.locker_storage
+      @default_branch = options.fetch(:default_branch) { 'master' }.to_s
+    end
+
+    def [](collection)
+      tracker[collection]
+    end
+
+    def empty?
+      tracker.empty? && current.empty? && branches.empty?
+    end
+
+    def changes?
+      !tracker.empty?
+    end
+
+    def changes_count
+      tracker.count
+    end
+
+    def delta
+      tracker.flatten
+    end
+
+    def delta=(delta)
+      tracker.clear
+      delta.each do |collection, changes|
+        changes.each do |id, change|
+          args = [id, change['data']].compact
+          self[collection].send(change['action'], *args)
+        end
+      end
+    end
+
+    def current_commit?
+      current.key? :commit
+    end
+
+    def current_commit
+      Commit.new current[:commit]
+    end
+
+    def current_branch
+      current[:branch] || @default_branch
+    end
+
+    def commit(options)
+      raise 'Nothing to commit' unless changes?
+
+      locker.lock! :commit do
+        commit! message: options.fetch(:message), 
+                author:  options.fetch(:author),
+                time:    options.fetch(:time) { Time.now }
+      end
+    end
+
+    def branch(name)
+      raise "Can't branch without commit" unless current_commit?
+      raise "Can't branch with uncommitted changes" if changes?
+
+      branches[name] = current_commit.id
+    end
+
+    def checkout(options)
+      raise "Can't checkout with uncommitted changes" if changes?
+
+      locker.lock! :checkout do
+        original_commit = current_commit
+
+        commit_id, branch = extract_commit_and_branch options
+
+        if commit_id
+          raise "Invalid commit #{commit_id}" unless Commit.exists? commit_id
+          current[:commit] = commit_id
+          branches[branch] = commit_id
+        else
+          current.delete :commit
+          branches.delete branch
+        end
+
+        current[:branch] = branch
+
+        Patch.diff(original_commit, current_commit).delta
+      end
+    end
+
+    def merge(options)
+      raise "Can't merge with uncommitted changes" if changes?
+
+      commit_id = extract_commit options
+
+      raise "Invalid commit #{commit_id}" unless Commit.exists? commit_id
+
+      merge! Commit.new(commit_id)
+    end
+
+    def push
+      raise 'Push rejected (non fast forward)' if current_commit != Branch[current_branch] && !current_commit.fast_forward?(Branch[current_branch])
+      push!
+    end
+
+    def push!
+      raise "Can't push without commit" unless current_commit?
+      Branch[current_branch] = current_commit.id
+    end
+
+    def pull
+      raise "Can't pull with uncommitted changes" if changes?
+      raise "Branch not found: #{current_branch}" unless Branch.exists? current_branch
+
+      target_commit = Branch[current_branch]
+
+      if current_commit == target_commit || current_commit.fast_forward?(target_commit)
+        {}
+      elsif target_commit.fast_forward?(current_commit)
+        checkout commit: target_commit.id
+      else 
+        merge! target_commit
+      end
+    end
+
+    def revert
+      locker.lock! :revert do
+        Delta.revert(delta, current_commit).tap { tracker.revert }
+      end
+    end
+
+    def log
+      current_commit? ? ([current_commit] + current_commit.history) : []
+    end
+
+    def destroy
+      tracker.destroy
+      current.destroy
+      branches.destroy
+    end
+
+    def to_h
+      {
+        'current' => current.to_h,
+        'branches' => branches.to_h,
+        'delta' => delta
+      }
+    end
+    alias_method :dump, :to_h
+
+    def restore(dump)
+      current.merge! dump['current']
+      branches.merge! dump['branches']
+      self.delta = dump['delta']
+    end
+
+    [:delta, :delta=, :commit, :pull, :push, :checkout, :merge, :revert, :destroy, :dump].each { |m| log m }
+
+    private
+
+    attr_reader :tracker, :current, :locker
+
+    def commit!(options)
+      changes = delta
+      options[:parents] ||= [current_commit.id]
+      options[:delta]   ||= write_delta changes
+      options[:index]   ||= write_index changes
+
+      Commit.create(options).tap do |commit|
+        current[:commit] = commit.id
+        current[:branch] = current_branch
+        branches[current_branch] = commit.id
+        tracker.clear
+      end
+    end
+
+    def merge!(target_commit)
+      locker.lock! :merge do
+        patch = Patch.merge current_commit, target_commit
+
+        raise 'Already merged' if patch.merged?
+
+        commit! message:    "Merge #{target_commit.short_id} into #{current_commit.short_id}",
+                author:     'System',
+                parents:    [current_commit.id, target_commit.id],
+                index:      write_index(patch.delta),
+                base:       patch.base_commit.id,
+                base_delta: Blob.write(:delta, patch.base_delta)
+
+        patch.delta
+      end
+    end
+
+    def write_index(delta)
+      current_commit.with_index do |index|
+        index.apply delta
+        index.write_blob
+      end
+    end
+
+    def write_delta(delta)
+      Blob.write :delta, delta
+    end
+
+    def extract_commit(options)
+      extract_commit_and_branch(options).first
+    end
+
+    def extract_commit_and_branch(options)
+      branch = options.fetch(:branch) { current_branch }
+      
+      commit_id = options.fetch(:commit) do
+        if branches.key? branch
+          branches[branch]
+        elsif Branch.exists?(branch)
+          Branch[branch].id
+        else
+          raise "Invalid branch #{branch}"
+        end
+      end
+
+      [commit_id, branch]
+    end
+
+  end
+end

data/lib/eternity/track_flatter.rb

@@ -0,0 +1,57 @@
+module Eternity
+  class TrackFlatter
+    class << self
+
+      def flatten(changes)
+        send "flatten_#{changes.first['action']}_#{changes.last['action']}", changes
+      end
+
+      private
+
+      def flatten_insert_insert(changes)
+        expand changes.last
+      end
+
+      def flatten_insert_update(changes)
+        {'action' => INSERT, 'data' => expand(changes.last)['data']}
+      end
+
+      def flatten_insert_delete(changes)
+        nil
+      end
+
+      def flatten_update_insert(changes)
+        {'action' => UPDATE, 'data' => expand(changes.last)['data']}
+      end
+
+      def flatten_update_update(changes)
+        expand changes.last
+      end
+
+      def flatten_update_delete(changes)
+        expand changes.last
+      end
+
+      def flatten_delete_insert(changes)
+        {'action' => UPDATE, 'data' => expand(changes.last)['data']}
+      end
+
+      def flatten_delete_update(changes)
+        {'action' => UPDATE, 'data' => expand(changes.last)['data']}
+      end
+
+      def flatten_delete_delete(changes)
+        expand changes.last
+      end
+
+      def expand(change)
+        return change if change.key? 'data'
+        change.tap do |ch|
+          sha1 = ch.delete 'blob'
+          ch['data'] = Blob.read(:data, sha1) if sha1
+        end
+      end
+   
+    end 
+  end
+end

data/lib/eternity/tracker.rb

@@ -0,0 +1,38 @@
+module Eternity
+  class Tracker
+
+    Changes = Restruct::NestedHash.new CollectionTracker
+    
+    extend Forwardable
+    def_delegators :changes, :[], :to_h, :empty?, :destroy
+
+    attr_reader :repository
+
+    def initialize(repository)
+      @repository = repository
+      @changes = Changes.new redis: Eternity.redis, 
+                             id: repository.id[:changes]
+    end
+
+    def count
+      changes.inject(0) do |sum, (collection, tracker)|
+        sum + tracker.count
+      end
+    end
+
+    alias_method :revert, :destroy
+    alias_method :clear, :destroy
+
+    def flatten
+      changes.each_with_object({}) do |(collection, tracker), hash|
+        collection_changes = tracker.flatten
+        hash[collection] = collection_changes unless collection_changes.empty?
+      end
+    end
+
+    private
+
+    attr_reader :changes
+    
+  end
+end

data/lib/eternity/version.rb

@@ -0,0 +1,3 @@
+module Eternity
+  VERSION = '0.0.1'
+end

data/spec/blob_spec.rb

@@ -0,0 +1,83 @@
+require 'minitest_helper'
+
+describe Blob do
+
+  let(:data) { {'id' => 'AR', 'name' => 'Argentina'} }
+  let(:serialization) { MessagePack.pack data }
+  let(:sha1) { Digest::SHA1.hexdigest serialization }
+  let(:key) { Eternity.keyspace[:blob][:xyz][sha1] }
+  let(:filename) { File.join(Eternity.blob_path, 'xyz', sha1[0..1], sha1[2..-1]) }
+
+  def encode(text)
+    Base64.encode64 text
+  end
+
+  def decode(text)
+    Base64.decode64 text
+  end
+
+  def wait_and_read_file(filename)
+    Timeout.timeout(5) do
+      until File.exists?(filename) && File.size(filename) > 0
+        sleep 0.001
+      end
+      IO.read filename
+    end
+  rescue Timeout::Error
+    raise "File not found: #{filename}"
+  end
+
+  it 'Write in redis and file system' do
+    sha1 = Blob.write :xyz, data
+
+    redis_data = redis.call 'GET', key
+    file_data = wait_and_read_file filename
+
+    [redis_data, decode(file_data)].each { |d| MessagePack.unpack(d).must_equal data }
+  end
+
+  it 'Read from redis' do
+    redis.call 'SET', key, serialization
+    
+    refute File.exists?(filename)
+    Blob.read(:xyz, sha1).must_equal data
+  end
+
+  it 'Read from file' do
+    FileUtils.mkpath File.dirname(filename)
+    File.write filename, encode(serialization)
+
+    redis.call('GET', key).must_be_nil
+    Blob.read(:xyz, sha1).must_equal data
+  end
+
+  it 'Read invalid sha1' do
+    error = proc { Blob.read :xyz, 'invalid_sha1' }.must_raise RuntimeError
+    error.message.must_equal 'Blob not found: xyz -> invalid_sha1'
+  end
+
+  it 'Count' do
+    Blob.count.must_equal 0
+
+    3.times { |i| Blob.write :xyz, value: i }
+
+    Blob.count.must_equal 3
+  end
+
+  it 'Clear cache' do
+    3.times { |i| Blob.write :xyz, value: i }
+
+    Blob.clear_cache
+
+    Blob.count.must_equal 0
+  end
+
+  it 'Normalize serialization' do
+    time = Time.now
+    data_1 = {key_1: 1, key_2: time}
+    data_2 = {key_2: time.utc.strftime(TIME_FORMAT), key_1: 1}
+
+    Blob.serialize(data_1).must_equal Blob.serialize(data_2)
+  end
+
+end

data/spec/branch_spec.rb

@@ -0,0 +1,71 @@
+require 'minitest_helper'
+
+describe Repository, 'Branch' do
+
+  describe 'Global' do
+
+    let(:commit_id) { SecureRandom.uuid }
+
+    it 'Get/Set' do
+      Branch[:test].id.must_be_nil
+      Branch[:test] = commit_id
+      Branch[:test].id.must_equal commit_id
+    end
+
+    it 'Exists' do
+      refute Branch.exists?(:test)
+      Branch[:test] = commit_id
+      assert Branch.exists?(:test)
+    end
+
+    it 'Delete' do
+      Branch[:test] = commit_id
+      assert Branch.exists?(:test)
+      Branch.delete :test
+      refute Branch.exists?(:test)
+    end
+
+    it 'Names' do
+      branches = %w(test_1 test_2 test_3)
+      branches.each { |b| Branch[b] = commit_id }
+      Branch.names.must_equal branches
+    end
+
+  end
+
+  describe 'Local' do
+
+    let(:repository) { Repository.new :test }
+
+    it 'New' do
+      repository[:countries].insert 'AR', name: 'Argentina'
+      commit = repository.commit author: 'User', message: 'Commit message'
+
+      repository.current_commit.must_equal commit
+      repository.current_branch.must_equal 'master'
+      repository.branches.to_h.must_equal 'master' => commit.id
+
+      repository.branch :test_branch
+
+      repository.current_branch.must_equal 'master'
+      repository.branches.to_h.must_equal 'master' => commit.id, 
+                                          'test_branch' => commit.id
+    end
+
+    it 'Without commit' do
+      error = proc { repository.branch :test_branch }.must_raise RuntimeError
+      error.message.must_equal "Can't branch without commit"
+    end
+    
+    it 'With uncommitted changes' do
+      repository[:countries].insert 'AR', name: 'Argentina'
+      commit_id = repository.commit author: 'User', message: 'Commit message'
+      repository[:countries].delete 'AR'
+
+      error = proc { repository.branch :test_branch }.must_raise RuntimeError
+      error.message.must_equal "Can't branch with uncommitted changes"
+    end
+
+  end
+
+end