gitlab_git 7.0.0.rc12 → 7.0.0.rc13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 44a52af0f3a9985bae1ccd85e7cb074682d8b691
-  data.tar.gz: 26e8ffbe31ae2baa9880ba82c568baed3188dd98
+  metadata.gz: f86d9c6e73cb52a8f31d29324a44392a2553ba05
+  data.tar.gz: 0576273f835e885e8959be448057bc4021b443ee
 SHA512:
-  metadata.gz: 04c93841365a6bf23042e5e495189c6dd134047cf54219dcf7cc4aa72b1936da99f2b63cebbbbdb2041005f1a25815d3bf53ecae66660a942e3ea55efdb2e57e
-  data.tar.gz: 794f208951447ba3a5cb71a0908b94e4786a6149f19a31b70072ca65cdb43f4770ab1387769df4374761b89a786c1d1370139faa3c895b23f61103f0d7b0400c
+  metadata.gz: 94e6049f197b94027436e028c9d19f835a06146e3020c6c3cf537cd13cb458322324af04ae38a11fd5f3d77bf880f494de3028600f2bfd6ec6f4eb4c8ec70848
+  data.tar.gz: 6b01cb8f1debacf1b7df04d45a801325ba23d967f5f80c8b3e3a0615e25ca3031c155697829fd71add957b7963dac0199067490213a12bdd0c50b2042960eef9

data/VERSION

@@ -1 +1 @@
-7.0.0.rc12
+7.0.0.rc13

data/lib/gitlab_git/commit.rb

@@ -108,6 +108,25 @@ module Gitlab
         def decorate(commit, ref = nil)
           Gitlab::Git::Commit.new(commit, ref)
         end
+
+        # Returns a diff object for the changes introduced by +rugged_commit+.
+        # If +rugged_commit+ doesn't have a parent, then the diff is between
+        # this commit and an empty repo.  See Repository#diff for the keys
+        # allowed in the +options+ hash.
+        def diff_from_parent(rugged_commit, options = {})
+          options ||= {}
+          break_rewrites = options[:break_rewrites]
+          actual_options = Diff.filter_diff_options(options)
+
+          if rugged_commit.parents.empty?
+            diff = rugged_commit.diff(actual_options.merge(reverse: true))
+          else
+            diff = rugged_commit.parents[0].diff(rugged_commit, actual_options)
+          end
+
+          diff.find_similar!(break_rewrites: break_rewrites)
+          diff
+        end
       end
 
       def initialize(raw_commit, head = nil)
@@ -152,8 +171,8 @@ module Gitlab
       # Shows the diff between the commit's parent and the commit.
       #
       # Cuts out the header and stats from #to_patch and returns only the diff.
-      def to_diff
-        patch = to_patch
+      def to_diff(options = {})
+        patch = to_patch(options)
 
         # discard lines before the diff
         lines = patch.split("\n")
@@ -167,13 +186,10 @@ module Gitlab
 
       # Returns a diff object for the changes from this commit's first parent.
       # If there is no parent, then the diff is between this commit and an
-      # empty repo.
-      def diff_from_parent
-        if raw_commit.parents.empty?
-          raw_commit.diff(reverse: true)
-        else
-          raw_commit.parents[0].diff(raw_commit)
-        end
+      # empty repo.  See Repository#diff for keys allowed in the +options+
+      # hash.
+      def diff_from_parent(options = {})
+        Commit.diff_from_parent(raw_commit, options)
       end
 
       def has_zero_stats?
@@ -196,8 +212,8 @@ module Gitlab
         committed_date
       end
 
-      def diffs
-        diff_from_parent.map { |diff| Gitlab::Git::Diff.new(diff) }
+      def diffs(options = {})
+        diff_from_parent(options).map { |diff| Gitlab::Git::Diff.new(diff) }
       end
 
       def parents
@@ -212,8 +228,8 @@ module Gitlab
         Gitlab::Git::CommitStats.new(self)
       end
 
-      def to_patch
-        raw_commit.to_mbox
+      def to_patch(options = {})
+        raw_commit.to_mbox(options)
       end
 
       # Get a collection of Rugged::Reference objects for this commit.

data/lib/gitlab_git/compare.rb

@@ -24,7 +24,7 @@ module Gitlab
         @commits = Gitlab::Git::Commit.between(repository, @base.id, @head.id)
       end
 
-      def diffs(paths = nil)
+      def diffs(paths = nil, options = {})
         unless @head && @base
           return []
         end
@@ -33,7 +33,8 @@ module Gitlab
         # Otherwise return cached version
         if @diffs.empty? && @timeout == false
           begin
-            @diffs = Gitlab::Git::Diff.between(@repository, @head.id, @base.id, *paths)
+            @diffs = Gitlab::Git::Diff.between(@repository, @head.id, @base.id,
+                                               options, *paths)
           rescue Gitlab::Git::Diff::TimeoutError => ex
             @diffs = []
             @timeout = true

data/lib/gitlab_git/diff.rb

@@ -12,13 +12,146 @@ module Gitlab
       attr_accessor  :new_file, :renamed_file, :deleted_file
 
       class << self
-        def between(repo, head, base, *paths)
+        def between(repo, head, base, options = {}, *paths)
           # Only show what is new in the source branch compared to the target branch, not the other way around.
           # The linex below with merge_base is equivalent to diff with three dots (git diff branch1...branch2)
           # From the git documentation: "git diff A...B" is equivalent to "git diff $(git-merge-base A B) B"
           common_commit = repo.merge_base_commit(head, base)
 
-          repo.diff(common_commit, head, *paths)
+          options ||= {}
+          break_rewrites = options[:break_rewrites]
+          actual_options = filter_diff_options(options)
+          repo.diff(common_commit, head, actual_options, *paths)
+        end
+
+        # Return a copy of the +options+ hash containing only keys that can be
+        # passed to Rugged.  Allowed options are:
+        #
+        #  :max_size ::
+        #    An integer specifying the maximum byte size of a file before a it
+        #    will be treated as binary. The default value is 512MB.
+        #
+        #  :context_lines ::
+        #    The number of unchanged lines that define the boundary of a hunk
+        #    (and to display before and after the actual changes). The default is
+        #    3.
+        #
+        #  :interhunk_lines ::
+        #    The maximum number of unchanged lines between hunk boundaries before
+        #    the hunks will be merged into a one. The default is 0.
+        #
+        #  :old_prefix ::
+        #    The virtual "directory" to prefix to old filenames in hunk headers.
+        #    The default is "a".
+        #
+        #  :new_prefix ::
+        #    The virtual "directory" to prefix to new filenames in hunk headers.
+        #    The default is "b".
+        #
+        #  :reverse ::
+        #    If true, the sides of the diff will be reversed.
+        #
+        #  :force_text ::
+        #    If true, all files will be treated as text, disabling binary
+        #    attributes & detection.
+        #
+        #  :ignore_whitespace ::
+        #    If true, all whitespace will be ignored.
+        #
+        #  :ignore_whitespace_change ::
+        #    If true, changes in amount of whitespace will be ignored.
+        #
+        #  :ignore_whitespace_eol ::
+        #    If true, whitespace at end of line will be ignored.
+        #
+        #  :ignore_submodules ::
+        #    if true, submodules will be excluded from the diff completely.
+        #
+        #  :patience ::
+        #    If true, the "patience diff" algorithm will be used (currenlty
+        #    unimplemented).
+        #
+        #  :include_ignored ::
+        #    If true, ignored files will be included in the diff.
+        #
+        #  :include_untracked ::
+        #   If true, untracked files will be included in the diff.
+        #
+        #  :include_unmodified ::
+        #    If true, unmodified files will be included in the diff.
+        #
+        #  :recurse_untracked_dirs ::
+        #    Even if +:include_untracked+ is true, untracked directories will
+        #    only be marked with a single entry in the diff. If this flag is set
+        #    to true, all files under ignored directories will be included in the
+        #    diff, too.
+        #
+        #  :disable_pathspec_match ::
+        #    If true, the given +*paths+ will be applied as exact matches,
+        #    instead of as fnmatch patterns.
+        #
+        #  :deltas_are_icase ::
+        #    If true, filename comparisons will be made with case-insensitivity.
+        #
+        #  :include_untracked_content ::
+        #    if true, untracked content will be contained in the the diff patch
+        #    text.
+        #
+        #  :skip_binary_check ::
+        #    If true, diff deltas will be generated without spending time on
+        #    binary detection. This is useful to improve performance in cases
+        #    where the actual file content difference is not needed.
+        #
+        #  :include_typechange ::
+        #    If true, type changes for files will not be interpreted as deletion
+        #    of the "old file" and addition of the "new file", but will generate
+        #    typechange records.
+        #
+        #  :include_typechange_trees ::
+        #    Even if +:include_typechange+ is true, blob -> tree changes will
+        #    still usually be handled as a deletion of the blob. If this flag is
+        #    set to true, blob -> tree changes will be marked as typechanges.
+        #
+        #  :ignore_filemode ::
+        #    If true, file mode changes will be ignored.
+        #
+        #  :recurse_ignored_dirs ::
+        #    Even if +:include_ignored+ is true, ignored directories will only be
+        #    marked with a single entry in the diff. If this flag is set to true,
+        #    all files under ignored directories will be included in the diff,
+        #    too.
+        def filter_diff_options(options, default_options = {})
+          allowed_options = [:max_size, :context_lines, :interhunk_lines,
+                             :old_prefix, :new_prefix, :reverse, :force_text,
+                             :ignore_whitespace, :ignore_whitespace_change,
+                             :ignore_whitespace_eol, :ignore_submodules,
+                             :patience, :include_ignored, :include_untracked,
+                             :include_unmodified, :recurse_untracked_dirs,
+                             :disable_pathspec_match, :deltas_are_icase,
+                             :include_untracked_content, :skip_binary_check,
+                             :include_typechange, :include_typechange_trees,
+                             :ignore_filemode, :recurse_ignored_dirs, :paths]
+
+          if default_options
+            actual_defaults = default_options.dup
+            actual_defaults.keep_if do |key|
+              allowed_options.include?(key)
+            end
+          else
+            actual_defaults = {}
+          end
+
+          if options
+            filtered_opts = options.dup
+            filtered_opts.keep_if do |key|
+              allowed_options.include?(key)
+            end
+            filtered_opts = actual_defaults.merge(filtered_opts)
+          else
+            filtered_opts = actual_defaults
+          end
+
+          filtered_opts
         end
       end
 

data/lib/gitlab_git/repository.rb

@@ -11,6 +11,7 @@ module Gitlab
       SEARCH_CONTEXT_LINES = 3
 
       class NoRepository < StandardError; end
+      class InvalidBlobName < StandardError; end
 
       # Default branch in the repository
       attr_accessor :root_ref
@@ -265,19 +266,22 @@ module Gitlab
       end
 
       # Return an array of Diff objects that represent the diff
-      # between +from+ and +to+.
-      def diff(from, to, *paths)
-        rugged.diff(from, to, paths: paths).each_patch.map do |p|
+      # between +from+ and +to+.  See Diff::filter_diff_options for the allowed
+      # diff options.  The +options+ hash can also include :break_rewrites to
+      # split larger rewrites into delete/add pairs.
+      def diff(from, to, options = {}, *paths)
+        diff_patches(from, to, options, *paths).map do |p|
           Gitlab::Git::Diff.new(p)
         end
       end
 
-      # Return the diff between +from+ and +to+ in a single patch string.
-      def diff_text(from, to, *paths)
+      # Return the diff between +from+ and +to+ in a single patch string.  The
+      # +options+ hash has the same allowed keys as #diff.
+      def diff_text(from, to, options = {}, *paths)
         # NOTE: It would be simpler to use the Rugged::Diff#patch method, but
         # that formats the diff text differently than Rugged::Patch#to_s for
         # changes to binary files.
-        rugged.diff(from, to, paths: paths).each_patch.map do |p|
+        diff_patches(from, to, options, *paths).map do |p|
           p.to_s
         end.join("\n")
       end
@@ -416,7 +420,12 @@ module Gitlab
       def submodules(ref)
         commit = rugged.rev_parse(ref)
 
-        content = blob_content(commit, ".gitmodules")
+        begin
+          content = blob_content(commit, ".gitmodules")
+        rescue InvalidBlobName
+          return {}
+        end
+
         parse_gitmodules(commit, content)
       end
 
@@ -658,13 +667,16 @@ module Gitlab
       end
 
       # Return a String containing the mbox-formatted diff between +from+ and
-      # +to+
-      def format_patch(from, to)
-        rugged.diff(from, to).patch
+      # +to+.  See #diff for the allowed keys in the +options+ hash.
+      def format_patch(from, to, options = {})
+        options ||= {}
+        break_rewrites = options[:break_rewrites]
+        actual_options = Diff.filter_diff_options(options)
+
         from_sha = rugged.rev_parse_oid(from)
         to_sha = rugged.rev_parse_oid(to)
         commits_between(from_sha, to_sha).map do |commit|
-          commit.to_mbox
+          commit.to_mbox(actual_options)
         end.join("\n")
       end
 
@@ -724,6 +736,10 @@ module Gitlab
       def blob_content(commit, blob_name)
         blob_entry = tree_entry(commit, blob_name)
 
+        unless blob_entry
+          raise InvalidBlobName.new("Invalid blob name: #{blob_name}")
+        end
+
         if blob_entry[:type] == :commit
           blob_entry[:oid]
         else
@@ -742,11 +758,16 @@ module Gitlab
             current = txt.match(/(?<=").*(?=")/)[0]
             results[current] = {}
           else
+            next unless results[current]
             match_data = txt.match(/(\w+)\s*=\s*(.*)/)
             results[current][match_data[1]] = match_data[2]
 
             if match_data[1] == "path"
-              results[current]["id"] = blob_content(commit, match_data[2])
+              begin
+                results[current]["id"] = blob_content(commit, match_data[2])
+              rescue InvalidBlobName
+                results.delete(current)
+              end
             end
           end
         end
@@ -985,6 +1006,17 @@ module Gitlab
 
         greps
       end
+
+      # Return the Rugged patches for the diff between +from+ and +to+.
+      def diff_patches(from, to, options = {}, *paths)
+        options ||= {}
+        break_rewrites = options[:break_rewrites]
+        actual_options = Diff.filter_diff_options(options.merge(paths: paths))
+
+        diff = rugged.diff(from, to, actual_options)
+        diff.find_similar!(break_rewrites: break_rewrites)
+        diff.each_patch
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gitlab_git
 version: !ruby/object:Gem::Version
-  version: 7.0.0.rc12
+  version: 7.0.0.rc13
 platform: ruby
 authors:
 - Dmitriy Zaporozhets
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-18 00:00:00.000000000 Z
+date: 2014-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gitlab-linguist