au 0.1.0

data/bin/au

@@ -0,0 +1,170 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'fileutils'
+require 'au'
+require 'thor'
+require 'colorize'
+
+module Au
+  class CLI < Thor
+
+    desc 'reset', 'reset .au directory'
+    def reset
+      FileUtils.rm_r('.au') if File.directory?('.au')
+    end
+
+    desc "init", "Start tracking current directory"
+    def init
+      Repository.instance(nil, true)
+      puts 'Welcome to AU. Your project is now tracked.'
+    end
+
+    desc "clone remote PATH and target PATH", "Copy an existing repo"
+    def clone(remote_repo_root, target_repo_root = nil)
+      # default target path is the same with rename's name in current working directory
+      target_repo_root = File.join(Dir.pwd, File.basename(remote_repo_root)) if target_repo_root.nil?
+      if Dir.exist?(target_repo_root)
+        puts 'target directory path exists, please try another one'
+        return
+      end
+
+      remote_au_dir = File.join(remote_repo_root, '.au')
+      unless Dir.exist?(remote_au_dir)
+        puts 'given remote directory path is not an Au repo, please try another one.'
+        return
+      end
+
+      # create local repo
+      Dir.mkdir(target_repo_root)
+      target_repo_au_path = File.join(target_repo_root, '.au')
+      Dir.mkdir(target_repo_au_path)
+      # copy remote's .au directory to local repo
+      FileUtils.copy_entry(remote_au_dir, target_repo_au_path)
+
+      # create current repo's single instance
+      Repository.instance(target_repo_root)
+
+      remote_repo = Au::Repository.new(remote_repo_root, false)
+      remote_head_commit_id = remote_repo.update_head_var  # get remote head commit id
+      if remote_head_commit_id
+        cur_repo = Au::Repository.new(target_repo_root, false)
+        cur_repo.checkout(remote_head_commit_id)  # checkout to remote's head
+      end
+    end
+
+    desc "stage PATH", "Stage file for commit"
+    def stage(*file_paths)
+      puts Staging.stage(file_paths)
+    end
+
+    desc "unstage PATHS", "Unstage file for commit"
+    def unstage(*file_path)
+      Staging.unstage(file_path)
+    end
+
+    desc "status", "Check current status of repo"
+    def status
+      changed_files = Staging.status
+      staged_files = Staging.staged_file_paths
+
+      puts ''
+      if head_id = Repository.head&.id
+        puts "  HEAD: #{head_id}".light_green
+      else
+        puts "  No past commit found."
+      end
+      puts ''
+
+      puts 'Staged files:' if staged_files.any?
+      staged_files.each{ |file_path| puts "  " + file_path.green }
+
+      unstaged_files = changed_files - staged_files
+      puts 'Unstaged files:' if unstaged_files.any?
+      unstaged_files.each{ |file_path| puts "  " + file_path.light_red }
+    end
+
+    desc "heads", "Show current HEAD"
+    def heads
+      Repository.instance.heads
+    end
+
+    desc "diff PATH", "Display between tracked version and current version"
+    def diff(file_path)
+      diff = Repository.diff(file_path)
+      if diff.present?
+        puts diff
+      else
+        puts "No change found in #{file_path}"
+      end
+    end
+
+    desc "checkout COMMIT", "Check out a commit"
+    def checkout(commit_id)
+      Repository.instance.checkout(commit_id)
+    end
+
+    desc "cat COMMIT PATH", "Display file from provided commit"
+    def cat(commit_id, file_path)
+      output_tempfile = Commit.find(commit_id).cat(file_path)
+
+      if output_tempfile
+        system("less #{output_tempfile.path}")
+      else
+        puts "#{commit_id} does not track file #{file_path}"
+      end
+    end
+
+    desc "commit", "Commit staged files"
+    option :m
+    def commit
+      created_commit_id = Repository.instance.commit(options[:m])
+      if created_commit_id
+        puts "Created commit #{created_commit_id}"
+      else
+        puts 'Please stage your changes first.'
+      end
+    end
+
+    desc "log", "Display parent commits"
+    def log
+      Repository.head.log.each do |commit|
+        commit.id == Repository.head.id ? puts("#{commit.id}".green) : puts(commit.id)
+        puts commit.message
+        puts
+      end
+    end
+
+    desc "merge COMMIT", "Merge with provided commit"
+    def merge(commit_id)
+      Repository.instance.merge(commit_id)
+    end
+
+    desc "pull REMOTE_PATH", "Pull changes from remote repo"
+    def pull(remote_repo_root)
+      remote = nil
+      begin
+        remote = Repository.instance(remote_repo_root, false)
+      rescue
+        puts "Remote path is invalid!"
+        return
+      end
+      Repository.instance.pull(remote)
+    end
+
+    desc "push REMOTE_PATH", "Push changes to remote repo"
+    def push(remote_repo_root)
+      remote = nil
+      begin
+        remote = Repository.instance(remote_repo_root, false)
+      rescue
+        puts "Remote path is invalid!"
+        return
+      end
+      Repository.instance.push(remote)
+    end
+
+  end
+end
+
+Au::CLI.start

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "au"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/au.rb

@@ -0,0 +1,14 @@
+require 'au/patches/object'
+
+require 'au/version'
+
+require 'au/models/commit'
+require 'au/models/diff'
+require 'au/models/document'
+require 'au/models/repository'
+require 'au/models/staging'
+
+require 'pry'
+
+module Au
+end

data/lib/au/misc/load_pstore.rb

@@ -0,0 +1,13 @@
+require 'PStore'
+
+root = 'test_tmp/repo1/.au'
+
+commits_path = File.join(root, 'commits.pstore')
+
+commit_store = PStore.new(commits_path)
+commit_store.transaction do
+  commit_store.roots.each do |key|
+    puts 'key: ', key
+    puts 'value: ', commit_store[key]
+  end
+end

data/lib/au/models/commit.rb

@@ -0,0 +1,259 @@
+require 'pstore'
+require 'set'
+require 'digest/md5'
+require_relative '../models/document'
+
+
+# This represents a global commit created when
+# user enters git commit
+module Au
+  class Commit
+    attr_reader :id, :message, :doc_diff_ids, :parent_id_1, :parent_id_2, :created_at
+
+    def initialize(id, message, doc_diff_ids, parent_id_1 = nil, parent_id_2 = nil, created_at = 0)
+      @id = id
+      @message = message
+      @doc_diff_ids = doc_diff_ids
+      @parent_id_1 = parent_id_1
+      @parent_id_2 = parent_id_2
+      @created_at = created_at
+    end
+
+    def self.list
+      db.transaction(true) do
+        puts db.roots
+      end
+    end
+
+    # find a commit which has been created
+    def self.find(commit_id)
+      return unless commit_id # used for initial commit
+      db.transaction(true) do
+        init_attrs = %i(message doc_diff_ids parent_id_1 parent_id_2 created_at)
+        new(commit_id, *db[commit_id].values_at(*init_attrs))
+      end
+    end
+
+    # find a remote commit which has been created
+    def self.find_remote(commit_id, repo_path)
+      return unless commit_id # used for initial commit
+      db(repo_path).transaction(true) do
+        init_attrs = %i(message doc_diff_ids parent_id_1 parent_id_2 created_at)
+        new(commit_id, *db(repo_path)[commit_id].values_at(*init_attrs))
+      end
+    end
+
+    def self.create(staged_file_paths, commit_message, parent_commit_id = nil)
+      # only support one parent
+      # file_paths: changed / added / removed files_paths
+      parent_commit = find(parent_commit_id)
+      new_doc_diff_ids = {}
+
+      Document.find(staged_file_paths).each do |doc|
+        # pass in the diff id for this doc from parent commit, if present
+        diff_id = doc.create_diff(parent_commit ? parent_commit.doc_diff_ids[doc.path] : nil)
+        new_doc_diff_ids[doc.path] = diff_id ? diff_id : -1
+      end
+
+      if parent_commit
+        docs_from_parent_commit = Document.find(parent_commit.doc_diff_ids.keys)
+        docs_from_parent_commit.each do |doc|
+          new_doc_diff_ids[doc.path] ||= parent_commit.doc_diff_ids[doc.path]
+        end
+      end
+
+      new_commit_id = build_commit_id
+      db.transaction do
+        db[new_commit_id] = {
+          message: commit_message,
+          parent_id_1: parent_commit_id,
+          doc_diff_ids: new_doc_diff_ids.delete_if{ |key, val| val == -1 },
+          created_at: Time.now.to_f
+        }
+      end
+      new_commit_id
+    end
+
+    def self.merge(parent_commit_id_1, parent_commit_id_2)
+      # If commit 2 is commit 1's ancestor, don't merge
+      if gen_ancestor_set(parent_commit_id_1, Set.new).include?(parent_commit_id_2)
+        puts 'Stop merging. Commit to be merged is ancestor of current commit'
+        return nil
+      end
+
+      # Load commit objects
+      parent1_commit = find(parent_commit_id_1)
+      parent2_commit = find(parent_commit_id_2)
+      ancestor_commit_id = lowest_common_ancestor(parent_commit_id_1, parent_commit_id_2)
+      ancestor_commit = find(ancestor_commit_id)
+
+      # Initialize local variables
+      new_doc_diff_ids = {}
+      conflict_file_paths = []
+
+      # Go through files in commit 1
+      parent1_commit.doc_diff_ids.each do |doc_path, diff1_id|
+        if parent2_commit.doc_diff_ids[doc_path].nil?
+          # If this file only exists in commit 1, add it to the file table
+          new_doc_diff_ids[doc_path] = diff1_id
+          next
+        end
+
+        doc = Document.find(doc_path)
+        begin
+          # If this file also exists in commit 2, run diff3 to merge files and check for conflict.
+          doc.diff_3(ancestor_diff_id: ancestor_commit.doc_diff_ids[doc_path], other_diff_id: parent2_commit.doc_diff_ids[doc_path])
+          new_doc_diff_ids[doc_path] = doc.create_diff(diff1_id) if conflict_file_paths.empty?
+        rescue Document::HasMergeConflict
+          conflict_file_paths << doc.path
+        end
+      end
+
+      unless conflict_file_paths.empty?
+        # add a file to indicate user is resolving conflicts
+        File.open(Repository.resolve_conflict_fname, 'w') do |f|
+          f.truncate(0)
+          f.write(parent_commit_id_1.to_s + ',' + parent_commit_id_2.to_s)
+        end
+
+        puts "Merge failed due to conflicts. Fix conflicts in files: \n#{conflict_file_paths.join('\n')}"
+        return nil
+      end
+
+      # Check if there is any file in commit 2 and not in commit 1,
+      # if so, add them to file table
+      parent2_commit.doc_diff_ids.each do |doc_path, diff2_id|
+        new_doc_diff_ids[doc_path] = diff2_id unless parent1_commit.doc_diff_ids.key?(doc_path)
+      end
+
+      # Generate commit id and Write commit
+      new_commit_id = build_commit_id
+      db.transaction do
+        db[new_commit_id] = {
+          message: "Merged #{parent_commit_id_1} and #{parent_commit_id_2}",
+          parent_id_1: parent_commit_id_1,
+          parent_id_2: parent_commit_id_2,
+          doc_diff_ids: new_doc_diff_ids,
+          created_at: Time.now.to_f
+        }
+      end
+      new_commit_id
+    end
+
+    def self.create_commit_resolve_conflict(staged_file_paths, parent_commit_id_1, parent_commit_id_2)
+      parent_commit_1 = find(parent_commit_id_1)
+      new_doc_diff_ids = {}
+
+      Document.find(staged_file_paths).each do |doc|
+        # pass in the diff id for this doc from parent commit, if present
+        diff_id = doc.create_diff(parent_commit_1 ? parent_commit_1.doc_diff_ids[doc.path] : nil)
+        new_doc_diff_ids[doc.path] = diff_id ? diff_id : -1
+      end
+
+      if parent_commit_1
+        docs_from_parent_commit_1 = Document.find(parent_commit_1.doc_diff_ids.keys)
+        docs_from_parent_commit_1.each do |doc|
+          new_doc_diff_ids[doc.path] ||= parent_commit_1.doc_diff_ids[doc.path]
+        end
+      end
+
+      new_commit_id = build_commit_id
+      db.transaction do
+        db[new_commit_id] = {
+            message: "Resolved conflicts for #{parent_commit_id_1} and #{parent_commit_id_2}",
+            parent_id_1: parent_commit_id_1,
+            parent_id_2: parent_commit_id_2,
+            doc_diff_ids: new_doc_diff_ids.delete_if{ |key, val| val == -1 },
+            created_at: Time.now.to_f
+        }
+      end
+      new_commit_id
+    end
+
+    def checkout(current_commit_id)
+      current_commit = Commit.find(current_commit_id)
+      @doc_diff_ids.each{ |doc_path, diff_id| Document.find(doc_path).checkout(diff_id) }
+      current_commit.doc_diff_ids.each_key do |doc_path|
+        abs_doc_path = File.join(Repository.root, doc_path)
+        abs_dir_path = File.dirname(abs_doc_path)
+        File.delete(abs_doc_path) if not @doc_diff_ids.include?(doc_path) and File.exist?(abs_doc_path)
+        Dir.delete(abs_dir_path) if Dir.empty?(abs_dir_path)
+      end
+    end
+
+    def self.lowest_common_ancestor(parent_commit_1, parent_commit_2)
+      # keys are commit id, values are Array of number of hops
+      all_ancestors_of_parent_1 = self.gen_ancestor_set(parent_commit_1, Set.new, skip_first=true)
+      all_ancestors_of_parent_2 = self.gen_ancestor_set(parent_commit_2, Set.new, skip_first=true)
+
+      common_ancestors = all_ancestors_of_parent_1 & all_ancestors_of_parent_2
+      raise 'no common ancestors' if common_ancestors.size.zero?
+
+      while common_ancestors.size != 1
+        picked_ancestor = common_ancestors.first
+        ancestors_to_be_removed_set = gen_ancestor_set(picked_ancestor, Set.new, skip_first=true)
+        common_ancestors -= ancestors_to_be_removed_set
+      end
+
+      common_ancestors.first
+    end
+
+    # returns a tempfile with the content of the document at the recorded diff of commit.
+    def cat(file_path)
+      diff_id = doc_diff_ids[file_path]
+      return unless diff_id
+      Document.find(file_path).content_from(diff_id)
+    end
+
+    # Returns an array of ids, starting from self.id and
+    # through all left parents (parent 1).
+    def log
+      commits = [self]
+      this_commit = self
+      while this_commit.has_parent_1?
+        commits << this_commit.parent_1
+        this_commit = this_commit.parent_1
+      end
+      commits
+    end
+
+    def has_parent_1?
+      !!parent_id_1
+    end
+
+    def parent_1
+      return nil unless parent_id_1
+      @parent ||= self.class.find(parent_id_1)
+    end
+
+    def tracked_docs_md5
+      Document.find(doc_diff_ids.keys).each_with_object({}) do |doc, accum|
+        accum[doc.path] = doc.md5_at(doc_diff_ids[doc.path])
+      end
+    end
+
+    private
+
+    def self.db(repo_path = nil)
+      # in this pstore file, each key is a commit id
+      @db ||= PStore.new(File.join(Repository.path(repo_path), 'commits.pstore'))
+    end
+
+    def self.build_commit_id
+      Digest::MD5.hexdigest(Time.now.to_f.to_s)
+    end
+
+    def self.gen_ancestor_set(commit_id, commit_id_set, skip_first=false)
+      commit_id_set.add(commit_id) unless skip_first
+      commit = find(commit_id)
+
+      if commit.parent_id_1
+        commit_id_set = self.gen_ancestor_set(commit.parent_id_1, commit_id_set)
+      end
+      if commit.parent_id_2
+        commit_id_set = self.gen_ancestor_set(commit.parent_id_2, commit_id_set)
+      end
+      commit_id_set
+    end
+  end
+end