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.



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

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

Instance Attribute Details

#jgit ⇒ Object

Returns the value of attribute jgit.



15
16
17
 
# File 'lib/git.rb', line 15

def jgit
  @jgit
end

#jrepo ⇒ Object

Returns the value of attribute jrepo.



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

def jrepo
  @jrepo
end

Class Method Details

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



66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/git.rb', line 66

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 



85
86
87
 
# File 'lib/git.rb', line 85

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

#apply(input_stream) ⇒ Object 



156
157
158
159
160
161
162
163
164
 
# File 'lib/git.rb', line 156

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 



171
172
173
174
 
# File 'lib/git.rb', line 171

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

#apply_patch(patch_content) ⇒ Object 



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

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

#branch_list ⇒ Object 



41
42
43
44
45
46
47
48
 
# File 'lib/git.rb', line 41

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 



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

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 



176
177
178
179
180
181
 
# File 'lib/git.rb', line 176

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 



62
63
64
 
# File 'lib/git.rb', line 62

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

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



50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/git.rb', line 50

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 



126
127
128
 
# File 'lib/git.rb', line 126

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

#delete_branch(name) ⇒ Object 



130
131
132
 
# File 'lib/git.rb', line 130

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

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



27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/git.rb', line 27

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]
  commits = Array.new
  logs.call.each do |jcommit|
    commits << Commit.new(jrepo, jcommit)
  end
  commits
end

#merge(commit) ⇒ Object 



93
94
95
96
97
98
99
100
101
102
 
# File 'lib/git.rb', line 93

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 



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

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 



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

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 



208
209
210
211
212
213
214
215
216
217
218
 
# File 'lib/git.rb', line 208

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 



89
90
91
 
# File 'lib/git.rb', line 89

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

#rename_branch(old_name, new_name) ⇒ Object 



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

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 



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

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 



117
118
119
120
121
122
123
124
 
# File 'lib/git.rb', line 117

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 



196
197
198
199
200
201
202
 
# File 'lib/git.rb', line 196

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 



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

def status
  @jgit.status.call
end

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



104
105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/git.rb', line 104

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