Class: RJGit::RubyGit

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

Constant Summary collapse

RESET_MODES = 
["HARD", "SOFT", "KEEP", "MERGE", "MIXED"]

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(repository) ⇒ RubyGit

Returns a new instance of RubyGit.



24
25
26
27
 
# File 'lib/git.rb', line 24

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

Instance Attribute Details

#jgit ⇒ Object

Returns the value of attribute jgit.



17
18
19
 
# File 'lib/git.rb', line 17

def jgit
  @jgit
end

#jrepo ⇒ Object

Returns the value of attribute jrepo.



18
19
20
 
# File 'lib/git.rb', line 18

def jrepo
  @jrepo
end

Class Method Details

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



100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/git.rb', line 100

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
  if options[:username]
    clone_command.set_credentials_provider(UsernamePasswordCredentialsProvider.new(options[:username], options[:password]))
  end
  clone_command.call
  Repo.new(local)
end

Instance Method Details

#add(file_pattern) ⇒ Object 



119
120
121
 
# File 'lib/git.rb', line 119

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

#apply(input_stream) ⇒ Object 



190
191
192
193
194
195
196
197
198
 
# File 'lib/git.rb', line 190

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 



205
206
207
208
 
# File 'lib/git.rb', line 205

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

#apply_patch(patch_content) ⇒ Object 



200
201
202
203
 
# File 'lib/git.rb', line 200

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

#branch_list ⇒ Object 



75
76
77
78
79
80
81
82
 
# File 'lib/git.rb', line 75

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 



172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
 
# File 'lib/git.rb', line 172

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 



210
211
212
213
214
215
 
# File 'lib/git.rb', line 210

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 



96
97
98
 
# File 'lib/git.rb', line 96

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

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



84
85
86
87
88
89
90
91
92
93
94
 
# File 'lib/git.rb', line 84

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 



160
161
162
 
# File 'lib/git.rb', line 160

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

#delete_branch(name) ⇒ Object 



164
165
166
 
# File 'lib/git.rb', line 164

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

#follow_renames(jcommits, path) ⇒ Object 



50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/git.rb', line 50

def follow_renames(jcommits, path)
  renames = Array.new
  jcommits.each do |jcommit|
    all_commits = @jgit.log.add(jcommit).call
    all_commits.each do |jcommit_prev|
      tree_start = jcommit.getTree
      tree_prev  = jcommit_prev.getTree
      treewalk = TreeWalk.new(jrepo)
      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))
          renames << Commit.new(jrepo, jcommit_prev)
        end
      end
    end
  end
  renames
end

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



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
# File 'lib/git.rb', line 29

def log(path = nil, revstring = Constants::HEAD, options = {})
  logs = @jgit.log
  ref = jrepo.resolve(revstring)
  logs.add(ref)
  logs.addPath(path) if path
  logs.setMaxCount(options[:max_count]) if options[:max_count]
  logs.setSkip(options[:skip]) if options[:skip]
  jcommits = logs.call
  commits = Array.new
  jcommits.each do |jcommit|
    commits << Commit.new(jrepo, jcommit)
  end
  
  if path && options[:follow]
    jcommits = @jgit.log.add(ref).addPath(path).call
    commits += follow_renames(jcommits, path)
  end

  commits
end

#merge(commit) ⇒ Object 



127
128
129
130
131
132
133
134
135
136
 
# File 'lib/git.rb', line 127

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(options = {}) ⇒ Object 



268
269
270
271
272
273
274
275
276
 
# File 'lib/git.rb', line 268

def pull(options = {})
    pull_command = @jgit.pull
    pull_command.set_dry_run(true) if options[:dryrun]
    pull_command.set_rebase(options[:rebase]) if options[:rebase]
    if options[:username]
      pull_command.set_credentials_provider(UsernamePasswordCredentialsProvider.new(options[:username], options[:password]))
    end
    pull_command.call
end

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



254
255
256
257
258
259
260
261
262
263
264
265
266
 
# File 'lib/git.rb', line 254

def push(remote, refs = [], options = {})
  if(refs.size > 0)
    refs.map!{|ref| RefSpec.new(ref)}
    push_command = @jgit.push
    push_command.set_dry_run(true) if options[:dryrun]
    push_command.set_remote(remote)
    push_command.set_ref_specs(refs)
    if options[:username]
      push_command.set_credentials_provider(UsernamePasswordCredentialsProvider.new(options[:username], options[:password]))
    end
    push_command.call
  end
end

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



242
243
244
245
246
247
248
249
250
251
252
 
# File 'lib/git.rb', line 242

def push_all(remote, options = {})
  push_command = @jgit.push
  push_command.set_dry_run(true) if options[:dryrun]
  push_command.set_remote(remote)
  push_command.set_push_all
  push_command.set_push_tags
  if options[:username]
    push_command.set_credentials_provider(UsernamePasswordCredentialsProvider.new(options[:username], options[:password]))
  end
  push_command.call
end

#remove(file_pattern) ⇒ Object 



123
124
125
 
# File 'lib/git.rb', line 123

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

#rename_branch(old_name, new_name) ⇒ Object 



168
169
170
 
# File 'lib/git.rb', line 168

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 



217
218
219
220
221
222
223
224
225
226
227
228
 
# File 'lib/git.rb', line 217

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 



151
152
153
154
155
156
157
158
 
# File 'lib/git.rb', line 151

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 



230
231
232
233
234
235
236
 
# File 'lib/git.rb', line 230

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 



238
239
240
 
# File 'lib/git.rb', line 238

def status
  @jgit.status.call
end

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



138
139
140
141
142
143
144
145
146
147
148
149
 
# File 'lib/git.rb', line 138

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