lg_pod_plugin 1.0.8 → 1.0.10

data/lib/git/branch.rb

@@ -1,126 +0,0 @@
-require 'git/path'
-
-module Git
-
-  class Branch < Path
-    
-    attr_accessor :full, :remote, :name
-    
-    def initialize(base, name)
-      @full = name
-      @base = base
-      @gcommit = nil
-      @stashes = nil
-      @remote, @name = parse_name(name)
-    end
-    
-    def gcommit
-      @gcommit ||= @base.gcommit(@full)
-      @gcommit
-    end
-    
-    def stashes
-      @stashes ||= Git::Stashes.new(@base)
-    end
-    
-    def checkout
-      check_if_create
-      @base.checkout(@full)
-    end
-    
-    def archive(file, opts = {})
-      @base.lib.archive(@full, file, opts)
-    end
-    
-    # g.branch('new_branch').in_branch do
-    #   # create new file
-    #   # do other stuff
-    #   return true # auto commits and switches back
-    # end
-    def in_branch(message = 'in branch work')
-      old_current = @base.lib.branch_current
-      checkout
-      if yield
-        @base.commit_all(message)
-      else
-        @base.reset_hard
-      end
-      @base.checkout(old_current)
-    end
-    
-    def create
-      check_if_create
-    end
-    
-    def delete
-      @base.lib.branch_delete(@name)
-    end
-    
-    def current
-      determine_current
-    end
-    
-    def contains?(commit)
-      !@base.lib.branch_contains(commit, self.name).empty?
-    end
-    
-    def merge(branch = nil, message = nil)
-      if branch
-        in_branch do 
-          @base.merge(branch, message)
-          false
-        end
-        # merge a branch into this one
-      else
-        # merge this branch into the current one
-        @base.merge(@name)
-      end
-    end
-    
-    def update_ref(commit)
-      @base.lib.update_ref(@full, commit)
-    end
-    
-    def to_a
-      [@full]
-    end
-    
-    def to_s
-      @full
-    end
-    
-    private 
-
-      def check_if_create
-        @base.lib.branch_new(@name) rescue nil
-      end
-      
-      def determine_current
-        @base.lib.branch_current == @name
-      end
-    
-      # Given a full branch name return an Array containing the remote and branch names.
-      #
-      # Removes 'remotes' from the beggining of the name (if present).
-      # Takes the second part (splittign by '/') as the remote name.
-      # Takes the rest as the repo name (can also hold one or more '/').
-      #
-      # Example:
-      #   parse_name('master') #=> [nil, 'master']
-      #   parse_name('origin/master') #=> ['origin', 'master']
-      #   parse_name('remotes/origin/master') #=> ['origin', 'master']
-      #   parse_name('origin/master/v2') #=> ['origin', 'master/v2'] 
-      #
-      # param [String] name branch full name.
-      # return [<Git::Remote,NilClass,String>] an Array containing the remote and branch names. 
-      def parse_name(name)
-        if name.match(/^(?:remotes)?\/([^\/]+)\/(.+)/)
-          return [Git::Remote.new(@base, $1), $2]
-        end
-
-        return [nil, name]
-      end
-    
-  end
-  
-end

data/lib/git/branches.rb

@@ -1,71 +0,0 @@
-module Git
-  
-  # object that holds all the available branches
-  class Branches
-
-    include Enumerable
-    
-    def initialize(base)
-      @branches = {}
-      
-      @base = base
-            
-      @base.lib.branches_all.each do |b|
-        @branches[b[0]] = Git::Branch.new(@base, b[0])
-      end
-    end
-
-    def local
-      self.select { |b| !b.remote }
-    end
-    
-    def remote
-      self.select { |b| b.remote }
-    end
-    
-    # array like methods
-
-    def size
-      @branches.size
-    end    
-    
-    def each(&block)
-      @branches.values.each(&block)
-    end
-    
-    # Returns the target branch
-    #
-    # Example:
-    #   Given (git branch -a):
-    #    master
-    #    remotes/working/master
-    #
-    #   g.branches['master'].full #=> 'master'
-    #   g.branches['working/master'].full => 'remotes/working/master'
-    #   g.branches['remotes/working/master'].full => 'remotes/working/master'
-    #
-    # @param [#to_s] branch_name the target branch name.
-    # @return [Git::Branch] the target branch.
-    def [](branch_name)
-      @branches.values.inject(@branches) do |branches, branch|
-        branches[branch.full] ||= branch
-
-        # This is how Git (version 1.7.9.5) works. 
-        # Lets you ignore the 'remotes' if its at the beginning of the branch full name (even if is not a real remote branch). 
-        branches[branch.full.sub('remotes/', '')] ||= branch if branch.full =~ /^remotes\/.+/
-        
-        branches
-      end[branch_name.to_s]
-    end
-    
-    def to_s
-      out = ''
-      @branches.each do |k, b|
-        out << (b.current ? '* ' : '  ') << b.to_s << "\n"
-      end
-      out
-    end
-    
-  end
-
-end

data/lib/git/config.rb

@@ -1,22 +0,0 @@
-module Git
-
-  class Config
-
-    attr_writer :binary_path, :git_ssh
-
-    def initialize
-      @binary_path = nil
-      @git_ssh = nil
-    end
-
-    def binary_path
-      @binary_path || ENV['GIT_PATH'] && File.join(ENV['GIT_PATH'], 'git') || 'git'
-    end
-
-    def git_ssh
-      @git_ssh || ENV['GIT_SSH']
-    end
-
-  end
-
-end

data/lib/git/diff.rb

@@ -1,155 +0,0 @@
-module Git
-
-  # object that holds the last X commits on given branch
-  class Diff
-    include Enumerable
-
-    def initialize(base, from = nil, to = nil)
-      @base = base
-      @from = from && from.to_s
-      @to = to && to.to_s
-
-      @path = nil
-      @full_diff = nil
-      @full_diff_files = nil
-      @stats = nil
-    end
-    attr_reader :from, :to
-
-    def name_status
-      cache_name_status
-    end
-
-    def path(path)
-      @path = path
-      return self
-    end
-
-    def size
-      cache_stats
-      @stats[:total][:files]
-    end
-
-    def lines
-      cache_stats
-      @stats[:total][:lines]
-    end
-
-    def deletions
-      cache_stats
-      @stats[:total][:deletions]
-    end
-
-    def insertions
-      cache_stats
-      @stats[:total][:insertions]
-    end
-
-    def stats
-      cache_stats
-      @stats
-    end
-
-    # if file is provided and is writable, it will write the patch into the file
-    def patch(file = nil)
-      cache_full
-      @full_diff
-    end
-    alias_method :to_s, :patch
-
-    # enumerable methods
-
-    def [](key)
-      process_full
-      @full_diff_files.assoc(key)[1]
-    end
-
-    def each(&block) # :yields: each Git::DiffFile in turn
-      process_full
-      @full_diff_files.map { |file| file[1] }.each(&block)
-    end
-
-    class DiffFile
-      attr_accessor :patch, :path, :mode, :src, :dst, :type
-      @base = nil
-      NIL_BLOB_REGEXP = /\A0{4,40}\z/.freeze
-
-      def initialize(base, hash)
-        @base = base
-        @patch = hash[:patch]
-        @path = hash[:path]
-        @mode = hash[:mode]
-        @src = hash[:src]
-        @dst = hash[:dst]
-        @type = hash[:type]
-        @binary = hash[:binary]
-      end
-
-      def binary?
-        !!@binary
-      end
-
-      def blob(type = :dst)
-        if type == :src && !NIL_BLOB_REGEXP.match(@src)
-          @base.object(@src)
-        elsif !NIL_BLOB_REGEXP.match(@dst)
-          @base.object(@dst)
-        end
-      end
-    end
-
-    private
-
-      def cache_full
-        @full_diff ||= @base.lib.diff_full(@from, @to, {:path_limiter => @path})
-      end
-
-      def process_full
-        return if @full_diff_files
-        cache_full
-        @full_diff_files = process_full_diff
-      end
-
-      def cache_stats
-        @stats ||=  @base.lib.diff_stats(@from, @to, {:path_limiter => @path})
-      end
-
-      def cache_name_status
-        @name_status ||= @base.lib.diff_name_status(@from, @to, {:path => @path})
-      end
-
-      # break up @diff_full
-      def process_full_diff
-        defaults = {
-          :mode => '',
-          :src => '',
-          :dst => '',
-          :type => 'modified'
-        }
-        final = {}
-        current_file = nil
-        @full_diff.split("\n").each do |line|
-          if m = %r{\Adiff --git ("?)a/(.+?)\1 ("?)b/(.+?)\3\z}.match(line)
-            current_file = Git::EscapedPath.new(m[2]).unescape
-            final[current_file] = defaults.merge({:patch => line, :path => current_file})
-          else
-            if m = /^index ([0-9a-f]{4,40})\.\.([0-9a-f]{4,40})( ......)*/.match(line)
-              final[current_file][:src] = m[1]
-              final[current_file][:dst] = m[2]
-              final[current_file][:mode] = m[3].strip if m[3]
-            end
-            if m = /^([[:alpha:]]*?) file mode (......)/.match(line)
-              final[current_file][:type] = m[1]
-              final[current_file][:mode] = m[2]
-            end
-            if m = /^Binary files /.match(line)
-              final[current_file][:binary] = true
-            end
-            final[current_file][:patch] << "\n" + line
-          end
-        end
-        final.map { |e| [e[0], DiffFile.new(@base, e[1])] }
-      end
-
-  end
-end

data/lib/git/encoding_utils.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-require 'rubygems'
-require 'rchardet'
-
-module Git
-  # Method that can be used to detect and normalize string encoding
-  module EncodingUtils
-    def self.default_encoding
-      __ENCODING__.name
-    end
-
-    def self.best_guess_encoding
-      # Encoding::ASCII_8BIT.name
-      Encoding::UTF_8.name
-    end
-
-    def self.detected_encoding(str)
-      CharDet.detect(str)['encoding'] || best_guess_encoding
-    end
-
-    def self.encoding_options
-      { invalid: :replace, undef: :replace }
-    end
-
-    def self.normalize_encoding(str)
-      return str if str.valid_encoding? && str.encoding.name == default_encoding
-
-      return str.encode(default_encoding, str.encoding, **encoding_options) if str.valid_encoding?
-
-      str.encode(default_encoding, detected_encoding(str), **encoding_options)
-    end
-  end
-end

data/lib/git/escaped_path.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module Git
-  # Represents an escaped Git path string
-  #
-  # Git commands that output paths (e.g. ls-files, diff), will escape usual
-  # characters in the path with backslashes in the same way C escapes control
-  # characters (e.g. \t for TAB, \n for LF, \\ for backslash) or bytes with values
-  # larger than 0x80 (e.g. octal \302\265 for "micro" in UTF-8).
-  #
-  # @example
-  #   Git::GitPath.new('\302\265').unescape # => "µ"
-  #
-  class EscapedPath
-    UNESCAPES = {
-      'a' => 0x07,
-      'b' => 0x08,
-      't' => 0x09,
-      'n' => 0x0a,
-      'v' => 0x0b,
-      'f' => 0x0c,
-      'r' => 0x0d,
-      'e' => 0x1b,
-      '\\' => 0x5c,
-      '"' => 0x22,
-      "'" => 0x27
-    }.freeze
-
-    attr_reader :path
-
-    def initialize(path)
-      @path = path
-    end
-
-    # Convert an escaped path to an unescaped path
-    def unescape
-      bytes = escaped_path_to_bytes(path)
-      str = bytes.pack('C*')
-      str.force_encoding(Encoding::UTF_8)
-    end
-
-    private
-
-    def extract_octal(path, index)
-      [path[index + 1..index + 4].to_i(8), 4]
-    end
-
-    def extract_escape(path, index)
-      [UNESCAPES[path[index + 1]], 2]
-    end
-
-    def extract_single_char(path, index)
-      [path[index].ord, 1]
-    end
-
-    def next_byte(path, index)
-      if path[index] == '\\' && path[index + 1] >= '0' && path[index + 1] <= '7'
-        extract_octal(path, index)
-      elsif path[index] == '\\' && UNESCAPES.include?(path[index + 1])
-        extract_escape(path, index)
-      else
-        extract_single_char(path, index)
-      end
-    end
-
-    def escaped_path_to_bytes(path)
-      index = 0
-      [].tap do |bytes|
-        while index < path.length
-          byte, chars_used = next_byte(path, index)
-          bytes << byte
-          index += chars_used
-        end
-      end
-    end
-  end
-end

data/lib/git/index.rb

@@ -1,5 +0,0 @@
-module Git
-  class Index < Git::Path
-    
-  end
-end