watson-ruby 1.5.1 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2cb1804dead00fc6ed4ccfc616c4551473fa2376
-  data.tar.gz: 0a56d91f93d36ae4ed03cfec5a3cd0e27779400f
+  metadata.gz: 91ffcd1dd3152a9e63f14d03f55f7c7ea50e7e95
+  data.tar.gz: f799be3066226f1f7ccae68dc1a2502325817a6c
 SHA512:
-  metadata.gz: 1ccdce1f3dd140fc82a608c69a0a0ab12b2d7e9750efb6f7582230f8f6567f52e9720965224131e328342b6975a1e3f36846525d5c9c45f8f8ba2ac487e595cd
-  data.tar.gz: 5291bd22fa3a29657864492e90e24404fa0a968e783866092ec5406dd073cceef991a5b956b83c226b23d55ad7cc526683076062f7b1b9bafe085f41186e6c76
+  metadata.gz: 8c8be18c25738d0c92401834d3adb7259356c98f4c6422e67a06ce4a15638865b1aada5e8be03c38110957d986c3e6ba31d3acb617892fe6dcb44d00c818781e
+  data.tar.gz: 0270accff9246e278d2e89ea71a5823a21e6771dc14e4d523d96b9bd6e6d2d5b645816b73303c649a46282f4c2f098924af2a4a215da1f6ae8c3cde353a49212

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    watson-ruby (1.5.1)
+    watson-ruby (1.6.0)
       json
 
 GEM

data/README.md

@@ -1,4 +1,5 @@
-# watson-ruby [![Build Status](https://travis-ci.org/nhmood/watson-ruby.png?branch=master)](https://travis-ci.org/nhmood/watson-ruby)
+# watson-ruby [![Gem Version](https://badge.fury.io/rb/watson-ruby.png)](http://badge.fury.io/rb/watson-ruby) [![Build Status](https://travis-ci.org/nhmood/watson-ruby.png?branch=master)](https://travis-ci.org/nhmood/watson-ruby) 
+
 ### an inline issue manager
 [watson](http://goosecode.com/watson) ([mirror](http://nhmood.github.io/watson-ruby)) is a tool for creating and tracking bug reports, issues, and internal notes in code.  
 It is avaliable in two flavors, [watson-ruby](http://github.com/nhmood/watson-ruby) and [watson-perl](http://github.com/nhmood/watson-perl)
@@ -27,6 +28,7 @@ bundle exec rake
 
 
 ## Recent Updates
+  - watson now supports [Asana](http://asana.com)
   - watson now supports [GitLab](http://gitlab.com)
   - [vim-unite-watson.vim](https://github.com/alpaca-tc/vim-unite-watson.vim) integrates watson right into vim!
   - watson now supports multiple export modes
@@ -63,6 +65,10 @@ submit a pull request (comment parsing happens in **lib/watson/paser.rb**)
 - **Python**
 - **Coffeescript**
 - **Clojure**
+- **VimL**
+- **Markdown**
+- **HTML**
+- **Emacslisp**
 
 
 ## Command line arguments
@@ -80,7 +86,7 @@ If no RC file exists, default RC file will be created
    -i, --ignore          list of files, directories, or types to ignore
    -p, --parse-depth     depth to recursively parse directories
    -r, --remote          list / create tokens for remote posting
-                         [github, bitbucket, gitlab]
+                         [github, bitbucket, gitlab, asana]
    -s, --show            filter results (files listed) based on issue status
                          [all, clean, dirty]
    -t, --tags            list of tags to search for
@@ -111,6 +117,13 @@ It should be followed by a space separated list of directories that should be pa
 If watson is run without this parameter, the current directory is parsed.  
 
 
+### --debug [CLASS]
+This parameter enables debug prints for the specified class.  
+It should be followed by a space separated list of classes that should print debug messages.  
+The list of classes are found in `lib/watson`.
+If passed without arguments, debug prints in **ALL** classes of watson will be enabled.  
+
+
 ### -f, --files [FILES]
 This parameter specifies which files watson should parse through.  
 It should be followed by a space separated list of files that should be parsed.  
@@ -149,10 +162,10 @@ If individual directories are passed with the -d (--dirs) flag, each will be par
 If watson is run without this parameter, the parsing depth is unlimited and will search through all subdirectories found.  
 
 
-### -r, --remote [GITHUB, BITBUCKET, GITLAB]
+### -r, --remote [GITHUB, BITBUCKET, GITLAB, ASANA]
 This parameter is used to both list currently established remotes as well as setup new ones.  
 If passed without any options, the currently established remotes will be listed.  
-If passed with a github, bitbucket, gitlab argument, watson will proceed to ask some questions to set up the corresponding remote.  
+If passed with a github, bitbucket, gitlab, asana argument, watson will proceed to ask some questions to set up the corresponding remote.
 
 
 ### -s, --show [ALL, CLEAN, DIRTY]
@@ -180,9 +193,13 @@ This parameter displays the current version of watson you are running.
 ## .watsonrc
 watson supports an RC file that allows for reusing commong settings without repeating command line arguments every time.  
 
-The .watsonrc is placed in every directory that watson is run from as opposed to a unified file (in ~/.watsonrc for example). The thinking behind this is that each project may have a different set of folders to ignore, directories to search through, and tags to look for.  
+The .watsonrc is placed in every directory that watson is run from as opposed to a unified file (in ~/.watsonrc for example). The thought process behind this is that each project may have a different set of folders to ignore, directories to search through, and tags to look for.  
 For example, a C/C++ project might want to look in src/ and ignore obj/ whereas a Ruby project might want to look in lib/ and ignore assets/.  
 
+A base `.watsonrc` is created in the users `$HOME` directory and used as the template for creating all subsequent config files.  
+Any changes made in the `$HOME/.watsonrc` will carry on towards new configs, but will **not** update previously created configs.  
+The `$HOME/.watsonrc` is directly copied, not merged, as to avoid confusion as to the source of config parameters.  
+
 The .watsonrc file is fairly straightforward...  
 **[dirs]** - This is a newline separated list of directories to look in while parsing.  
 
@@ -191,15 +208,27 @@ The .watsonrc file is fairly straightforward...
 **[ignore]** - This is a newline separated list of files / folders to ignore while parsing.    
 This supports wildcard type selecting by providing .filename (no * required)  
 
-**[context_depth]** - This value determines how many lines of context should be grabbed for each issue when posting to a remote.  
+**[context_depth]** - This value determines how many lines of context should be grabbed for each issue when posting to a remote.
 
-**[(github/bitbucket/gitlab)_api]** - If a remote is established, the API key for the corresponding remote is stored here.  
+**[type]** - This field allows for custom filetype/comment associations without having to edit the gem itself.  
+The format of filetype entries should be
+```
+".type"   => ["comment1", "comment2"]
+".nhmood" => ["@@", "***"]
+".cc"     => ["//"]
+```  
+
+**[(github/bitbucket/gitlab/asana)_api]** - If a remote is established, the API key for the corresponding remote is stored here.
 Currently, OAuth has yet to be implemented for Bitbucket so the Bitbucket username is stored here.  
 
 **[(github/bitbucket/gitlab)_repo]** - The repo name / path is stored here.  
 
 **[(github/gitlab)_endpoint]** - The endpoint in case of GitHub Enterprise of GitLab configuration.
 
+**[asana_project]** - The Asana project in case of Asana integration is stored here.
+
+**[asana_workspace]** - The Asana workspace in case of Asana integration is stored here.
+
 The remote related .watsonrc options shouldn't need to be edited manually, as they are automatically populated when the -r, --remote setup is called.  
 
 ## unite.vim
@@ -222,7 +251,7 @@ Special thanks to [@eugenekolo](http://twitter.com/eugenekolo) [[email](eugenek@
 Special thanks to [@crowell](http://github.com/crowell) for testing out watson-ruby!  
 
 ## FAQ
-- ** Will inline issues get deleted if I close them on GitHub/Bitbucket/GitLab?**
+- **Will inline issues get deleted if I close them on GitHub/Bitbucket/GitLab?**
   No, watson won't touch your source code, it will only inform you that issues have been closed remotely.
 
 - **Why Ruby?**  

data/lib/watson.rb

@@ -8,6 +8,7 @@ require_relative 'watson/remote'
 require_relative 'watson/github'
 require_relative 'watson/bitbucket'
 require_relative 'watson/gitlab'
+require_relative 'watson/asana'
 require_relative 'watson/version'
 
 module Watson
@@ -28,13 +29,14 @@ module Watson
   # [todo] - Replace Identify line in each method with method_added call
   #      http://ruby-doc.org/core-2.0.0/Module.html#method-i-method_added
 
-  # Separate ON and OFF so we can force state and still let
-  # individual classes have some control over their prints
 
-  # Global flag to turn ON debugging across all files
-  GLOBAL_DEBUG_ON = false
-  # Gllobal flag to turn OFF debugging across all files
-  GLOBAL_DEBUG_OFF = false
+  # Module container for debug mode (which classes to debug print)
+  # [review] - This doesn't seem like the right place to put this
+  class << self
+    attr_accessor :debug_mode
+    @@debug_mode = Array.new()
+  end
+
 
   # [review] - Not sure if module_function is proper way to scope
   # I want to be able to call debug_print without having to use the scope
@@ -46,18 +48,24 @@ module Watson
   ###########################################################
   # Global debug print that prints based on local file DEBUG flag as well as GLOBAL debug flag
   def debug_print(msg)
-  # [todo] - If input msg is a Hash, use pp to dump it
 
-    # Print only if DEBUG flag of calling class is true OR
-    # GLOBAL_DEBUG_ON of Watson module (defined above) is true
-    # AND GLOBAL_DEBUG_OFF of Watson module (Defined above) is false
+    # If nothing set from CLI, debug_mode will be nil
+    return if Watson.debug_mode.nil?
+
+    # If empty, just --debug passed, print ALL, else selective print
+    _enabled = false
+    if !Watson.debug_mode.empty?
+      _debug = (self.is_a? Class) ? self.name.downcase : self.class.name.downcase
+      Watson.debug_mode.each do |dbg|
+        _enabled = true if _debug.include?(dbg)
+      end
+    else
+      _enabled = true
+    end
 
-    # Sometimes we call debug_print from a static method (class << self)
-    # and other times from a class method, and ::DEBUG is accessed differently
-    # from a class vs object, so lets take care of that
-    _DEBUG = (self.is_a? Class) ? self::DEBUG : self.class::DEBUG
+    return if !_enabled
+    (msg.is_a? Hash) ? (pp msg) : (print "=> #{msg}")
 
-    print "=> #{msg}" if ( (_DEBUG == true || GLOBAL_DEBUG_ON == true) && (GLOBAL_DEBUG_OFF == false))
   end
 
 

data/lib/watson/asana.rb

@@ -0,0 +1,619 @@
+module Watson
+
+  class Remote
+
+    class Asana
+
+      @end_point = "https://app.asana.com/api/1.0"
+      @formatter = nil
+
+      # Debug printing for this class
+      DEBUG = true
+
+      class << self
+
+        # [todo] - post issue to diff. project in same workspace depending on config?
+
+        # Include for debug_print
+        include Watson
+
+        #############################################################################
+        # Setup remote access to Asana
+        # Get API Key, Workspace, Project
+        def setup(config)
+
+          @formatter = Printer.new(config).build_formatter
+
+          # Identify method entry
+          debug_print "#{ self.class } : #{ __method__ }\n"
+
+          @formatter.print_status "+", GREEN
+          print BOLD + "Setting up Asana...\n" + RESET
+
+          config_exists = config.asana_api.empty? && config.asana_workspace.empty? && config.asana_project.empty?
+          unless config_exists
+            @formatter.print_status "!", RED
+            print BOLD + "Previous Asana API 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 Asana config\n" + RESET
+              return false
+            end
+          end
+
+          @formatter.print_status "!", YELLOW
+          print BOLD + "Asana API key required to make/update issues\n" + RESET
+          print "      See help or README for more details on Asana access\n\n"
+
+          print "\n"
+
+          print BOLD + "API Key: " + RESET
+          _api_key = $stdin.gets.chomp
+          if _api_key.empty?
+            @formatter.print_status "x", RED
+            print BOLD + "Input blank. Please enter your api key!\n\n" + RESET
+            return false
+          end
+
+          print BOLD + "Workspace: " + RESET
+          _workspace = $stdin.gets.chomp
+          if _workspace.empty?
+            @formatter.print_status "x", RED
+            print BOLD + "Input blank. Please enter your workspace!\n\n" + RESET
+            return false
+          end
+
+          print BOLD + "Project: " + RESET
+          _project = $stdin.gets.chomp
+          if _project.empty?
+            @formatter.print_status "x", RED
+            print BOLD + "Input blank. Please enter your project!\n\n" + RESET
+            return false
+          end
+
+          workspace_dict = get_workspaces(_api_key)
+
+          unless workspace_dict
+            @formatter.print_status "x", RED
+            print BOLD + "Asana setup failed\n" + RESET
+            return false
+          end
+
+          unless workspace_dict.include?(_workspace)
+            print "\n"
+            @formatter.print_status "x", RED
+            print BOLD + "Workspace doesn't exist\n" + RESET
+            print "      Check that the workspace name is correct\n"
+            print "      Possible workspaces: '#{ workspace_dict.keys.join('\', \'') }'\n\n"
+            return false
+          end
+
+          workspace_id = workspace_dict[_workspace]
+          project_dict = get_projects(_api_key, workspace_id)
+
+          unless project_dict
+            @formatter.print_status "x", RED
+            print BOLD + "Asana API Request failed\n" + RESET
+            return false
+          end
+
+          unless project_dict.include?(_project)
+            print "\n"
+            @formatter.print_status "x", RED
+            print BOLD + "Project doesn't exist within workspace '#{ _workspace }'\n" + RESET
+            print "      Check that the project name is correct\n"
+            print "      Possible projects: '#{ project_dict.keys.join('\', \'') }'\n\n"
+            return false
+          end
+
+          config.asana_api = _api_key
+          debug_print "Asana API Key updated to: #{ config.asana_api }\n"
+          config.asana_workspace = _workspace
+          debug_print "Asana Workspace updated to: #{ config.asana_workspace }\n"
+          config.asana_project = _project
+          debug_print "Asana Project updated to: #{ config.asana_project }\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 Asana info\n"
+          config.update_conf("asana_api", "asana_workspace", "asana_project")
+
+          # Give user some info
+          print "\n"
+          @formatter.print_status "o", GREEN
+          print BOLD + "Asana successfully setup\n" + RESET
+          print "      Issues will now automatically be retrieved from Asana by default\n"
+          print "      Use -u, --update to post issues to Asana\n"
+          print "      See help or README for more details on GitHub/Bitbucket/Asana access\n\n"
+
+          true
+
+        end
+
+        ###########################################################
+        # Post given issue to Asana project
+        def post_issue(issue, 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.asana_api.empty?
+            debug_print "No asana API found, this shouldn't be called...\n"
+            return false
+          end
+
+          return false if config.asana_issues.key?(issue[:md5])
+          debug_print "#{issue[:md5]} not found in remote issues, posting\n"
+
+          _api_key = config.asana_api
+          _workspace = config.asana_workspace
+          _project = config.asana_project
+
+          workspace_id = get_workspace_id(_api_key, _workspace)
+
+          unless workspace_id
+            @formatter.print_status "x", RED
+            print BOLD + "Unable to get workspace info from Asana API\n" + RESET
+            return false
+          end
+
+          tags = init_tags(config, _api_key, workspace_id)
+
+          unless tags
+            @formatter.print_status "x", RED
+            print BOLD + "Unable to initialise tags\n" + RESET
+            return false
+          end
+
+          project_id = get_project_identifier(_api_key, _project, workspace_id)
+
+          unless project_id
+            @formatter.print_status "x", RED
+            print BOLD + "Unable to get project info from Asana API\n" + RESET
+            return false
+          end
+
+          tasks_url = "#{ @end_point }/workspaces/#{ workspace_id }/tasks"
+
+          # Create the body text for the issue here, too long to fit nicely into opts hash
+          _body =
+              "__filename__ : #{ issue[:path] }\n" +
+                  "__line #__ : #{ issue[:line_number] }\n" +
+                  "__tag__ : #{ issue[:tag] }\n" +
+                  "__md5__ : #{ issue[:md5] }\n\n" +
+                  "#{ issue[:context].join }\n"
+
+          opts = {
+              :url => tasks_url,
+              :ssl => true,
+              :method => "POST",
+              :basic_auth => [_api_key, ""],
+              :data => [{"name" => issue[:title],
+                         "notes" => _body,
+                         "projects" => project_id}],
+              :verbose => false
+          }
+
+          _json, _resp = Watson::Remote.http_call(opts)
+
+          unless _resp.code == "201"
+            @formatter.print_status "x", RED
+            print BOLD + "Unable to access Asana API, key may be invalid\n" + RESET
+            print "      Consider running --remote (-r) option to regenerate key\n\n"
+            print "      Status: #{ _resp.code } - #{ _resp.message }\n"
+            return false
+          end
+
+          _data = _json["data"]
+          new_task_id = _data["id"]
+
+          debug_print "creating file tag"
+          file_tag = create_or_get_tag(_api_key,workspace_id,issue[:path])
+          debug_print "tagging with file tag <#{ file_tag }>"
+
+          if file_tag
+            file_tag_id = file_tag['id']
+            unless tag_task(_api_key, new_task_id, file_tag_id)
+              @formatter.print_status "!", RED
+              print BOLD + "Unable to tag with '#{ issue[:path] }'\n" + RESET
+            end
+          else
+            @formatter.print_status "!", RED
+            print BOLD + "Unable create tag '#{ issue[:path] }'\n" + RESET
+          end
+
+          debug_print "tagging with issue tag <#{ issue[:tag] }>"
+          issue_tag_id = tags[issue[:tag]]['id']
+          unless tag_task(_api_key, new_task_id, issue_tag_id)
+            @formatter.print_status "!", RED
+            print BOLD + "Unable to tag with '#{ issue[:tag] }'\n" + RESET
+          end
+
+          debug_print "tagging with watson tag"
+          watson_tag_id = tags['watson']['id']
+          unless tag_task(_api_key, new_task_id, watson_tag_id)
+            @formatter.print_status "!", RED
+            print BOLD + "Unable to tag with 'watson'\n" + RESET
+          end
+
+          # Parse response and append issue hash so we are up to date
+          config.asana_issues[issue[:md5]] = {
+              :title => _data["name"],
+              :id    => _data["id"],
+              :state => _data["completed"]
+          }
+
+          true
+
+        end
+
+        ###########################################################
+        # Get all remote Asana 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.asana_api.empty?
+            debug_print "No asana API found, this shouldn't be called...\n"
+            return false
+          end
+
+          _api_key = config.asana_api
+          _workspace = config.asana_workspace
+          _project = config.asana_project
+
+          task_records = get_tasks(_api_key, _project, _workspace)
+
+          unless task_records
+            config.asana_valid = false
+            return false
+          end
+
+          task_records.each do |issue|
+            # Skip this issue if it doesn't have watson md5 tag
+            _md5 = issue["notes"].match(/.*__md5__ : (\w+)\s.*/)
+            next if (_md5).nil?
+
+            # If it does, use md5 as hash key and populate values with our info
+            config.asana_issues[_md5[1]] = {
+                :title => issue["name"],
+                :id    => issue["id"],
+                :state => issue["completed"] # TODO: How to check status?
+            }
+          end
+
+          config.asana_valid = true
+
+        end
+
+        private
+
+          ###########################################################
+          # Return all projects under the given api_key/workspace
+          def get_projects(_api_key, workspace_id)
+
+            debug_print "#{ self.class } : #{ __method__ }\n"
+
+            projects_url = "#{ @end_point }/workspaces/#{ workspace_id}/projects"
+
+            opts = {
+                :url => projects_url,
+                :ssl => true,
+                :method => "GET",
+                :basic_auth => [_api_key, ""],
+                :verbose => false
+            }
+
+            _json, _resp = Watson::Remote.http_call(opts)
+
+            if _resp.code != "200"
+              print "\n"
+              @formatter.print_status "x", RED
+              print BOLD + "Unable to access project list\n" + RESET
+              print "       Status: #{ _resp.code } - #{ _resp.message }\n\n"
+              return false
+            end
+
+            project_list = _json["data"]
+            project_dict = {}
+            project_list.each { |x| project_dict[x["name"]] = x["id"] }
+            project_dict
+          end
+
+          ###########################################################
+          # Return all workspaces under the given API key
+          def get_workspaces(_api_key)
+
+            debug_print "#{ self.class } : #{ __method__ }\n"
+
+            workspaces_url = "#{ @end_point }/workspaces"
+
+            opts = {
+                :url => workspaces_url,
+                :ssl => true,
+                :method => "GET",
+                :basic_auth => [_api_key, ""],
+                :verbose => false
+            }
+
+            _json, _resp = Watson::Remote.http_call(opts)
+
+            if _resp.code != "200"
+              print "\n"
+              @formatter.print_status "x", RED
+              print BOLD + "Unable to access workspace list with given credentials\n" + RESET
+              print "       Check that API key is correct\n"
+              print "       Status: #{ _resp.code } - #{ _resp.message }\n\n"
+              return false
+            end
+
+            workspace_list = _json["data"]
+            workspace_dict = {}
+            workspace_list.each { |x| workspace_dict[x["name"]] = x["id"] }
+            workspace_dict
+          end
+
+          ###########################################################
+          # Return all tasks in given project/workspace
+          def get_tasks(_api_key, _project, _workspace)
+
+            debug_print "#{ self.class } : #{ __method__ }\n"
+
+            workspace_id = get_workspace_id(_api_key, _workspace)
+
+            unless workspace_id
+              @formatter.print_status "x", RED
+              print BOLD + "Unable to get workspace info from Asana API\n" + RESET
+              return false          end
+
+            project_id = get_project_identifier(_api_key, _project, workspace_id)
+
+            unless project_id
+              @formatter.print_status "x", RED
+              print BOLD + "Unable to get project info from Asana API\n" + RESET
+              return false
+            end
+
+            tasks_url = "#{ @end_point }/projects/#{ project_id }/tasks?opt_fields=name,notes,completed&include_archived=true"
+
+            opts = {
+                :url => tasks_url,
+                :ssl => true,
+                :method => "GET",
+                :basic_auth => [_api_key, ""],
+                :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 Asana API, key 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 "Asana invalid, setting config var\n"
+              #return false
+            end
+
+            _json["data"]
+
+          end
+
+          ###########################################################
+          # Return full record for a particular task
+          def get_task_record(_api_key, task_id)
+
+            debug_print "#{ self.class } : #{ __method__ }\n"
+
+            task_url = "#{ @end_point }/tasks/#{ task_id }"
+
+            opts = {
+                :url => task_url,
+                :ssl => true,
+                :method => "GET",
+                :basic_auth => [_api_key, ""],
+                :verbose => false
+            }
+
+            _json, _resp = Watson::Remote.http_call(opts)
+
+            if _resp.code != "200"
+              @formatter.print_status "x", RED
+              print BOLD + "Unable to get task, API key may be invalid\n" + RESET
+              print "      Consider running --remote (-r) option to regenerate key\n\n"
+              print "      Status: #{ _resp.code } - #{ _resp.message }\n"
+              return false
+            end
+
+            _json["data"]
+          end
+
+          ###########################################################
+          # Get project id given project and work space name
+          def get_project_identifier(_api_key, _project, workspace_id)
+            debug_print "#{ self.class } : #{ __method__ }\n"
+            projects_dict = get_projects(_api_key, workspace_id)
+            unless projects_dict
+              return false
+            end
+            projects_dict[_project]
+          end
+
+          ###########################################################
+          # Get workspace id given workspace name
+          def get_workspace_id(_api_key, _workspace)
+            debug_print "#{ self.class } : #{ __method__ }\n"
+            workspace_dict = get_workspaces(_api_key)
+            unless workspace_dict
+              return false
+            end
+            workspace_dict[_workspace]
+          end
+
+          ###########################################################
+          # Tags task with task_id with the tag specified by tag_id
+          def tag_task(_api_key, task_id, tag_id)
+            debug_print "#{ self.class } : #{ __method__ }\n"
+
+            tags_url = "#{ @end_point }/tasks/#{ task_id }/addTag"
+
+            opts = {
+                :url => tags_url,
+                :ssl => true,
+                :method => "POST",
+                :basic_auth => [_api_key, ""],
+                :data => [{"tag" => tag_id}],
+                :verbose => false
+            }
+
+            _json, _resp = Watson::Remote.http_call(opts)
+
+            unless _resp.code == "200"
+              @formatter.print_status "x", RED
+              print BOLD + "Unable to access Asana API, key may be invalid\n" + RESET
+              print "      Consider running --remote (-r) option to regenerate key\n\n"
+              print "      Status: #{ _resp.code } - #{ _resp.message }\n"
+              return false
+            end
+
+            _json['data']
+
+          end
+
+          ###########################################################
+          # Returns hash, tag name => tag
+          def get_tags(_api_key, _workspace_id)
+            debug_print "#{ self.class } : #{ __method__ }\n"
+
+            tags_url = "#{ @end_point }/workspaces/#{ _workspace_id }/tags"
+
+            opts = {
+                :url => tags_url,
+                :ssl => true,
+                :method => "GET",
+                :basic_auth => [_api_key, ""],
+                :verbose => false
+            }
+
+            _json, _resp = Watson::Remote.http_call(opts)
+
+            unless _resp.code == "200"
+              @formatter.print_status "x", RED
+              print BOLD + "Unable to access Asana API, key may be invalid\n" + RESET
+              print "      Consider running --remote (-r) option to regenerate key\n\n"
+              print "      Status: #{ _resp.code } - #{ _resp.message }\n"
+              return false
+            end
+
+            # [review] - fancy ruby way of generating this hash?
+
+            _tags_dict = {}
+            _json['data'].each { |x| _tags_dict[x['name']] = x }
+            _tags_dict
+
+          end
+
+          ###########################################################
+          # Make sure base tags exist (tag_list + the watson tag), add them if not
+          def init_tags(config, _api_key, _workspace_id)
+            debug_print "#{ self.class } : #{ __method__ }\n"
+            tags_to_check = config.tag_list.dup << 'watson'
+            create_and_get_tags(_api_key, _workspace_id, tags_to_check)
+          end
+
+          ###########################################################
+          # Adds 'tags_to_add' and returns full list of tags.
+          # The reason that this is combined into one method is that
+          # Asana do not actually 'create' the tag properly until
+          # it has been used to tag a task
+          def create_and_get_tags(_api_key, _workspace_id, tags_to_add)
+            debug_print "#{ self.class } : #{ __method__ }\n"
+
+            _tags = get_tags(_api_key, _workspace_id)
+
+            unless _tags
+              return false
+            end
+
+            debug_print "Checking that tags #{ tags_to_add } exist\n"
+            tags_to_create = tags_to_add - _tags.keys
+            if tags_to_create
+              debug_print "Need to create tags #{ tags_to_create }\n"
+            end
+            tags_to_create.each do |tag_name|
+              _tag = create_tag(_api_key, _workspace_id, tag_name)
+              unless _tag
+                return false
+              end
+              _tags[_tag['name']] = _tag
+            end
+
+            _tags
+          end
+
+          ###########################################################
+          # Creates a tag in the given workspace
+          def create_tag(_api_key, _workspace_id, tag)
+            debug_print "#{ self.class } : #{ __method__ }\n"
+
+            opts = {
+                :url => "#{ @end_point }/workspaces/#{ _workspace_id }/tags",
+                :ssl => true,
+                :method => "POST",
+                :basic_auth => [_api_key, ""],
+                :data => [{'name'=>tag}],
+                :verbose => false
+            }
+
+            _json, _resp = Watson::Remote.http_call(opts)
+
+            unless _resp.code == "201"
+              @formatter.print_status "x", RED
+              print BOLD + "Unable to access Asana API, key may be invalid\n" + RESET
+              print "      Consider running --remote (-r) option to regenerate key\n\n"
+              print "      Status: #{ _resp.code } - #{ _resp.message }\n"
+              return false
+            end
+
+            _data = _json['data']
+
+            debug_print "Created tag '#{ tag }' with id #{ _data['id'] } \n"
+
+            _data
+
+          end
+
+          ###########################################################
+          # Creates a tag in the given workspace or else if already
+          # exists, returns that tag
+          def create_or_get_tag(_api_key, _workspace_id, tag_name)
+            debug_print "#{ self.class } : #{ __method__ }\n"
+            _tags = create_and_get_tags(_api_key, _workspace_id, [tag_name])
+            _tags ? _tags[tag_name] : false
+          end
+
+      end
+
+      end
+
+  end
+
+end