Class: RJGit::RubyGit

Inherits:
Object
  • Object
show all
Defined in:
lib/git.rb

Defined Under Namespace

Classes: RJGitSSHConfigCallback

Constant Summary collapse

RESET_MODES = 
["HARD", "SOFT", "KEEP", "MERGE", "MIXED"]
SSH_TRANSPORTS = 
["ssh"]
HTTP_TRANSPORTS = 
["http", "https"]
FILE_TRANSPORTS = 
["file"]
VALID_TRANSPORTS = 
SSH_TRANSPORTS + HTTP_TRANSPORTS + FILE_TRANSPORTS

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(repository) ⇒ RubyGit

Returns a new instance of RubyGit.



32
33
34
35
 
# File 'lib/git.rb', line 32

def initialize(repository)
  @jrepo = RJGit.repository_type(repository)
  @jgit = Git.new(@jrepo)
end

Instance Attribute Details

#jgit ⇒ Object

Returns the value of attribute jgit.



21
22
23
 
# File 'lib/git.rb', line 21

def jgit
  @jgit
end

#jrepo ⇒ Object

Returns the value of attribute jrepo.



22
23
24
 
# File 'lib/git.rb', line 22

def jrepo
  @jrepo
end

Class Method Details

.clone(remote, local, options = {}) ⇒ Object 



197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
 
# File 'lib/git.rb', line 197

def self.clone(remote, local, options = {})
  clone_command = Git.clone_repository
  clone_command.setURI(remote)
  clone_command.set_directory(java.io.File.new(local))
  clone_command.set_bare(true) if options[:is_bare]
  if options[:branch]
    if options[:branch] == :all
      clone_command.set_clone_all_branches(true)
    else
      clone_command.set_branch(options[:branch])
    end
  end

  set_command_transport(clone_command, remote, options)
  clone_command.call
  Repo.new(local)
end

.set_command_transport(command, remote, options = {}) ⇒ Object 



179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
 
# File 'lib/git.rb', line 179

def self.set_command_transport(command, remote, options = {})
  uri = nil
  begin
    uri = URI.parse(remote) if remote
  rescue URI::InvalidURIError
  end

  if uri && (VALID_TRANSPORTS.include? uri.scheme)
    transport_protocol = uri.scheme
  end

  if (SSH_TRANSPORTS.include? transport_protocol.to_s) || (options[:transport_protocol] == :ssh) || options[:private_key_file]
    command.set_transport_config_callback(RJGitSSHConfigCallback.new(options))
  elsif (HTTP_TRANSPORTS.include? transport_protocol.to_s) || options[:username]
    command.set_credentials_provider(UsernamePasswordCredentialsProvider.new(options[:username], options[:password]))
  end
end

Instance Method Details

#add(file_pattern) ⇒ Object 



215
216
217
 
# File 'lib/git.rb', line 215

def add(file_pattern)
  @jgit.add.add_filepattern(file_pattern).call
end

#apply(input_stream) ⇒ Object 



286
287
288
289
290
291
292
293
294
 
# File 'lib/git.rb', line 286

def apply(input_stream)
  apply_result = @jgit.apply.set_patch(input_stream).call
  updated_files = apply_result.get_updated_files
  updated_files_parsed = []
  updated_files.each do |file|
    updated_files_parsed << file.get_absolute_path
  end
  updated_files_parsed
end

#apply_file(patch_file) ⇒ Object 



301
302
303
304
 
# File 'lib/git.rb', line 301

def apply_file(patch_file)
  input_stream = FileInputStream.new(patch_file)
  apply(input_stream)
end

#apply_patch(patch_content) ⇒ Object 



296
297
298
299
 
# File 'lib/git.rb', line 296

def apply_patch(patch_content)
  input_stream = ByteArrayInputStream.new(patch_content.to_java_bytes)
  apply(input_stream)
end

#branch_list ⇒ Object 



112
113
114
115
116
117
118
119
 
# File 'lib/git.rb', line 112

def branch_list
  branch = @jgit.branch_list
  array = Array.new
  branch.call.each do |b|
    array << b.get_name
  end
  array
end

#checkout(branch_name = "master", options = {}) ⇒ Object 



268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
 
# File 'lib/git.rb', line 268

def checkout(branch_name = "master", options = {})
  checkout_command = @jgit.checkout.set_name(branch_name)
  checkout_command.set_start_point(options[:commit])
  options[:paths].each {|path| checkout_command.add_path(path)} if options[:paths]
  checkout_command.set_create_branch(true) if options[:create]
  checkout_command.set_force(true) if options[:force]
  result = {}
  begin
    checkout_command.call
    result[:success] = true
    result[:result] = @jgit.get_repository.get_full_branch
  rescue Java::OrgEclipseJgitApiErrors::CheckoutConflictException => conflict
    result[:success] = false
    result[:result] = conflict.get_conflicting_paths
  end
  result
end

#clean(options = {}) ⇒ Object 



306
307
308
309
310
311
 
# File 'lib/git.rb', line 306

def clean(options = {})
  clean_command = @jgit.clean
  clean_command.set_dry_run(true) if options[:dryrun]
  clean_command.set_paths(java.util.Arrays.asList(options[:paths])) if options[:paths]
  clean_command.call
end

#clone(remote, local, options = {}) ⇒ Object 



133
134
135
 
# File 'lib/git.rb', line 133

def clone(remote, local, options = {})
  RubyGit.clone(remote, local, options)
end

#commit(message, options = {}) ⇒ Object 



121
122
123
124
125
126
127
128
129
130
131
 
# File 'lib/git.rb', line 121

def commit(message, options = {})
  commit_cmd = @jgit.commit.set_message(message)
  commit_cmd.set_all(options[:all]) unless options[:all].nil?
  commit_cmd.set_amend(options[:amend]) unless options[:amend].nil?
  commit_cmd.set_author(options[:author].person_ident) unless options[:author].nil?
  commit_cmd.set_committer(options[:committer].person_ident) unless options[:committer].nil?
  commit_cmd.set_insert_change_id(options[:insert_change_id]) unless options[:insert_change_id].nil?
  options[:only_paths].each {|path| commit_cmd.set_only(path)} unless options[:only_paths].nil?
  commit_cmd.set_reflog_comment(options[:reflog_comment]) unless options[:reflog_comment].nil?
  Commit.new(jrepo, commit_cmd.call)
end

#create_branch(name) ⇒ Object 



256
257
258
 
# File 'lib/git.rb', line 256

def create_branch(name)
  @jgit.branch_create.setName(name).call
end

#delete_branch(name) ⇒ Object 



260
261
262
 
# File 'lib/git.rb', line 260

def delete_branch(name)
  @jgit.branch_delete.set_branch_names(name).call
end

#fetch(remote = nil, options = {}) ⇒ Object 



373
374
375
376
377
378
379
380
381
382
383
 
# File 'lib/git.rb', line 373

def fetch(remote = nil, options = {})
  fetch_command = @jgit.fetch
  fetch_command.set_dry_run(true) if options[:dryrun]
  fetch_command.set_thin(true) if options[:thin]
  fetch_command.set_check_fetched_objects(true) if options[:check_fetched_objects]
  fetch_command.set_remove_deleted_refs(true) if options[:remove_deleted_refs]
  fetch_command.set_ref_specs(RefSpec.new(options[:refspecs])) if options[:refspecs]
  fetch_command.set_remote(remote) if remote
  self.class.set_command_transport(fetch_command, remote, options)
  fetch_command.call
end

#follow_renames(jcommit, path) ⇒ Object 



89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/git.rb', line 89

def follow_renames(jcommit, path)
  commits = @jgit.log.add(jcommit).call
  commits.each do |jcommit_prev|
    tree_start = jcommit.getTree
    tree_prev  = jcommit_prev.getTree
    treewalk = TreeWalk.new(jrepo)
    #treewalk.setFilter(PathFilter.create(File.dirname(path)))
    treewalk.addTree(tree_prev)
    treewalk.addTree(tree_start)
    treewalk.setRecursive(true)
    rename_detector = RenameDetector.new(jrepo)
    rename_detector.addAll(DiffEntry.scan(treewalk))
    diff_entries = rename_detector.compute
    diff_entries.each do |entry|
      if ((entry.getChangeType == DiffEntry::ChangeType::RENAME || entry.getChangeType == DiffEntry::ChangeType::COPY) && entry.getNewPath.match(path))
        return entry.getOldPath
      end
    end
  end
  return nil
end

#log(path = nil, revstring = Constants::HEAD, options = {}) ⇒ Object 



45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/git.rb', line 45

def log(path = nil, revstring = Constants::HEAD, options = {})
  ref = jrepo.resolve(revstring)
  return [] unless ref
  jcommits = Array.new

  if path && options[:follow]
    current_path = path
    start = nil
    loop do
      logs = @jgit.log.add(ref).addPath(current_path).call
      logs.each do |jcommit|
        next if jcommits.include?(jcommit)
        jcommits << jcommit
        start = jcommit
      end
      current_path = follow_renames(start, current_path) if start
      break if current_path.nil?
    end

  else
    logs = @jgit.log
    logs.add(ref)
    logs.addPath(path) if path
    logs.setMaxCount(options[:max_count]) if options[:max_count]
    logs.setSkip(options[:skip]) if options[:skip]

    if (options[:since] && options[:until])
      revwalk = RevWalk.new(jrepo)
      since_commit = revwalk.parseCommit(jrepo.resolve(options[:since]))
      until_commit = revwalk.parseCommit(jrepo.resolve(options[:until]))
      logs.addRange(since_commit, until_commit)
    end
    if options[:not]
      revwalk = RevWalk.new(jrepo)
      options[:not].each do |ref|
        logs.not(revwalk.parseCommit(jrepo.resolve(ref)))
      end
    end
    jcommits = logs.call
  end

  jcommits.map{ |jcommit| Commit.new(jrepo, jcommit) }
end

#logs(refs, options = {}) ⇒ Object 



37
38
39
40
41
42
43
 
# File 'lib/git.rb', line 37

def logs(refs, options = {})
  logs = []
  refs.each do |ref|
    logs << log(nil, ref, options)
  end
  logs
end

#merge(commit) ⇒ Object 



223
224
225
226
227
228
229
230
231
232
 
# File 'lib/git.rb', line 223

def merge(commit)
  merge_command = @jgit.merge
  merge_command.include(commit.jcommit)
  result = merge_command.call
  if result.get_merge_status.to_string == 'Conflicting'
    return result.get_conflicts.to_hash.keys
  else
    return result
  end
end

#pull(remote = nil, remote_ref = nil, options = {}) ⇒ Object 



363
364
365
366
367
368
369
370
371
 
# File 'lib/git.rb', line 363

def pull(remote = nil, remote_ref = nil, options = {})
  pull_command = @jgit.pull
  pull_command.set_dry_run(true) if options[:dryrun]
  pull_command.set_rebase(options[:rebase]) if options[:rebase]
  pull_command.set_remote(remote) if remote
  pull_command.set_remote_branch_name(remote_ref) if remote_ref
  self.class.set_command_transport(pull_command, remote, options)
  pull_command.call
end

#push(remote = nil, refs = [], options = {}) ⇒ Object 



350
351
352
353
354
355
356
357
358
359
360
361
 
# File 'lib/git.rb', line 350

def push(remote = nil, refs = [], options = {})
  push_command = @jgit.push
  push_command.set_dry_run(true) if options[:dryrun]
  push_command.set_force(true) if options[:force]
  push_command.set_remote(remote) if remote
  if(refs.to_a.size > 0)
    refs.map!{|ref| RefSpec.new(ref)}
    push_command.set_ref_specs(refs)
  end
  self.class.set_command_transport(push_command, remote, options)
  push_command.call
end

#push_all(remote, options = {}) ⇒ Object 



338
339
340
341
342
343
344
345
346
347
348
 
# File 'lib/git.rb', line 338

def push_all(remote, options = {})
  push_command = @jgit.push
  push_command.set_dry_run(true) if options[:dryrun]
  push_command.set_force(true) if options[:force]
  push_command.set_remote(remote)
  push_command.set_push_all
  push_command.set_push_tags

  self.class.set_command_transport(push_command, remote, options)
  push_command.call
end

#remove(file_pattern) ⇒ Object 



219
220
221
 
# File 'lib/git.rb', line 219

def remove(file_pattern)
  @jgit.rm.add_filepattern(file_pattern).call
end

#rename_branch(old_name, new_name) ⇒ Object 



264
265
266
 
# File 'lib/git.rb', line 264

def rename_branch(old_name, new_name)
  @jgit.branch_rename.set_old_name(old_name).set_new_name(new_name).call
end

#reset(ref, mode = "HARD", paths = nil) ⇒ Object 



313
314
315
316
317
318
319
320
321
322
323
324
 
# File 'lib/git.rb', line 313

def reset(ref, mode = "HARD", paths = nil)
  return nil if mode != nil && !RESET_MODES.include?(mode)
  reset_command = @jgit.reset
  if paths then
    paths.each do |path|
      reset_command.addPath(path)
    end
  end
  reset_command.setRef(ref.id)
  reset_command.setMode(org.eclipse.jgit.api.ResetCommand::ResetType.valueOf(mode)) unless mode == nil
  reset_command.call
end

#resolve_tag(tagref) ⇒ Object 



247
248
249
250
251
252
253
254
 
# File 'lib/git.rb', line 247

def resolve_tag(tagref)
  begin
    walk = RevWalk.new(@jrepo)
    walk.parse_tag(tagref.get_object_id)
  rescue Java::OrgEclipseJgitErrors::IncorrectObjectTypeException
    nil
  end
end

#revert(commits) ⇒ Object 



326
327
328
329
330
331
332
 
# File 'lib/git.rb', line 326

def revert(commits)
  revert_command = @jgit.revert
  commits.each do |commit|
    revert_command.include commit.jcommit
  end
  Commit.new(jrepo, revert_command.call)
end

#status ⇒ Object 



334
335
336
 
# File 'lib/git.rb', line 334

def status
  @jgit.status.call
end

#tag(name, message = "", commit_or_revision = nil, actor = nil, force = false) ⇒ Object 



234
235
236
237
238
239
240
241
242
243
244
245
 
# File 'lib/git.rb', line 234

def tag(name, message = "", commit_or_revision = nil, actor = nil, force = false)
  tag_command = @jgit.tag
  tag_command.set_name(name)
  tag_command.set_force_update(force)
  tag_command.set_message(message)
  tag_command.set_object_id(RJGit.commit_type(commit_or_revision)) if commit_or_revision
  if actor
    actor = RJGit.actor_type(actor)
    tag_command.set_tagger(actor)
  end
  tag_command.call
end