watson-ruby 1.4.3 → 1.5.0

data/lib/watson/formatters/default_formatter.rb

@@ -31,9 +31,9 @@ module Watson::Formatters
       debug_print "#{ self } : #{ __method__ }\n"
 
       # Header
-      cprint <<-MESSAGE.gsub(/^ {6}/, '')
+      cprint <<-MESSAGE.gsub(/^(\s+)/, '')
       #{BOLD}------------------------------#{RESET}
-      #{BOLD}watson#{RESET} - #{RESET}#{BOLD}#{YELLOW}inline issue manager#{RESET}
+      #{BOLD}watson#{RESET} - #{RESET}#{BOLD}#{YELLOW}inline issue manager\n#{RESET}
 
       Run in: #{Dir.pwd}
       Run @ #{Time.now.asctime}
@@ -142,31 +142,36 @@ module Watson::Formatters
 
       # Go through each issue in tag
       entry[tag].each do |issue|
-        cprint "#{WHITE}  line #{issue[:line_number]} - #{RESET}#{BOLD}#{issue[:title]}#{RESET}"
-
-        # Check to see if it has been resolved on GitHub/Bitbucket
-        debug_print "Checking if issue has been resolved\n"
-        @config.github_issues[:closed].each do | _closed |
-          if _closed["body"].include?(issue[:md5])
-            debug_print "Found in #{ _closed[:comment] }, not posting\n"
-            cprint <<-MESSAGE.gsub(/^(\s+)/, '')
-            #{BOLD} [#{RESET}#{GREEN}#{BOLD}Resolved on GitHub#{RESET}#{BOLD}]#{RESET}
+        cprint "#{WHITE}  line #{issue[:line_number]} - #{RESET}#{BOLD}#{issue[:title]} #{RESET}"
+
+
+        # If there are any remote issues, print status and issue #
+        if _GH = @config.github_issues[issue[:md5]]
+          debug_print "Found #{ issue[:title]} in remote issues\n"
+
+          cprint <<-MESSAGE.gsub(/^(\s+)/, '').chomp
+          #{BOLD}[#{RESET}#{_GH[:state] != "closed" ? RED : GREEN}#{BOLD}GH##{_GH[:id]}#{RESET}#{BOLD}]#{RESET}
+          MESSAGE
+        end
+
+        if _BB = @config.bitbucket_issues[issue[:md5]]
+          debug_print "Found #{ issue[:title]} in remote issues\n"
+
+          cprint <<-MESSAGE.gsub(/^(\s+)/, '').chomp
+          #{BOLD}[#{RESET}#{_BB[:state] != "resolved" ? RED : GREEN}#{BOLD}BB##{_BB[:id]}#{RESET}#{BOLD}]#{RESET}
             MESSAGE
-          end
-          debug_print "Did not find in #{ _closed[:comment] }\n"
         end
 
-        debug_print "Checking if issue has been resolved\n"
-        @config.bitbucket_issues[:closed].each do  |closed|
-          if closed['content'].include?(issue[:md5])
-            debug_print "Found in #{ closed["content"] }, not posting\n"
-            cprint <<-MESSAGE.gsub(/^(\s+)/, '')
-            #{BOLD} [#{RESET}#{GREEN}#{BOLD}Resolved on Bitbucket#{RESET}#{BOLD}]#{RESET}
+
+        if _GL = @config.gitlab_issues[issue[:md5]]
+          debug_print "Found #{ issue[:title]} in remote issues\n"
+
+          cprint <<-MESSAGE.gsub(/^(\s+)/, '').chomp
+          #{BOLD}[#{RESET}#{_GL[:state] != "closed" ? RED : GREEN}#{BOLD}GL##{_GL[:id]}#{RESET}#{BOLD}]#{RESET}
             MESSAGE
-          end
-          debug_print "Did not find in #{ closed["title"] }\n"
         end
 
+
         cprint "\n"
       end
 

data/lib/watson/github.rb

@@ -67,6 +67,12 @@ module Watson
           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
@@ -105,15 +111,16 @@ module Watson
       # 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
-             }
+      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)
 
@@ -169,14 +176,15 @@ module Watson
       # 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
-             }
+      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)
 
@@ -254,15 +262,16 @@ module Watson
       end
 
 
-      # Get all open tickets
+      # 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&state=open",
-              :ssl        => true,
-              :method     => "GET",
-              :auth       => config.github_api,
-              :verbose    => false
-             }
+      opts = {
+        :url        => "#{ config.github_endpoint }/repos/#{ config.github_repo }/issues?labels=watson",
+        :ssl        => true,
+        :method     => "GET",
+        :auth       => config.github_api,
+        :verbose    => false
+      }
 
       _json, _resp  = Watson::Remote.http_call(opts)
 
@@ -279,37 +288,25 @@ module Watson
         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
-           }
+      # 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|
 
-      _json, _resp  = Watson::Remote.http_call(opts)
+        # Skip this issue if it doesn't have watson md5 tag
+        next if (_md5 = issue["body"].match(/__md5__ : (\w+)/)).nil?
 
-      # 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
+        # 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_issues[:closed] = _json.empty? ? Hash.new : _json
       config.github_valid = true
-      return true
     end
 
 
@@ -334,52 +331,33 @@ module Watson
         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
+      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"
+      _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
-             }
+      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)
 
@@ -394,6 +372,12 @@ module Watson
         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
 

data/lib/watson/gitlab.rb

@@ -0,0 +1,293 @@
+module Watson
+  class Remote
+    # GitLab remote access class
+    # Contains all necessary methods to obtain access to, get issue list,
+    # and post issues to GitLab
+    class GitLab
+
+    # Debug printing for this class
+    DEBUG = false
+
+    class << self
+
+    # [todo] - Keep asking for user data until valid instead of leaving app
+
+    # Include for debug_print
+    include Watson
+
+    #############################################################################
+    # Setup remote access to GitLab
+    # Get Username, Repo, and PW and perform necessary HTTP calls to check validity
+    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 GitLab...\n" + RESET
+
+      # Check config to make sure no previous API exists
+      unless config.gitlab_api.empty? && config.gitlab_repo.empty? && config.gitlab_endpoint.empty?
+        formatter.print_status "!", RED
+        print BOLD + "Previous GitLab 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 GitLab API + repo info\n" + RESET
+          return false
+        end
+      end
+
+
+      formatter.print_status "!", YELLOW
+      print BOLD + "Access to your GitLab account required to make/update issues\n" + RESET
+      print "      See help or README for more details on GitHub/Bitbucket/GitLab access\n\n"
+
+      print BOLD + "GitLab 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
+     
+       print "\n"
+
+      # GitLab only requires private token to ID, can't get it with basic auth though
+      print BOLD + "GitLab Private Token: " + RESET
+      _token = $stdin.gets.chomp
+      if _token.empty?
+        formatter.print_status "x", RED
+        print BOLD + "Input blank. Please enter your private token!\n\n" + RESET
+        return false
+      end
+
+      
+      # Get project to be synced against 
+      print BOLD + "GitLab Project (ID or Namespace/Name): " + RESET
+      _repo = $stdin.gets.chomp
+      if _repo.empty?
+        formatter.print_status "x", RED
+        print BOLD + "Input blank. Please enter project!\n\n" + RESET
+        return false
+      end
+
+      # Format project to GitLab specs (i.e. if Namespace/Name, need to URL encode /)
+      if !_repo.match(/\d+/)
+        _repo = URI.escape(_repo, "/") 
+      end
+
+      # HTTP Request to make sure we have access to project 
+      # GitLab API - http://api.gitlab.org/
+
+      # Create options hash to pass to Remote::http_call
+      # Project URL + SSL
+      
+      opts = {
+        :url        => "#{ _endpoint }/api/v3/projects/#{ _repo }",
+        :ssl        =>  _endpoint.match(/^https/) ? true : false,
+        :method     => "GET",
+        :headers    => [ { :field => "PRIVATE-TOKEN", :value => _token } ],
+        :verbose    => false
+      }
+
+      _json, _resp  = Watson::Remote.http_call(opts)
+
+      # Check response to validate authorization
+      if _resp.code == "200"
+        formatter.print_status "o", GREEN
+        print BOLD + "Succsesfully accessed GitLab with specified settings\n\n" + RESET
+      else
+        formatter.print_status "x", RED
+        print BOLD + "Unable to access GitLab with specified settings\n" + RESET
+        print "      Status: #{ _resp.code } - #{ _resp.message }\n\n"
+        return false
+      end
+
+      # Store endpoint and API key obtained from POST to @config.gitlab_api
+      config.gitlab_endpoint = _endpoint
+      config.gitlab_api = _token
+      config.gitlab_repo = URI.unescape(_repo)    # Unescape for config readability
+      debug_print "Config GitLab API Endpoint updated to: #{ config.gitlab_endpoint }\n"
+      debug_print "Config GitLab API Key updated to:      #{ config.gitlab_api }\n"
+      debug_print "Config GitLab Repo updated to:         #{ config.gitlab_repo }\n"
+
+
+
+      # All setup has been completed, need to update RC
+      # Call config updater/writer from @config to write config
+      debug_print "Updating config with new GitLab info\n"
+      config.update_conf("gitlab_api", "gitlab_repo", "gitlab_endpoint")
+
+      # Give user some info
+      print "\n"
+      formatter.print_status "o", GREEN
+      print BOLD + "GitLab successfully setup\n" + RESET
+      print "      Issues will now automatically be retrieved from GitLab by default\n"
+      print "      Use -u, --update to post issues to GitLab\n"
+      print "      See help or README for more details on GitHub/Bitbucket/GitLab access\n\n"
+
+      return true
+
+    end
+
+
+    ###########################################################
+    # Get all remote GitLab issues and store into Config container class
+    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.gitlab_api.empty?
+        debug_print "No API found, this shouldn't be called...\n"
+        return false
+      end
+
+
+      # GitLab API doesn't allow you to filter based on state (or anything for that matter...)
+      # Grab all the issues and then sort through them based on state
+
+      # Get all issues 
+      # Create options hash to pass to Remote::http_call
+      # Use URI.escape so config file is readable
+      opts = {
+        :url        => "#{ config.gitlab_endpoint }/api/v3/projects/#{ URI.escape(config.gitlab_repo, "/") }/issues",
+        :ssl        => config.gitlab_endpoint.match(/^https/) ? true : false,
+        :method     => "GET",
+        :headers    => [ { :field => "PRIVATE-TOKEN", :value => config.gitlab_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.gitlab_repo }, GitLab 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 "GitLab invalid, setting config var\n"
+        config.gitlab_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["description"].match(/__md5__ : (\w+)/)).nil?
+
+        # If it does, use md5 as hash key and populate values with our info
+        config.gitlab_issues[_md5[1]] = {
+          :title => issue["title"],
+          :id    => issue["iid"],
+          :state => issue["state"]
+        }
+      end
+    
+      config.gitlab_valid = true
+    end
+
+
+    ###########################################################
+    # Post given issue to remote GitLab repo
+    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.gitlab_api.empty?
+        debug_print "No API found, this shouldn't be called...\n"
+        return false
+      end
+
+
+
+      return false if config.gitlab_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 GitLab
+      opts = {
+        :url        => "#{ config.gitlab_endpoint }/api/v3/projects/#{ URI.escape(config.gitlab_repo, "/") }/issues",
+        :ssl        => config.gitlab_endpoint.match(/^https/) ? true : false,
+        :method     => "POST",
+        :headers    => [ { :field => "PRIVATE-TOKEN", :value => config.gitlab_api } ],
+        :data       => [{ "title"  => issue[:title] + " [#{ issue[:path] }]",
+                         "labels" => "#{issue[:tag]}, watson",
+                         "description" => _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.gitlab_issues[issue[:md5]] = {
+        :title => _json["title"],
+        :id    => _json["iid"],
+        :state => _json["state"]
+      }
+
+
+      return true
+    end
+
+    end
+    end
+  end
+end