au 0.1.0

data/lib/au/models/diff.rb

@@ -0,0 +1,69 @@
+require 'pstore'
+
+module Au
+  class Diff
+
+    def self.create(db_name, parent_id, change, md5)
+      db = get_db(db_name)
+      id = Time.now.to_f
+      db.transaction do
+        db[id] = [parent_id, change, md5]
+      end
+      id
+    end
+
+    def self.replay_changes_upto(id, db_name)
+      raise 'Missing block' unless block_given?
+      diffs = [find(id, db_name: db_name)]
+      while diffs.last.has_parent?
+        diffs << diffs.last.parent
+      end
+      # apply the oldest first
+      diffs.reverse.each do |diff|
+        yield(diff)
+      end
+    end
+
+    def self.find(id, db_name: nil, db: nil)
+      raise 'Missing both db name and db' if db_name.nil? && db.nil?
+      db ||= get_db(db_name)
+      stored_values = db.transaction{ db[id] }
+
+      raise 'Diff not found' unless stored_values
+      parent_id, change, md5 = stored_values
+      new(id, parent_id, change, md5, db)
+    end
+
+    # memoize all encountered dbs
+    # Note, may need to watch memory usage.
+    # Note, depending on PStore initialization, may not need this
+    def self.get_db(db_name)
+      if @dbs
+        @dbs[db_name] ||= PStore.new(db_name)
+      else
+        @dbs = {}
+        get_db(db_name)
+      end
+    end
+
+    attr_reader :id, :parent_id, :change, :md5, :db
+
+    def initialize(id, parent_id, change, md5, db)
+      @id = id
+      @parent_id = parent_id
+      @change = change
+      @md5 = md5
+      @db = db
+    end
+
+    def parent
+      return unless parent_id
+      self.class.find(parent_id, db: db)
+    end
+
+    def has_parent?
+      !!parent_id
+    end
+
+  end
+end

data/lib/au/models/document.rb

@@ -0,0 +1,104 @@
+require 'pstore'
+require 'tempfile'
+require 'digest/md5'
+require 'fileutils'
+require_relative '../models/diff'
+
+module Au
+  class Document
+    class HasMergeConflict < StandardError
+      attr_reader :document
+      def initialize(document)
+        @document = document
+        super
+      end
+    end
+
+    def self.find(paths)
+      paths.is_a?(Array) ? paths.map{ |path| new(path) } : new(paths)
+    end
+
+    attr_reader :path
+
+    # Do NOT invoke this method directly, always use
+    # Document.find instead.
+    def initialize(path)
+      @path = path
+    end
+
+    def create_diff(parent_diff_id)
+      return nil unless File.exists?(abs_path)
+      changes = diff(parent_diff_id)
+      # if not first diff AND there's no change, don't create new diff
+      return parent_diff_id if changes.empty? && parent_diff_id
+      Diff.create(diff_db_name, parent_diff_id, changes, calculate_md5)
+    end
+
+    def diff_3(ancestor_diff_id:, other_diff_id:)
+      file_in_ancestor_state = content_from(ancestor_diff_id)
+      file_in_other_state = content_from(other_diff_id)
+      diff3_args = "#{abs_path} #{file_in_ancestor_state.path} #{file_in_other_state.path}"
+
+      has_conflict = !`diff3 -x #{diff3_args}`.empty?
+      merged_content = `diff3 --merge #{diff3_args}`
+      File.open(abs_path, 'w'){ |f| f.write(merged_content) }
+
+      raise HasMergeConflict.new(self) if has_conflict
+    end
+
+    def changed?(parent_diff_id)
+      !diff(parent_diff_id).empty?
+    end
+
+    def diff(parent_diff_id)
+      `diff -c #{abs_path} #{content_from(parent_diff_id).path}`
+    end
+
+    def content_from(diff_id)
+      output = Tempfile.new
+      return output unless diff_id
+      apply_diffs(output, diff_id)
+      output
+    end
+
+    def checkout(diff_id)
+      # do nothing if file didn't change
+      return if File.exists?(abs_path) && calculate_md5 == md5_at(diff_id)
+      FileUtils.mkdir_p(File.dirname(abs_path)) unless File.exists?(abs_path)
+
+      File.open(abs_path, 'w') do |f|
+        apply_diffs(f, diff_id)
+      end
+    end
+
+    def md5_at(diff_id)
+      Diff.find(diff_id, db_name: diff_db_name).md5
+    end
+
+    private
+
+    def calculate_md5
+      Digest::MD5.hexdigest(File.read(abs_path))
+    end
+
+    def apply_diffs(output, last_diff_id)
+      Diff.replay_changes_upto(last_diff_id, diff_db_name) do |diff|
+        Tempfile.create do |f|
+          f.write(diff.change)
+          f.rewind
+          `patch -cR #{output.path} #{f.path}`
+        end
+      end
+    end
+
+    def diff_db_name
+      paths = [Repository.path, "diff_#{path.gsub('/', '.')}.pstore"].compact
+      File.join(*paths)
+    end
+
+    def abs_path
+      File.join(Repository.root, path)
+    end
+
+  end
+end

data/lib/au/models/repository.rb

@@ -0,0 +1,254 @@
+require 'pstore'
+
+module Au
+  class Repository
+    # singleton class
+    attr_reader :root, :path, :current, :head
+
+    def self.root(path = nil)
+      instance(path, false).root
+    end
+
+    def self.path(path = nil)
+      instance(path, false).path
+    end
+
+    def self.head(path = nil)
+      Commit.find instance(path, false).head
+    end
+
+    def self.diff(file_path)
+      return nil unless head
+      tracked_version = head.cat(file_path)
+      return nil unless tracked_version
+      `diff -c #{tracked_version.path} #{File.join(root, file_path)}`
+    end
+
+    def self.instance(path = nil, create = false)
+      return @single_instance unless @single_instance.nil?
+      @single_instance = new(path, create)
+    end
+
+    def initialize(path, create = false, remote_path = nil)
+      if path.nil?
+        working_dir = Dir.pwd
+        # little bit different with mercurial 0.1
+        # here we only check whether the current working directory is a repository
+        if not File.directory?(File.join(working_dir, '.au')) and not create
+          raise 'Repository not found in ' + working_dir
+        end
+        path = working_dir
+      end
+
+      @root = path
+      @path = File.join(path, '.au')
+
+      Dir.mkdir(@path) if create && !File.directory?(@path)
+
+      @head_pstore = PStore.new(File.join(@path, 'head.pstore'))
+
+      update_head_var
+
+      @alt_pstore = PStore.new(File.join(@path, 'alt.pstore'))
+
+      update_alt_list
+
+      @leaves_pstore = PStore.new(File.join(@path, 'leaves.pstore'))
+    end
+
+    def merge(commit_to_merge)
+      commit_id = Commit.merge(@head, commit_to_merge)
+      return false if commit_id.nil?
+      # checkout to new commit
+      checkout(commit_id)
+      true
+    end
+
+    def commit(commit_message)
+      staged_file_paths = Staging.staged_file_paths
+      return if staged_file_paths.empty?
+      commit_created_id =
+          if File.exist?(Repository.resolve_conflict_fname)
+            parent_id1, parent_id2 = File.read(Repository.resolve_conflict_fname).split(',')
+            File.delete(Repository.resolve_conflict_fname)
+            Commit.create_commit_resolve_conflict(staged_file_paths, parent_id1, parent_id2)
+          else
+            Commit.create(staged_file_paths, commit_message, @head)
+          end
+      update_head_pstore(commit_created_id)
+      update_leaves_pstore(commit_created_id)
+      Staging.clear_staged_file_paths
+      commit_created_id
+    end
+
+    def checkout(commit_id)
+      this_commit = Commit.find(commit_id)
+      if this_commit
+        this_commit.checkout(update_head_var)
+        update_alt_pstore(update_head_var)
+        update_head_pstore(commit_id)
+        update_head_var
+      end
+    end
+
+    def pull(remote_repo)
+      # Initialize local and remote db and commit list
+      remote_commit_db = Commit.db(remote_repo.root)
+      remote_commit_list = remote_commit_db.transaction do
+        remote_commit_db.roots
+      end
+      local_commit_db = Commit.db
+      local_commit_list = local_commit_db.transaction do
+        local_commit_db.roots
+      end
+      # Check if the root commits are the same
+      if local_commit_list[0] != remote_commit_list[0]
+        raise "Error: Root commits do not match."
+      end
+
+      # Find commits that only exist locally
+      commit_id_to_add_list = remote_commit_list.reject{|x| local_commit_list.include?(x)}
+      commits_to_add = {}
+      remote_commit_db.transaction(true) do
+        commit_id_to_add_list.each{|commit_id| commits_to_add[commit_id] = remote_commit_db[commit_id]}
+      end
+
+      # Write those commits to remote commit db
+      local_commit_db.transaction do
+        commits_to_add.each{|commit_id, data| local_commit_db[commit_id] = data}
+      end
+
+      # Find documents and their diff_id in those commits that only existed locally
+      remote_diff_id_to_add_list = {}
+      commits_to_add.each do |commit| 
+        commit[:doc_diff_ids].each do |doc_path, diff_id| 
+          remote_diff_id_to_add_list[doc_path] = diff_id
+        end
+      end
+
+      # Write these information to remote
+      remote_diff_id_to_add_list.each do |doc_path, diff_id|
+        diff_pstore_remote = PStore.new(diff_db_name_remote(doc_path, remote_repo.path))
+        diff_pstore_remote.transaction(true) do
+          diff_pstore_local = PStore.new(diff_db_name_remote(doc_path, @path))
+          diff_pstore_local.transaction do
+            if diff_pstore_local[doc_path] == nil
+              diff_pstore_local[doc_path] = diff_pstore_remote[doc_path]
+            elsif diff_pstore_local[doc_path] != diff_pstore_remote[doc_path]
+              raise "Error: Remote and local reposiroty have different content in a same diff"
+            end
+          end
+        end
+      end
+    end
+
+    def push(remote_repo)
+      # Initialize local and remote db and commit list
+      remote_commit_db = Commit.db(remote_repo.root)
+      remote_commit_list = remote_commit_db.transaction do
+        remote_commit_db.roots
+      end
+      local_commit_db = Commit.db
+      local_commit_list = local_commit_db.transaction do
+        local_commit_db.roots
+      end
+      # Check if the root commits are the same
+      if local_commit_list[0] != remote_commit_list[0]
+        raise "Error: Root commits do not match."
+      end
+
+      # Find commits that only exist locally
+      commit_id_to_add_list = local_commit_list.reject{|x| remote_commit_list.include?(x)}
+      commits_to_add = {}
+      remote_commit_db.transaction(true) do
+        commit_id_to_add_list.each{|commit_id| commits_to_add[commit_id] = remote_commit_db[commit_id]}
+      end
+
+      # Write those commits to remote commit db
+      remote_commit_db.transaction do
+        commits_to_add.each{|commit_id, data| remote_commit_db[commit_id] = data}
+      end
+
+      # Find documents and their diff_id in those commits that only existed locally
+      local_diff_id_to_add_list = {}
+      commits_to_add.each do |commit| 
+        commit[:doc_diff_ids].each do |doc_path, diff_id| 
+          local_diff_id_to_add_list[doc_path] = diff_id
+        end
+      end
+
+      # Write these information to remote
+      local_diff_id_to_add_list.each do |doc_path, diff_id|
+        diff_pstore_local = PStore.new(diff_db_name_remote(doc_path, @path))
+        diff_pstore_local.transaction(true) do
+          diff_pstore_remote = PStore.new(diff_db_name_remote(doc_path, remote_repo.path))
+          diff_pstore_remote.transaction do
+            if diff_pstore_remote[doc_path] == nil
+              diff_pstore_remote[doc_path] = diff_pstore_local[doc_path]
+            elsif diff_pstore_local[doc_path] != diff_pstore_remote[doc_path]
+              raise "Error: Remote and local reposiroty have different content in a same diff"
+            end
+          end
+        end
+      end
+    end
+
+    # def clone
+    #
+    # end
+
+    def heads
+      @leaves_pstore.transaction(true) do
+        @leaves_pstore.roots
+      end
+    end
+
+    private
+
+    def diff_db_name_remote(file_path, remote_path)
+      paths = [Repository(remote_path, false).path, "diff_#{file_path.gsub('/', '.')}.pstore"].compact
+      File.join(*paths)
+    end
+
+    
+    def update_head_var
+      @head = @head_pstore.transaction(true) do
+        @head_pstore[:head]
+      end
+    end
+
+    def update_head_pstore(commit_id)
+      @head = @head_pstore.transaction do
+        @head_pstore[:head] = commit_id
+      end
+    end
+
+    def update_alt_list
+      @alt_list = @alt_pstore.transaction(true) do
+        @alt_pstore[:commit]
+      end
+    end
+
+    def update_alt_pstore(commit_id)
+      @alt_pstore.transaction do
+        @alt_pstore[:commit].nil? ? (@alt_pstore[:commit] = [commit_id]) : (@alt_pstore[:commit] << commit_id)
+      end
+    end
+
+    def update_leaves_pstore(commit_id)
+      @leaves_pstore.transaction do
+        commit = Commit.find(commit_id)
+        if commit
+          parent_commit_id_1, parent_commit_id_2 = commit.parent_id_1, commit.parent_id_2
+          @leaves_pstore.delete(parent_commit_id_1)
+          @leaves_pstore.delete(parent_commit_id_2)
+          @leaves_pstore[commit_id] = 1
+        end
+      end
+    end
+
+    def self.resolve_conflict_fname
+      File.join(Repository.instance.path, 'resolve_conflict')
+    end
+  end
+end

data/lib/au/models/staging.rb

@@ -0,0 +1,91 @@
+require 'digest/md5'
+require 'pstore'
+
+module Au
+  class Staging
+
+    def self.status(last_commit = Repository.head)
+      return project_file_paths unless last_commit
+      changed_doc_paths = []
+      tracked_docs_md5 = last_commit.tracked_docs_md5
+      project_file_paths.each do |relative_path|
+        known_md5 = tracked_docs_md5[relative_path]
+        # file not tracked or tracked but hasn't changed
+        if known_md5.nil? || Digest::MD5.hexdigest(File.read(abs_path(relative_path))) != known_md5
+          changed_doc_paths << relative_path
+        end
+        tracked_docs_md5.delete(relative_path) if known_md5
+      end
+
+      # remaining files in tracked_docs_md5 are no longer in the project
+      changed_doc_paths += tracked_docs_md5.keys unless tracked_docs_md5.empty?
+      changed_doc_paths
+    end
+
+    def self.stage(relative_paths, last_commit = Repository.head)
+      relative_paths = relative_paths.each_with_object([]) do |staged_path, accum|
+        if File.directory?(staged_path)
+          Dir.glob('**/*', base: staged_path) do |sub_path|
+            accum << (File.join(staged_path, sub_path)) unless File.directory?(sub_path)
+          end
+        else
+          accum << staged_path
+        end
+      end
+
+      stage_db.transaction do
+        filter_stageable(last_commit, relative_paths).each do |relative_path|
+          stage_db[relative_path] = 1
+        end
+      end
+      relative_paths
+    end
+
+    def self.filter_stageable(last_commit, relative_paths)
+      tracked_docs_md5 = last_commit&.tracked_docs_md5 || {}
+      relative_paths.reject do |relative_path|
+        known_md5 = tracked_docs_md5[relative_path]
+        abs_path = File.join(Repository.root, relative_path)
+        if File.exists?(abs_path)
+          known_md5 && Digest::MD5.hexdigest(File.read(abs_path)) == known_md5
+        else
+          known_md5.nil?
+        end
+      end
+    end
+
+    def self.staged_file_paths
+      stage_db.transaction(true) do
+        stage_db.roots
+      end
+    end
+
+    def self.clear_staged_file_paths
+      File.delete stage_db.path
+    end
+
+    def self.unstage(file_paths)
+      stage_db.transaction do
+        file_paths.each do |file_path|
+          stage_db.delete(file_path)
+        end
+      end
+    end
+
+    def self.abs_path(relative_path)
+      File.join(Repository.root, relative_path)
+    end
+
+    def self.project_file_paths
+      Dir.glob('**/*', base: Repository.root).reject do |file_path|
+        File.directory? file_path
+      end
+    end
+
+    # private
+    def self.stage_db
+      @stage_db ||= PStore.new(File.join(*[Repository.path, 'stage.pstore'].compact))
+    end
+
+  end
+end