Class: Watson::Remote::GitHub

Inherits:
Object
  • Object
show all
Extended by:
Watson
Defined in:
lib/watson/github.rb

Overview

GitHub remote access class Contains all necessary methods to obtain access to, get issue list, and post issues to GitHub

Constant Summary

Constants included from Watson

BLUE, BOLD, CYAN, GRAY, GREEN, MAGENTA, Watson::RED, Watson::RESET, UNDERLINE, VERSION, WHITE, YELLOW

Class Method Summary collapse

Methods included from Watson

check_less, debug_print

Class Method Details

.get_issues(config) ⇒ Object

Get all remote GitHub issues and store into Config container class



297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
 
# File 'lib/watson/github.rb', line 297

def get_issues(config)

  # Identify method entry
  debug_print "#{ self.class } : #{ __method__ }\n"

  # Set up formatter for printing errors
  # config.output_format should be set based on less status by now
  formatter = Printer.new(config).build_formatter

  # Only attempt to get issues if API is specified
  if config.github_api.empty?
    debug_print "No API found, this shouldn't be called...\n"
    return false
  end


  # Get all issues
  # Create options hash to pass to Remote::http_call
  # Issues URL for GitHub + SSL
  opts = {
    :url        => "#{ config.github_endpoint }/repos/#{ config.github_repo }/issues?labels=watson",
    :ssl        => true,
    :method     => "GET",
    :auth       => config.github_token,
    :verbose    => false
  }

  _json, _resp  = Watson::Remote.http_call(opts)


  # Check response to validate repo access
  if _resp.code != "200"
    formatter.print_status "x", RED
    print BOLD + "Unable to access remote #{ config.github_repo }, GitHub API may be invalid\n" + RESET
    print "      Consider running --remote (-r) option to regenerate key\n\n"
    print "      Status: #{ _resp.code } - #{ _resp.message }\n"

    debug_print "GitHub invalid, setting config var\n"
    config.github_valid = false
    return false
  end


  # Create hash entry from each returned issue
  # MD5 of issue serves as hash key
  # Hash value is another hash of info we will use
  _json.each do |issue|

    # Skip this issue if it doesn't have watson md5 tag
    next if (_md5 = issue["body"].match(/__md5__ : (\w+)/)).nil?


    # If it does, use md5 as hash key and populate values with our info
    config.github_issues[_md5[1]] = {
      :title => issue["title"],
      :id    => issue["number"],
      :state => issue["state"]
    }
  end

  config.github_valid = true
end

.get_repo(config, formatter) ⇒ Object

Obtain repo info for GitHub Set repo for current dir/project



205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
 
# File 'lib/watson/github.rb', line 205

def get_repo(config, formatter)
  # Get repo information, if blank give error
  formatter.print_status "!", YELLOW
  print BOLD + "Repo information required\n" + RESET
  print "      Please provide owner that repo is under followed by repo name\n"
  print "      e.g. owner: nhmood, repo: watson (case sensitive)\n"
  print "      See help or README for more details on GitHub access\n\n"

  print BOLD + "Owner: " + RESET
  _owner = $stdin.gets.chomp
  if _owner.empty?
    print "\n"
    formatter.print_status "x", RED
    print BOLD + "Input blank. Please enter the owner the repo is under!\n\n" + RESET
    return false
  end

  print BOLD + "Repo: " + RESET
  _repo = $stdin.gets.chomp
  if _repo.empty?
    print "\n"
    formatter.print_status "x", RED
    print BOLD + "Input blank. Please enter the repo name!\n\n" + RESET
    return false
  end


  # Make call to GitHub API to create new label for Issues
  # If status returns not 404, then we have access to repo (+ it exists)
  # If 422, then (most likely) the label already exists

  # Create options hash to pass to Remote::http_call
  # Label URL for GitHub + SSL
  #
  # Auth token
  opts = {
    :url        => "#{ config.github_endpoint }/repos/#{ _owner }/#{ _repo }/labels",
    :ssl        => true,
    :method     => "POST",
    :auth       => config.github_token,
    :data       => {"name" => "watson",
                    "color" => "00AEEF" },
    :verbose    => false
  }

  _json, _resp  = Watson::Remote.http_call(opts)

  # [review] - This is pretty messy, maybe clean it up later
  # Check response to validate repo access
  if _resp.code == "404"
    print "\n"
    formatter.print_status "x", RED
    print BOLD + "Unable to access /#{ _owner }/#{ _repo } with given credentials\n" + RESET
    print "      Check that credentials are correct and repository exists under user\n"
    print "      Status: #{ _resp.code } - #{ _resp.message }\n\n"
    return false

  else
    # If it is anything but a 404, I THINK it means we have access...
    # Will assume that until proven otherwise
    print "\n"
    formatter.print_status "o", GREEN
    print BOLD + "Repo successfully accessed\n\n" + RESET
  end

  # Store owner/repo obtained from POST to @config.github_repo
  config.github_repo = "#{ _owner }/#{ _repo }"
  config.update_conf("github_repo")
  debug_print "Config GitHub API Key updated to: #{ config.github_repo }\n"

  # Inform user of label creation status (created above)
  formatter.print_status "+", GREEN
  print BOLD + "Creating label for watson on GitHub...\n" + RESET
  if _resp.code == "201"
    formatter.print_status "+", GREEN
    print BOLD + "Label successfully created\n" + RESET
  elsif _resp.code == "422" && _json["code"] == "already_exists"
    formatter.print_status "!", YELLOW
    print BOLD + "Label already exists\n" + RESET
  else
    formatter.print_status "x", RED
    print BOLD + "Unable to create label for /#{ _owner }/#{ _repo }\n" + RESET
    print "      Status: #{ _resp.code } - #{ _resp.message }\n"
  end

  true
end

.get_token(config, home_conf, formatter) ⇒ Object

Obtain API token fom GitHub Either generate new Auth Token or use existing for current dir/project



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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
 
# File 'lib/watson/github.rb', line 51

def get_token(config, home_conf, formatter)

  # Avaliable GitHub APIs
  _github = home_conf.github_api
  
  formatter.print_status "+", GREEN
  print BOLD + "Obtaining OAuth Token for GitHub...\n" + RESET

  unless _github.empty?
    formatter.print_status "!", YELLOW
    print BOLD + "Previous GitHub APIs found do you want to use one that is listed?\n" + RESET
    print "      Enter # of API key (blank will create new): "

    # Get user input
    unless (_api = $stdin.gets.chomp).empty?
      print "\n"
      _api = _api.to_i - 1
      
      # Return specified API token if # selected is valid
      return _github[_github.keys[_api]] if _api >= 0 && _api < _github.length

      formatter.print_status "x", RED
      print BOLD + "Invalid API selected\n" + RESET
      print "      Make sure the correct # was selected from the list!\n" + RESET
      return false
    end
  end


  formatter.print_status "!", YELLOW
  print BOLD + "Access to your GitHub account required to make/update issues\n" + RESET
  print "      See help or README for more details on GitHub/Bitbucket access\n\n"

  formatter.print_status "!", GREEN
  print BOLD + "Is this a GitHub Enterprise account?\n" + RESET
  print "      (Y)es/(N)o: "


  # Get user input
  _enterprise = $stdin.gets.chomp
  if ["yes", "y"].include?(_enterprise.downcase)
    print "\n\n"
    print BOLD + "GitHub API Endpoint: " + RESET
    _endpoint = $stdin.gets.chomp.chomp('/')
    if _endpoint.empty?
      formatter.print_status "x", RED
      print BOLD + "Input blank. Please enter your API endpoint!\n\n" + RESET
      return false
    end

    # Make sure we have the http(s)://
    if !_endpoint.match(/(http|https):\/\//)
      _endpoint = "http://#{_endpoint}"
    end

  else
    _endpoint = ''
  end

  print "\n"

  # [todo] - Don't just check for blank password but invalid as well
  # Poor mans username/password grabbing
  print BOLD + "Username: " + RESET
  _username = $stdin.gets.chomp
  if _username.empty?
    formatter.print_status "x", RED
    print BOLD + "Input blank. Please enter your username!\n\n" + RESET
    return false
  end

  # [fix] - Crossplatform password block needed, not sure if current method is safe either
  # Block output to tty to prevent PW showing, Linux/Unix only :(
  print BOLD + "Password: " + RESET
  system "stty -echo"
  _password = $stdin.gets.chomp
  system "stty echo"
  print "\n\n"
  if _password.empty?
    formatter.print_status "x", RED
    print BOLD + "Input is blank. Please enter your password!\n\n" + RESET
    return false
  end

  # Label for Auth Token
  print BOLD + "Auth Token Label (leave blank to ignore): " + RESET
  _label = $stdin.gets.chomp

  _endpoint = "https://api.github.com" if _endpoint.empty?

  # HTTP Request to get OAuth Token
  # GitHub API v3 - http://developer.github.com/v3/

  # Create options hash to pass to Remote::http_call
  # Auth URL for GitHub + SSL
  # Repo scope + notes for watson
  # Basic auth with user input
  opts = {
    :url        => "#{ _endpoint }/authorizations",
    :ssl        => true,
    :method     => "POST",
    :basic_auth => [_username, _password],
    :data       => {"scopes" => ["repo"],
                    "note" => "watson - #{_label}",
                    "note_url" => "http://watson.goosecode.com/" },
    :verbose    => false
  }

  _json, _resp  = Watson::Remote.http_call(opts)

  # Check response to validate authorization
  if _resp.code == "201"
    formatter.print_status "o", GREEN
    print BOLD + "Obtained OAuth Token\n\n" + RESET

  elsif _resp.code == "401"
    begin
      # [todo] - Refactor all
      _json, _resp = two_factor_authentication(opts, formatter)
    rescue => e
      return false
    end
  else
    formatter.print_status "x", RED
    print BOLD + "Unable to obtain OAuth Token\n" + RESET
    print "      Status: #{ _resp.code } - #{ _resp.message }\n\n"
    return false
  end

  # Add to $HOME/.watsonrc and current .watsonrc
  home_conf.github_api[_username] = _json["token"]
  home_conf.update_conf("github_api")

  # Store endpoint and API key obtained from POST to @config.github_api
  config.github_endpoint = _endpoint

  # If we are currently in $HOME then don't touch the .watsonrc
  # [todo] - Better way of selecting API if in $HOME, or just don't use in $HOME...
  unless Dir.pwd.eql?(File.expand_path('~'))
    config.github_api = {_username => _json["token"]}
    config.update_conf("github_api", "github_endpoint")
  end


  debug_print "Config GitHub API Endpoint updated to: #{ config.github_endpoint }\n"
  debug_print "Config GitHub API Key updated to:      #{ config.github_api }\n"

  true
end

.post_issue(issue, config) ⇒ Object

Post given issue to remote GitHub repo



363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
 
# File 'lib/watson/github.rb', line 363

def post_issue(issue, config)
# [todo] - Better way to identify/compare remote->local issues than md5
#        Current md5 based on some things that easily can change, need better ident

  # Identify method entry
  debug_print "#{ self.class } : #{ __method__ }\n"


  # Set up formatter for printing errors
  # config.output_format should be set based on less status by now
  formatter = Printer.new(config).build_formatter


  # Only attempt to get issues if API is specified
  if config.github_api.empty?
    debug_print "No API found, this shouldn't be called...\n"
    return false
  end


  return false if config.github_issues.key?(issue[:md5])
  debug_print "#{issue[:md5]} not found in remote issues, posting\n"

  # We didn't find the md5 for this issue in the open or closed issues, so safe to post

  # Create the body text for the issue here, too long to fit nicely into opts hash
  # [review] - Only give relative path for privacy when posted
  _body =
    "__filename__ : #{ issue[:path] }\n" +
    "__line #__ : #{ issue[:line_number] }\n" +
    "__tag__ : #{ issue[:tag] }\n" +
    "__md5__ : #{ issue[:md5] }\n\n" +
    "#{ issue[:context].join }\n"

  # Create option hash to pass to Remote::http_call
  # Issues URL for GitHub + SSL
  opts = {
    :url        => "#{ config.github_endpoint }/repos/#{ config.github_repo }/issues",
    :ssl        => true,
    :method     => "POST",
    :auth       => config.github_token,
    :data       => { "title" => issue[:title] + " [#{ issue[:path] }]",
                     "labels" => [issue[:tag], "watson"],
                     "body" => _body },
    :verbose    => false
  }

  _json, _resp  = Watson::Remote.http_call(opts)


  # Check response to validate repo access
  # Shouldn't be necessary if we passed the last check but just to be safe
  if _resp.code != "201"
    formatter.print_status "x", RED
    print BOLD + "Post unsuccessful. \n" + RESET
    print "      Since the open issues were obtained earlier, something is probably wrong and you should let someone know...\n"
    print "      Status: #{ _resp.code } - #{ _resp.message }\n"
    return false
  end

  # Parse response and append issue hash so we are up to date
  config.github_issues[issue[:md5]] = {
    :title => _json["title"],
    :id    => _json["number"],
    :state => _json["state"]
  }
  return true
end

.setup(config) ⇒ Object

Setup remote access to GitHub Get Username, Repo, and PW and perform necessary HTTP calls to check validity



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
# File 'lib/watson/github.rb', line 23

def setup(config)

  # Identify method entry
  debug_print "#{ self.class } : #{ __method__ }\n"

  formatter = Printer.new(config).build_formatter
  
  # Create new RC for $HOME/.watsonrc and check for existing remotes there
  _home_conf = Watson::Config.home_conf

  return false if !get_token(config, _home_conf, formatter)
  return false if !get_repo(config, formatter)

  # Give user some info
  print "\n"
  formatter.print_status "o", GREEN
  print BOLD + "GitHub successfully setup\n" + RESET
  print "      Issues will now automatically be retrieved from GitHub by default\n"
  print "      Use -u, --update to post issues to GitHub\n"
  print "      See help or README for more details on GitHub/Bitbucket access\n\n"

  true
end