bringit 1.0.0

data/lib/bringit/commit_stats.rb

@@ -0,0 +1,24 @@
+# Bringit::CommitStats counts the additions, deletions, and total changes
+# in a commit.
+module Bringit
+  class CommitStats
+    attr_reader :id, :additions, :deletions, :total
+
+    # Instantiate a CommitStats object
+    def initialize(commit)
+      @id = commit.id
+      @additions = 0
+      @deletions = 0
+      @total = 0
+
+      diff = commit.diff_from_parent
+
+      diff.each_patch do |p|
+        # TODO: Use the new Rugged convenience methods when they're released
+        @additions += p.stat[0]
+        @deletions += p.stat[1]
+        @total += p.changes
+      end
+    end
+  end
+end

data/lib/bringit/committing.rb

@@ -0,0 +1,334 @@
+# frozen_string_literal: true
+
+require_relative "committing/merge"
+
+module Bringit
+  # Methods for committing. Use all these methods only mutexed with the git
+  # repository as the key.
+  module Committing
+    include Bringit::Committing::Merge
+
+    class Error < StandardError; end
+    class InvalidPathError < Error; end
+
+    # This error is thrown when attempting to commit on a branch whose HEAD has
+    # changed.
+    class HeadChangedError < Error
+      attr_reader :conflicts, :options
+      def initialize(message, conflicts, options)
+        super(message)
+        @conflicts = conflicts
+        @options = options
+      end
+    end
+
+    # Create a file in repository and return commit sha
+    #
+    # options should contain the following structure:
+    #   file: {
+    #     content: 'Lorem ipsum...',
+    #     path: 'documents/story.txt'
+    #   },
+    #   author: {
+    #     email: 'user@example.com',
+    #     name: 'Test User',
+    #     time: Time.now    # optional - default: Time.now
+    #   },
+    #   committer: {
+    #     email: 'user@example.com',
+    #     name: 'Test User',
+    #     time: Time.now    # optional - default: Time.now
+    #   },
+    #   commit: {
+    #     message: 'Wow such commit',
+    #     branch: 'master',    # optional - default: 'master'
+    #     update_ref: false    # optional - default: true
+    #   }
+    def create_file(options, previous_head_sha = nil)
+      commit_multichange(convert_options(options, :create), previous_head_sha)
+    end
+
+    # Change the contents of a file in repository and return commit sha
+    #
+    # options should contain the following structure:
+    #   file: {
+    #     content: 'Lorem ipsum...',
+    #     path: 'documents/story.txt'
+    #   },
+    #   author: {
+    #     email: 'user@example.com',
+    #     name: 'Test User',
+    #     time: Time.now    # optional - default: Time.now
+    #   },
+    #   committer: {
+    #     email: 'user@example.com',
+    #     name: 'Test User',
+    #     time: Time.now    # optional - default: Time.now
+    #   },
+    #   commit: {
+    #     message: 'Wow such commit',
+    #     branch: 'master',    # optional - default: 'master'
+    #     update_ref: false    # optional - default: true
+    #   }
+    def update_file(options, previous_head_sha = nil)
+      commit_multichange(convert_options(options, :update), previous_head_sha)
+    end
+
+    # Change contents and path of a file in repository and return commit sha
+    #
+    # options should contain the following structure:
+    #   file: {
+    #     content: 'Lorem ipsum...',
+    #     path: 'documents/story.txt',
+    #     previous_path: 'documents/old_story.txt'
+    #   },
+    #   author: {
+    #     email: 'user@example.com',
+    #     name: 'Test User',
+    #     time: Time.now    # optional - default: Time.now
+    #   },
+    #   committer: {
+    #     email: 'user@example.com',
+    #     name: 'Test User',
+    #     time: Time.now    # optional - default: Time.now
+    #   },
+    #   commit: {
+    #     message: 'Wow such commit',
+    #     branch: 'master',    # optional - default: 'master'
+    #     update_ref: false    # optional - default: true
+    #   }
+    def rename_and_update_file(options, previous_head_sha = nil)
+      commit_multichange(convert_options(options, :rename_and_update), previous_head_sha)
+    end
+
+    # Remove file from repository and return commit sha
+    #
+    # options should contain the following structure:
+    #   file: {
+    #     path: 'documents/story.txt'
+    #   },
+    #   author: {
+    #     email: 'user@example.com',
+    #     name: 'Test User',
+    #     time: Time.now    # optional - default: Time.now
+    #   },
+    #   committer: {
+    #     email: 'user@example.com',
+    #     name: 'Test User',
+    #     time: Time.now    # optional - default: Time.now
+    #   },
+    #   commit: {
+    #     message: 'Remove FILENAME',
+    #     branch: 'master'    # optional - default: 'master'
+    #   }
+    def remove_file(options, previous_head_sha = nil)
+      commit_multichange(convert_options(options, :remove), previous_head_sha)
+    end
+
+    # Rename file from repository and return commit sha
+    # This does not change the file content.
+    #
+    # options should contain the following structure:
+    #   file: {
+    #     previous_path: 'documents/old_story.txt'
+    #     path: 'documents/story.txt'
+    #   },
+    #   author: {
+    #     email: 'user@example.com',
+    #     name: 'Test User',
+    #     time: Time.now    # optional - default: Time.now
+    #   },
+    #   committer: {
+    #     email: 'user@example.com',
+    #     name: 'Test User',
+    #     time: Time.now    # optional - default: Time.now
+    #   },
+    #   commit: {
+    #     message: 'Rename FILENAME',
+    #     branch: 'master'    # optional - default: 'master'
+    #   }
+    #
+    def rename_file(options, previous_head_sha = nil)
+      commit_multichange(convert_options(options, :rename), previous_head_sha)
+    end
+
+    # Create a new directory with a .gitkeep file. Creates
+    # all required nested directories (i.e. mkdir -p behavior)
+    #
+    # options should contain the following structure:
+    #   author: {
+    #     email: 'user@example.com',
+    #     name: 'Test User',
+    #     time: Time.now    # optional - default: Time.now
+    #   },
+    #   committer: {
+    #     email: 'user@example.com',
+    #     name: 'Test User',
+    #     time: Time.now    # optional - default: Time.now
+    #   },
+    #   commit: {
+    #     message: 'Wow such commit',
+    #     branch: 'master',    # optional - default: 'master'
+    #     update_ref: false    # optional - default: true
+    #   }
+    def mkdir(path, options, previous_head_sha = nil)
+      options[:file] = {path: path}
+      commit_multichange(convert_options(options, :mkdir), previous_head_sha)
+    end
+
+    # Apply multiple file changes to the repository
+    #
+    # options should contain the following structure:
+    #   files: {
+    #     [{content: 'Lorem ipsum...',
+    #       path: 'documents/story.txt',
+    #       action: :create},
+    #      {content: 'New Lorem ipsum...',
+    #       path: 'documents/old_story',
+    #       action: :update},
+    #      {content: 'New Lorem ipsum...',
+    #       previous_path: 'documents/really_old_story.txt',
+    #       path: 'documents/old_story',
+    #       action: :rename_and_update},
+    #      {path: 'documents/obsolet_story.txt',
+    #       action: :remove},
+    #      {path: 'documents/old_story',
+    #       previus_path: 'documents/really_old_story.txt',
+    #       action: :rename},
+    #      {path: 'documents/secret',
+    #       action: :mkdir}
+    #     ]
+    #     }
+    #   },
+    #   author: {
+    #     email: 'user@example.com',
+    #     name: 'Test User',
+    #     time: Time.now    # optional - default: Time.now
+    #   },
+    #   committer: {
+    #     email: 'user@example.com',
+    #     name: 'Test User',
+    #     time: Time.now    # optional - default: Time.now
+    #   },
+    #   commit: {
+    #     message: 'Wow such commit',
+    #     branch: 'master',    # optional - default: 'master'
+    #     update_ref: false    # optional - default: true
+    #   }
+    def commit_multichange(options, previous_head_sha = nil)
+      commit_with(options, previous_head_sha) do |index|
+        options[:files].each do |file|
+          file_options = {}
+          file_options[:file_path] = file[:path] if file[:path]
+          file_options[:content] = file[:content] if file[:content]
+          file_options[:encoding] = file[:encoding] if file[:encoding]
+          case file[:action]
+          when :create
+            index.create(file_options)
+          when :rename
+            file_options[:previous_path] = file[:previous_path]
+            file_options[:content] ||=
+              blob(options[:commit][:branch], file[:previous_path]).data
+            index.move(file_options)
+          when :update
+            index.update(file_options)
+          when :rename_and_update
+            previous_path = file[:previous_path]
+            file_options[:previous_path] = previous_path
+            index.move(file_options)
+          when :remove
+            index.delete(file_options)
+          when :mkdir
+            index.create_dir(file_options)
+          end
+        end
+      end
+    end
+
+    protected
+
+
+    # Converts the options from a single change commit to a multi change
+    # commit.
+    def convert_options(options, action)
+      converted = options.dup
+      converted.delete(:file)
+      converted[:files] = [options[:file].merge(action: action)]
+      converted
+    end
+
+    def insert_defaults(options)
+      options[:author][:time] ||= Time.now
+      options[:committer][:time] ||= Time.now
+      options[:commit][:branch] ||= 'master'
+      options[:commit][:update_ref] = true if options[:commit][:update_ref].nil?
+      normalize_ref(options)
+      normalize_update_ref(options)
+    end
+
+    def normalize_ref(options)
+      return if options[:commit][:branch].start_with?('refs/')
+      options[:commit][:branch] = 'refs/heads/' + options[:commit][:branch]
+    end
+
+    def normalize_update_ref(options)
+      options[:commit][:update_ref] =
+        if options[:commit][:update_ref].nil?
+          true
+        else
+          options[:commit][:update_ref]
+        end
+    end
+
+    # This method does the actual committing. Use this mutexed with the git
+    # repository as the key.
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/MethodLength
+    def commit_with(options, previous_head_sha)
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/MethodLength
+      insert_defaults(options)
+      action, commit_sha = merge_if_needed(options, previous_head_sha)
+      return commit_sha if action == :merge_commit_created
+
+      index = Bringit::Index.new(bringit)
+      parents, last_commit = parents_and_last_commit(options)
+      index.read_tree(last_commit.tree) if last_commit
+
+      yield(index)
+      create_commit(index, index.write_tree, options, parents)
+    end
+
+    def parents_and_last_commit(options)
+      parents = []
+      last_commit = nil
+      unless empty?
+        rugged_ref = rugged.references[options[:commit][:branch]]
+        unless rugged_ref
+          raise Bringit::Repository::InvalidRef, 'Invalid branch name'
+        end
+        last_commit = rugged_ref.target
+        parents = [last_commit]
+      end
+      [parents, last_commit]
+    end
+
+    def create_commit(index, tree, options, parents)
+      opts = {}
+      opts[:tree] = tree
+      opts[:author] = options[:author]
+      opts[:committer] = options[:committer]
+      opts[:message] = options[:commit][:message]
+      opts[:parents] = parents
+      if options[:commit][:update_ref]
+        opts[:update_ref] = options[:commit][:branch]
+      end
+
+      Rugged::Commit.create(rugged, opts)
+    end
+  end
+end

data/lib/bringit/committing/merge.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Bringit
+  module Committing
+    # Methods for merging a commit into another if the previous_head_sha is
+    # an ancestor of the current HEAD of a branch.
+    module Merge
+      def merge_if_needed(options, previous_head_sha)
+        return [:noop, nil] unless diverged?(options, previous_head_sha)
+
+        commit_sha = merge(options, previous_head_sha)
+        return [:merge_commit_created, commit_sha]
+      end
+
+      def diverged?(options, previous_head_sha)
+        !previous_head_sha.nil? &&
+          branch_sha(options[:commit][:branch]) != previous_head_sha
+      end
+
+      def merge(options, previous_head_sha)
+        user_commit = create_user_commit(options, previous_head_sha)
+        base_commit = commit(options[:commit][:branch]).raw_commit
+
+        index = rugged.merge_commits(base_commit, user_commit)
+
+        if index.conflicts?
+          enriched_conflicts = add_merge_data(options, index)
+          raise_head_changed_error(enriched_conflicts, options)
+        end
+        tree_id = index.write_tree(rugged)
+        found_conflicts = conflicts(options, base_commit, user_commit)
+        if found_conflicts.any?
+          raise_head_changed_error(found_conflicts, options)
+        end
+        create_merging_commit(base_commit, index, tree_id, options)
+      end
+
+      def add_merge_data(options, index)
+        our_label = options[:commit][:branch].sub(%r{\Arefs/heads/}, '')
+        index.conflicts.map do |conflict|
+          if conflict[:ancestor] && conflict[:ours] && conflict[:theirs]
+            conflict[:merge_info] =
+              index.merge_file(conflict[:ours][:path],
+                                ancestor_label: 'parent',
+                                our_label: our_label,
+                                their_label: options[:commit][:message])
+          else
+            conflict[:merge_info] = nil
+          end
+          conflict
+        end
+      end
+
+      def conflicts(options, base_commit, user_commit)
+        options[:files].map do |file|
+          case file[:action]
+          when :update
+            conflict_on_update(base_commit, user_commit, file[:path])
+          when :rename_and_update
+            conflict_on_update(base_commit, user_commit, file[:previous_path])
+          end
+        end.compact
+      end
+
+      def conflict_on_update(base_commit, user_commit, path)
+        base_blob = blob(base_commit.oid, path)
+        return nil unless base_blob.nil?
+
+        ancestor_blob = blob(base_commit.parents.first.oid, path)
+        user_blob = blob(user_commit.oid, path)
+        result = {merge_info: nil, ours: nil}
+        result[:ancestor] = conflict_hash(ancestor_blob, 1) if ancestor_blob
+        result[:theirs] = conflict_hash(user_blob, 3) if user_blob
+        result
+      end
+
+      def conflict_hash(blob_object, stage)
+        {path: blob_object.path,
+          oid: blob_object.id,
+          dev: 0,
+          ino: 0,
+          mode: blob_object.mode.to_i(8),
+          gid: 0,
+          uid: 0,
+          file_size: 0,
+          valid: false,
+          stage: stage,
+          ctime: Time.at(0),
+          mtime: Time.at(0)}
+      end
+
+      def create_user_commit(options, previous_head_sha)
+        with_temp_user_reference(options, previous_head_sha) do |reference|
+          new_options = options.dup
+          new_options[:commit] = options[:commit].dup
+          new_options[:commit][:branch] = reference.name
+          new_options[:commit][:update_ref] = false
+          commit_sha = commit_multichange(new_options)
+          rugged.lookup(commit_sha)
+        end
+      end
+
+      def with_temp_user_reference(options, previous_head_sha)
+        refname = "#{Time.now.to_f.to_s.tr('.', '')}_#{SecureRandom.hex(20)}"
+        full_refname = "refs/merges/user/#{refname}"
+        reference = rugged.references.create(full_refname, previous_head_sha)
+        yield(reference)
+      ensure
+        rugged.references.delete(reference)
+      end
+
+      def create_merging_commit(parent_commit, index, tree_id, options)
+        parents = [parent_commit.oid]
+        create_commit(index, tree_id, options, parents)
+      end
+
+      def raise_head_changed_error(conflicts, options)
+        message = <<MESSAGE
+The branch has changed since editing and cannot be merged automatically.
+MESSAGE
+        raise HeadChangedError.new(message, conflicts, options)
+      end
+    end
+  end
+end