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 collapse

DEBUG =

Debug printing for this class

false

Constants included from Watson

BLUE, BOLD, CYAN, GLOBAL_DEBUG_OFF, GLOBAL_DEBUG_ON, 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



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
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
 
# File 'lib/watson/github.rb', line 241

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 open tickets
  # 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&state=open",
          :ssl        => true,
          :method     => "GET",
          :auth       => config.github_api,
          :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

  config.github_issues[:open] = _json.empty? ? Hash.new : _json
  config.github_valid = true

  # Get all closed tickets
  # Create option hash to pass to Remote::http_call
  # Issues URL for GitHub + SSL
  opts = {:url        => "#{ config.github_endpoint }/repos/#{ config.github_repo }/issues?labels=watson&state=closed",
          :ssl        => true,
          :method     => "GET",
          :auth       => config.github_api,
          :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 != "200"
    formatter.print_status "x", RED
    print BOLD + "Unable to get closed issues.\n" + RESET
    print "      Since the open issues were obtained, something is probably wrong and you should file a bug report or something...\n"
    print "      Status: #{ _resp.code } - #{ _resp.message }\n"

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

  config.github_issues[:closed] = _json.empty? ? Hash.new : _json
  config.github_valid = true
  return true
end

.post_issue(issue, config) ⇒ Object

Post given issue to remote GitHub repo



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
359
360
361
362
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
 
# File 'lib/watson/github.rb', line 318

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

  # Check that issue hasn't been posted already by comparing md5s
  # Go through all open issues, if there is a match in md5, return out of method
  # [todo] - Play with idea of making body of GitHub issue hash format to be exec'd
  #      Store pieces in text as :md5 => "whatever" so when we get issues we can
  #      call exec and turn it into a real hash for parsing in watson
  #      Makes watson code cleaner but not as readable comment on GitHub...?
  debug_print "Checking open issues to see if already posted\n"
  config.github_issues[:open].each do | _open |
    if _open["body"].include?(issue[:md5])
      debug_print "Found in #{ _open["title"] }, not posting\n"
      return false
    end
    debug_print "Did not find in #{ _open["title"] }\n"
  end


  debug_print "Checking closed issues to see if already posted\n"
  config.github_issues[:closed].each do  | _closed |
    if _closed["body"].include?(issue[:md5])
      debug_print "Found in #{ _closed["title"] }, not posting\n"
      return false
    end
    debug_print "Did not find in #{ _closed["title"] }\n"
  end

  # 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_api,
          :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

  return true
end

.setup(config) ⇒ Object

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



25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
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
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
200
201
202
203
204
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
 
# File 'lib/watson/github.rb', line 25

def setup(config)

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

  formatter = Printer.new(config).build_formatter
  formatter.print_status "+", GREEN
  print BOLD + "Obtaining OAuth Token for GitHub...\n" + RESET

  # Check config to make sure no previous API exists
  unless config.github_api.empty? && config.github_repo.empty? && config.github_endpoint.empty?
    formatter.print_status "!", RED
    print BOLD + "Previous GitHub API + Repo is in RC, are you sure you want to overwrite?\n" + RESET
    print "      (Y)es/(N)o: "

    # Get user input
    _overwrite = $stdin.gets.chomp
    if ["no", "n"].include?(_overwrite.downcase)
      print "\n\n"
      formatter.print_status "x", RED
      print BOLD + "Not overwriting current GitHub API + repo info\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
  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

  _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",
                          "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
  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

  # Store endpoint and API key obtained from POST to @config.github_api
  config.github_endpoint = _endpoint
  config.github_api = _json["token"]
  debug_print "Config GitHub API Endpoint updated to: #{ config.github_endpoint }\n"
  debug_print "Config GitHub API Key updated to:      #{ config.github_api }\n"


  # 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        => "#{ _endpoint }/repos/#{ _owner }/#{ _repo }/labels",
          :ssl        => true,
          :method     => "POST",
          :auth       => config.github_api,
          :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 }"
  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

  # All setup has been completed, need to update RC
  # Call config updater/writer from @config to write config
  debug_print "Updating config with new GitHub info\n"
  config.update_conf("github_api", "github_repo", "github_endpoint")

  # 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"

  return true

end