bringit 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: be4c0173cdf310733872d3c191685be11d84ad75
+  data.tar.gz: '0096d31422d89baaa73df9475dac864c6166b91e'
+SHA512:
+  metadata.gz: 2fb3f7d165f9ad42a5ca4880034d0dc613bd78c9ff5020e1c5bbc9439d3e12670475862b37f8dc9831f96d3fc7bae4c3cde6194756351dc6e3e0ffe63c3d0a81
+  data.tar.gz: '08ba4d74431dee2c8a077b26dba6667d19704daf415d8fe06db5f1ae8f0009f3b8e28956310e744bba68d8d29e4e493aea96e5ac37d6f8569ccc9f78983f935e'

data/lib/bringit.rb

@@ -0,0 +1,96 @@
+# Libraries
+require 'ostruct'
+require 'fileutils'
+require 'linguist'
+require 'active_support/core_ext/hash/compact'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/hash/slice'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/object/try'
+require 'active_support/core_ext/module/delegation'
+require 'rugged'
+require "charlock_holmes"
+
+# Bringit
+require_relative "bringit/popen"
+require_relative 'bringit/encoding_helper'
+require_relative 'bringit/path_helper'
+require_relative "bringit/blame"
+require_relative "bringit/blob"
+require_relative "bringit/commit"
+require_relative "bringit/commit_stats"
+require_relative "bringit/compare"
+require_relative "bringit/diff"
+require_relative "bringit/diff_collection"
+require_relative "bringit/hook"
+require_relative "bringit/index"
+require_relative "bringit/rev_list"
+require_relative "bringit/repository"
+require_relative "bringit/tree"
+require_relative "bringit/blob_snippet"
+require_relative "bringit/ref"
+require_relative "bringit/branch"
+require_relative "bringit/tag"
+require_relative "bringit/util"
+require_relative "bringit/attributes"
+require_relative "bringit/version_info"
+require_relative "bringit/committing"
+require_relative "bringit/cloning"
+require_relative "bringit/pulling"
+require_relative "bringit/wrapper"
+
+module Bringit
+  BLANK_SHA = ('0' * 40).freeze
+  TAG_REF_PREFIX = "refs/tags/".freeze
+  BRANCH_REF_PREFIX = "refs/heads/".freeze
+
+  class << self
+    def ref_name(ref)
+      ref.sub(/\Arefs\/(tags|heads)\//, '')
+    end
+
+    def branch_name(ref)
+      ref = ref.to_s
+      if self.branch_ref?(ref)
+        self.ref_name(ref)
+      else
+        nil
+      end
+    end
+
+    def committer_hash(email:, name:)
+      return if email.nil? || name.nil?
+
+      {
+        email: email,
+        name: name,
+        time: Time.now
+      }
+    end
+
+    def tag_name(ref)
+      ref = ref.to_s
+      if self.tag_ref?(ref)
+        self.ref_name(ref)
+      else
+        nil
+      end
+    end
+
+    def tag_ref?(ref)
+      ref.start_with?(TAG_REF_PREFIX)
+    end
+
+    def branch_ref?(ref)
+      ref.start_with?(BRANCH_REF_PREFIX)
+    end
+
+    def blank_ref?(ref)
+      ref == BLANK_SHA
+    end
+
+    def version
+      Bringit::VersionInfo.parse(Bringit::Popen.popen(%W(git --version)).first)
+    end
+  end
+end

data/lib/bringit/attributes.rb

@@ -0,0 +1,129 @@
+module Bringit
+  # Class for parsing Git attribute files and extracting the attributes for
+  # file patterns.
+  #
+  # Unlike Rugged this parser only needs a single IO call (a call to `open`),
+  # vastly reducing the time spent in extracting attributes.
+  #
+  # This class _only_ supports parsing the attributes file located at
+  # `$GIT_DIR/info/attributes` as GitLab doesn't use any other files
+  # (`.gitattributes` is copied to this particular path).
+  #
+  # Basic usage:
+  #
+  #     attributes = Bringit::Attributes.new(some_repo.path)
+  #
+  #     attributes.attributes('README.md') # => { "eol" => "lf }
+  class Attributes
+    # path - The path to the Git repository.
+    def initialize(path)
+      @path = File.expand_path(path)
+      @patterns = nil
+    end
+
+    # Returns all the Git attributes for the given path.
+    #
+    # path - A path to a file for which to get the attributes.
+    #
+    # Returns a Hash.
+    def attributes(path)
+      full_path = File.join(@path, path)
+
+      patterns.each do |pattern, attrs|
+        return attrs if File.fnmatch?(pattern, full_path)
+      end
+
+      {}
+    end
+
+    # Returns a Hash containing the file patterns and their attributes.
+    def patterns
+      @patterns ||= parse_file
+    end
+
+    # Parses an attribute string.
+    #
+    # These strings can be in the following formats:
+    #
+    #     text      # => { "text" => true }
+    #     -text     # => { "text" => false }
+    #     key=value # => { "key" => "value" }
+    #
+    # string - The string to parse.
+    #
+    # Returns a Hash containing the attributes and their values.
+    def parse_attributes(string)
+      values = {}
+      dash = '-'
+      equal = '='
+      binary = 'binary'
+
+      string.split(/\s+/).each do |chunk|
+        # Data such as "foo = bar" should be treated as "foo" and "bar" being
+        # separate boolean attributes.
+        next if chunk == equal
+
+        key = chunk
+
+        # Input: "-foo"
+        if chunk.start_with?(dash)
+          key = chunk.byteslice(1, chunk.length - 1)
+          value = false
+
+        # Input: "foo=bar"
+        elsif chunk.include?(equal)
+          key, value = chunk.split(equal, 2)
+
+        # Input: "foo"
+        else
+          value = true
+        end
+
+        values[key] = value
+
+        # When the "binary" option is set the "diff" option should be set to
+        # the inverse. If "diff" is later set it should overwrite the
+        # automatically set value.
+        values['diff'] = false if key == binary && value
+      end
+
+      values
+    end
+
+    # Iterates over every line in the attributes file.
+    def each_line
+      full_path = File.join(@path, 'info/attributes')
+
+      return unless File.exist?(full_path)
+
+      File.open(full_path, 'r') do |handle|
+        handle.each_line do |line|
+          break unless line.valid_encoding?
+
+          yield line.strip
+        end
+      end
+    end
+
+    private
+
+    # Parses the Git attributes file.
+    def parse_file
+      pairs = []
+      comment = '#'
+
+      each_line do |line|
+        next if line.start_with?(comment) || line.empty?
+
+        pattern, attrs = line.split(/\s+/, 2)
+
+        parsed = attrs ? parse_attributes(attrs) : {}
+
+        pairs << [File.join(@path, pattern), parsed]
+      end
+
+      # Newer entries take precedence over older entries.
+      pairs.reverse.to_h
+    end
+  end
+end

data/lib/bringit/blame.rb

@@ -0,0 +1,73 @@
+module Bringit
+  class Blame
+    include Bringit::EncodingHelper
+
+    attr_reader :lines, :blames
+
+    def initialize(repository, sha, path)
+      @repo = repository
+      @sha = sha
+      @path = path
+      @lines = []
+      @blames = load_blame
+    end
+
+    def each
+      @blames.each do |blame|
+        yield(
+          Bringit::Commit.new(blame.commit, @repo),
+          blame.line
+        )
+      end
+    end
+
+    private
+
+    def load_blame
+      cmd = %W(git --git-dir=#{@repo.path} blame -p #{@sha} -- #{@path})
+      # Read in binary mode to ensure ASCII-8BIT
+      raw_output = IO.popen(cmd, 'rb') {|io| io.read }
+      output = encode_utf8(raw_output)
+      process_raw_blame output
+    end
+
+    def process_raw_blame(output)
+      lines, final = [], []
+      info, commits = {}, {}
+
+      # process the output
+      output.split("\n").each do |line|
+        if line[0, 1] == "\t"
+          lines << line[1, line.size]
+        elsif m = /^(\w{40}) (\d+) (\d+)/.match(line)
+          commit_id, old_lineno, lineno = m[1], m[2].to_i, m[3].to_i
+          commits[commit_id] = nil unless commits.key?(commit_id)
+          info[lineno] = [commit_id, old_lineno]
+        end
+      end
+
+      # load all commits in single call
+      commits.keys.each do |key|
+        commits[key] = @repo.lookup(key)
+      end
+
+      # get it together
+      info.sort.each do |lineno, (commit_id, old_lineno)|
+        commit = commits[commit_id]
+        final << BlameLine.new(lineno, old_lineno, commit, lines[lineno - 1])
+      end
+
+      @lines = final
+    end
+  end
+
+  class BlameLine
+    attr_accessor :lineno, :oldlineno, :commit, :line
+    def initialize(lineno, oldlineno, commit, line)
+      @lineno = lineno
+      @oldlineno = oldlineno
+      @commit = commit
+      @line = line
+    end
+  end
+end

data/lib/bringit/blob.rb

@@ -0,0 +1,175 @@
+module Bringit
+  class Blob
+    include Linguist::BlobHelper
+    include Bringit::EncodingHelper
+
+    # This number is the maximum amount of data that we want to display to
+    # the user. We load as much as we can for encoding detection
+    # (Linguist) and LFS pointer parsing. All other cases where we need full
+    # blob data should use load_all_data!.
+    MAX_DATA_DISPLAY_SIZE = 10485760
+
+    attr_reader :repository
+    attr_accessor :name, :path, :size, :data, :mode, :id, :commit_id, :loaded_size, :binary
+
+    class << self
+      def find(repository, sha, path)
+        path = path&.sub(%r{\A/*}, '')
+        commit = repository.lookup(sha)
+        root_tree = commit.tree
+
+        blob_entry = find_entry_by_path(repository, root_tree.oid, path)
+
+        return nil unless blob_entry
+
+        if blob_entry[:type] == :commit
+          submodule_blob(repository, blob_entry, path, sha)
+        else
+          blob = repository.lookup(blob_entry[:oid])
+
+          if blob
+            new(repository,
+              id: blob.oid,
+              name: blob_entry[:name],
+              size: blob.size,
+              data: blob.content(MAX_DATA_DISPLAY_SIZE),
+              mode: blob_entry[:filemode].to_s(8),
+              path: Bringit::PathHelper.normalize_path(path).to_s,
+              commit_id: sha,
+              binary: blob.binary?
+            )
+          end
+        end
+      end
+
+      def raw(repository, sha)
+        blob = repository.lookup(sha)
+
+        new(repository,
+          id: blob.oid,
+          size: blob.size,
+          data: blob.content(MAX_DATA_DISPLAY_SIZE),
+          binary: blob.binary?
+        )
+      end
+
+      # Recursive search of blob id by path
+      #
+      # Ex.
+      #   blog/            # oid: 1a
+      #     app/           # oid: 2a
+      #       models/      # oid: 3a
+      #       file.rb      # oid: 4a
+      #
+      #
+      # Blob.find_entry_by_path(repo, '1a', 'app/file.rb') # => '4a'
+      #
+      def find_entry_by_path(repository, root_id, path)
+        root_tree = repository.lookup(root_id)
+        # Strip leading slashes
+        path = path.sub(%r{\A/*}, '')
+        path_arr = path.split('/')
+
+        entry = root_tree.find do |entry|
+          entry[:name] == path_arr[0]
+        end
+
+        return nil unless entry
+
+        if path_arr.size > 1
+          return nil unless entry[:type] == :tree
+          path_arr.shift
+          find_entry_by_path(repository, entry[:oid], path_arr.join('/'))
+        else
+          [:blob, :commit].include?(entry[:type]) ? entry : nil
+        end
+      end
+
+      def submodule_blob(repository, blob_entry, path, sha)
+        path = path&.sub(%r{\A/*}, '')
+        new(repository,
+          id: blob_entry[:oid],
+          name: blob_entry[:name],
+          data: '',
+          path: path,
+          commit_id: sha,
+        )
+      end
+    end
+
+    def initialize(repository, options)
+      @repository = repository
+      %w(id name path size data mode commit_id binary).each do |key|
+        self.send("#{key}=", options[key.to_sym])
+      end
+
+      @loaded_all_data = false
+      # Retain the actual size before it is encoded
+      @loaded_size = @data.bytesize if @data
+    end
+
+    def binary?
+      @binary.nil? ? super : @binary == true
+    end
+
+    def empty?
+      !data || data == ''
+    end
+
+    def data
+      encode! @data
+    end
+
+    # Load all blob data (not just the first MAX_DATA_DISPLAY_SIZE bytes) into
+    # memory as a Ruby string.
+    def load_all_data!
+      return if @data == '' # don't mess with submodule blobs
+      return @data if @loaded_all_data
+
+      @loaded_all_data = true
+      @data = repository.lookup(id).content
+      @loaded_size = @data.bytesize
+    end
+
+    def name
+      encode! @name
+    end
+
+    # Valid LFS object pointer is a text file consisting of
+    # version
+    # oid
+    # size
+    # see https://github.com/github/git-lfs/blob/v1.1.0/docs/spec.md#the-pointer
+    def lfs_pointer?
+      has_lfs_version_key? && lfs_oid.present? && lfs_size.present?
+    end
+
+    def lfs_oid
+      if has_lfs_version_key?
+        oid = data.match(/(?<=sha256:)([0-9a-f]{64})/)
+        return oid[1] if oid
+      end
+
+      nil
+    end
+
+    def lfs_size
+      if has_lfs_version_key?
+        size = data.match(/(?<=size )([0-9]+)/)
+        return size[1] if size
+      end
+
+      nil
+    end
+
+    def truncated?
+      size && (size > loaded_size)
+    end
+
+    private
+
+    def has_lfs_version_key?
+      !empty? && text? && data.start_with?("version https://git-lfs.github.com/spec")
+    end
+  end
+end