watson-ruby 1.0.0

data/lib/watson/fs.rb

@@ -0,0 +1,69 @@
+module Watson
+	# File system utility function class 
+	# Contains all methods for file access in watson 
+	class FS 
+		
+		# Debug printing for this class
+		DEBUG = false
+	
+		class << self
+		# [todo] - Not sure whether to make check* methods return FP
+		#		   Makes it nice to get it returned and use it but
+		#		   not sure how to deal with closing the FP after
+		#		   Currently just close inside
+
+		# Include for debug_print
+		include Watson
+		
+		###########################################################
+		# Check if file exists and can be opened
+		def check_file(file)
+			
+			# Identify method entry
+			debug_print "#{ self } : #{ __method__ }\n"
+		
+			# Error check for input
+			if file.length == 0
+				debug_print "No file specified\n" 
+				return false
+			end
+
+			# Check if file can be opened
+			if File.readable?(file)
+				debug_print "#{ file } exists and opened successfully\n"
+				return true
+			else
+				debug_print "Could not open #{ file }, skipping\n"
+				return false
+			end					
+		end
+
+
+		###########################################################
+		# Check if directory exists and can be opened 
+		def check_dir(dir)
+			
+			# Identify method entry
+			debug_print "#{ self } : #{ __method__ }\n"
+	
+			# Error check for input
+			if dir.length == 0
+				debug_print "No directory specified\n"
+				return false
+			end
+
+			# Check if directory exists 
+			if Dir.exists?(dir)
+				debug_print "#{ dir } exists and opened succesfully\n"
+				return true
+			else
+				debug_print "Could not open #{ dir }, skipping\n"
+				return false
+			end 
+		end
+
+		end
+	end
+end
+
+

data/lib/watson/github.rb

@@ -0,0 +1,369 @@
+module Watson
+	class Remote
+		# GitHub remote access class
+		# Contains all necessary methods to obtain access to, get issue list,
+		# and post issues to GitHub 
+		class GitHub
+		
+		# Debug printing for this class
+		DEBUG = false		
+
+		class << self
+
+		# [todo] - Allow closing of issues from watson? Don't like that idea but maybe
+		# [review] - Properly scope Printer class so we dont need the Printer. for 
+		#			 method calls?
+		# [todo] - Keep asking for user data until valid instead of leaving app
+
+
+		# Include for debug_print
+		include Watson
+		
+		#############################################################################	
+		# Setup remote access to GitHub 
+		# 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"
+		
+			Printer.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?
+				Printer.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"
+					Printer.print_status "x", RED
+					print BOLD + "Not overwriting current GitHub API + repo info\n" + RESET
+					return false
+				end
+			end
+
+
+			Printer.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"
+
+
+			# [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?
+				Printer.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?
+				Printer.print_status "x", RED
+				print BOLD + "Input is blank. Please enter your password!\n\n" + RESET
+				return false
+			end
+
+			# 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        => "https://api.github.com/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"
+				Printer.print_status "o", GREEN
+				print BOLD + "Obtained OAuth Token\n\n" + RESET
+			else
+				Printer.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 API key obtained from POST to @config.github_api
+			config.github_api = _json["token"]
+			debug_print "Config GitHub API Key updated to: #{ config.github_api }\n"
+
+
+			# Get repo information, if blank give error
+			Printer.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"
+				Printer.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"
+				Printer.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        => "https://api.github.com/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"
+				Printer.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"
+				Printer.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) 
+			Printer.print_status "+", GREEN
+			print BOLD + "Creating label for watson on GitHub...\n" + RESET
+			if _resp.code == "201"
+				Printer.print_status "+", GREEN
+				print BOLD + "Label successfully created\n" + RESET
+			elsif _resp.code == "422" && _json["code"] == "already_exists"
+				Printer.print_status "!", YELLOW
+				print BOLD + "Label already exists\n" + RESET
+			else
+				Printer.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")
+
+			# Give user some info
+			print "\n"
+			Printer.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 -p, --push to post issues to GitHub\n"
+			print "      See help or README for more details on GitHub/Bitbucket access\n\n"
+
+			return true
+
+		end
+
+
+		###########################################################
+		# Get all remote GitHub issues and store into Config container class  
+
+		def get_issues(config)
+
+			# Identify method entry
+			debug_print "#{ self.class } : #{ __method__ }\n"
+
+			# 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        => "https://api.github.com/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"
+				Printer.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        => "https://api.github.com/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"
+				Printer.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 given issue to remote GitHub 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"
+	
+				
+			# 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        => "https://api.github.com/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"
+				Printer.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
+		
+		end
+		end
+	end
+end

data/lib/watson/parser.rb

@@ -0,0 +1,405 @@
+module Watson
+	# Dir/File parser class
+	# Contains all necessary methods to parse through files and directories 
+	# for specified tags and generate data structure containing found issues
+	class Parser
+
+		# Include for debug_print
+		include Watson
+
+		# [review] - Should this require be required higher up or fine here
+		# Include for Digest::MD5.hexdigest used in issue creating
+		require 'digest'
+		require 'pp'
+		
+		# Debug printing for this class
+		DEBUG = false 		
+	
+		###########################################################
+		# Initialize the parser with the current watson config 
+		def initialize(config)
+		# [review] - Not sure if passing config here is best way to access it
+		
+			# Identify method entry
+			debug_print "#{ self } : #{ __method__ }\n"
+			
+			@config = config
+		end	
+
+
+		###########################################################
+		# Begins parsing of files / dirs specified in the initial dir/file lists   
+		def run
+		
+			# Identify method entry
+			debug_print "#{ self } : #{ __method__ }\n"
+	
+			# Go through all files added from CL (sort them first)
+			# If empty, sort and each will do nothing, no errors
+			_completed_dirs = Array.new()
+			_completed_files = Array.new()
+			if @config.cl_entry_set
+				@config.file_list.sort.each	do | _file |
+					_completed_files.push(parse_file(_file))
+				end
+			end
+			
+			# Then go through all the specified directories 
+			# Initial parse depth to parse_dir is 0 (unlimited)
+			@config.dir_list.sort.each do | _dir |
+				_completed_dirs.push(parse_dir(_dir, 0))
+			end	
+			
+			# Create overall hash for parsed files	
+			_structure = Hash.new()
+			_structure[:files] = _completed_files
+			_structure[:subdirs]  = _completed_dirs
+
+			debug_print "_structure dump\n\n"
+			debug_print PP.pp(_structure, "")
+			debug_print "\n\n"
+			
+			return _structure
+		end	
+
+
+		###########################################################
+		# Parse through specified directory and find all subdirs and files
+		def parse_dir(dir, depth)
+
+			# Identify method entry
+			debug_print "#{ self } : #{ __method__ }\n"
+
+			# Error check on input
+			if !Watson::FS.check_dir(dir)
+				print "Unable to open #{ dir }, exiting\n"
+				return false
+			else
+				debug_print "Opened #{ dir } for parsing\n"
+			end
+			
+			debug_print "Parsing through all files/directories in #{ dir }\n"
+
+			# [review] - Shifted away from single Dir.glob loop to separate for dir/file
+			# 			 This duplicates code but is much better for readability
+			# 			 Not sure which is preferred?
+			
+
+			# Remove leading . or ./
+			_glob_dir = dir.gsub(/^\.(\/?)/, '')
+			debug_print "_glob_dir: #{_glob_dir}\n"
+	
+
+			# Go through directory to find all files
+			# Create new array to hold all parsed files
+			_completed_files = Array.new()
+			Dir.glob("#{ _glob_dir }{*,.*}").select { | _fn | File.file?(_fn) }.sort.each do | _entry |
+				debug_print "Entry: #{_entry} is a file\n"	
+			
+			
+				# [review] - Warning to user when file is ignored? (outside of debug_print)
+				# Check against ignore list, if match, set to "" which will be ignored
+				@config.ignore_list.each do | _ignore |
+					# [review] - Better "Ruby" way to check for "*"? 
+					# [review] - Probably cleaner way to perform multiple checks below
+					# Look for *.type on list, regex to match entry
+					if _ignore[0] == "*"
+						_cut = _ignore[1..-1]
+						if _entry.match(/#{ _cut }/)
+							debug_print "#{ _entry } is on the ignore list, setting to \"\"\n"
+							_entry = ""
+							break
+						end
+					# Else check for verbose ignore match
+					else
+						if  _entry  == _ignore || File.absolute_path(_entry) == _ignore
+							debug_print "#{ _entry } is on the ignore list, setting to \"\"\n"
+							_entry = ""
+							break
+						end
+					end
+				end	
+
+				# If the resulting entry (after filtering) isn't empty, parse it and push into file array
+				if !_entry.empty?
+					debug_print "Parsing #{ _entry }\n"
+					_completed_files.push(parse_file(_entry))
+				end	
+			
+			end
+				 
+			
+			# Go through directory to find all subdirs
+			# Create new array to hold all parsed subdirs 
+			_completed_dirs = Array.new()
+			Dir.glob("#{ _glob_dir }{*, .*}").select { | _fn | File.directory?(_fn) }.sort.each do | _entry |
+				debug_print "Entry: #{ _entry } is a dir\n"	
+					
+				
+
+				## Depth limit logic
+				# Current depth is depth of previous parse_dir (passed in as second param) + 1
+				_cur_depth = depth + 1
+				debug_print "Current Folder depth: #{ _cur_depth }\n"
+				
+				# If Config.parse_depth is 0, no limit on subdir parsing
+				if @config.parse_depth == 0
+					debug_print "No max depth, parsing directory\n"
+					_completed_dirs.push(parse_dir("#{ _entry }/", _cur_depth))
+				# If current depth is less than limit (set in config), parse directory and pass depth
+				elsif _cur_depth < @config.parse_depth.to_i + 1
+					debug_print "Depth less than max dept (from config), parsing directory\n"
+					_completed_dirs.push(parse_dir("#{ _entry }/", _cur_depth))
+				# Else, depth is greater than limit, ignore the directory
+				else
+					debug_print "Depth greater than max depth, ignoring\n"	
+				end
+
+				# Add directory to ignore list so it isn't repeated again accidentally
+				@config.ignore_list.push(_entry)
+			end
+
+
+			# [review] - Not sure if Dir.glob requires a explicit directory/file close?
+				
+			# Create hash to hold all parsed files and directories
+			_structure = Hash.new()
+			_structure[:curdir] = dir
+			_structure[:files] = _completed_files
+			_structure[:subdirs]  = _completed_dirs
+			return _structure
+		end
+
+
+		###########################################################
+		# Parse through individual files looking for issue tags, then generate formatted issue hash 
+		def parse_file(filename)
+		# [review] - Rename method input param to filename (more verbose?)
+
+			# Identify method entry
+			debug_print "#{ self } : #{ __method__ }\n"
+
+			_relative_path = filename
+			_absolute_path = File.absolute_path(filename) 
+
+			# Error check on input, use input filename to make sure relative path is correct
+			if !Watson::FS.check_file(_relative_path)
+				print "Unable to open #{ _relative_path }, exiting\n"
+				return false
+			else
+				debug_print "Opened #{ _relative_path } for parsing\n"
+				debug_print "Short path: #{ _relative_path }\n"
+			end
+
+
+			# Get filetype and set corresponding comment type
+			_comment_type = get_comment_type(_relative_path)
+			if !_comment_type
+				debug_print "Using default (#) comment type\n"
+				_comment_type = "#"
+			end
+
+
+			# Open file and read in entire thing into an array
+			# Use an array so we can look ahead when creating issues later
+			# [review] - Not sure if explicit file close is required here
+			# [review] - Better var name than data for read in file?
+			_data = Array.new()
+			File.open(_absolute_path, 'r').read.each_line do | _line |
+				_data.push(_line)
+			end
+
+	
+			# Initialize issue list hash 
+			_issue_list = Hash.new()
+			_issue_list[:relative_path] = _relative_path 
+			_issue_list[:absolute_path] = _absolute_path
+			_issue_list[:has_issues] = false
+			@config.tag_list.each do | _tag |
+				debug_print "Creating array named #{ _tag }\n"
+				# [review] - Use to_sym to make tag into symbol instead of string?
+				_issue_list[_tag] = Array.new
+			end
+			
+			# Loop through all array elements (lines in file) and look for issues
+			_data.each_with_index do | _line, _i |
+
+				# Find any comment line with [tag] - text (any comb of space and # acceptable)
+				# Using if match to stay consistent (with config.rb) see there for
+				# explanation of why I do this (not a good good one persay...)
+				_mtch = _line.encode('UTF-8', :invalid => :replace).match(/^[#{ _comment_type }+?\s+?]+\[(\w+)\]\s+-\s+(.+)/)
+				if !_mtch
+					debug_print "No valid tag found in line, skipping\n"
+					next
+				end
+			
+				# Set tag
+				_tag = _mtch[1]
+
+				# Make sure that the tag that was found is something we accept
+				# If not, skip it but tell user about an unrecognized tag
+				if !@config.tag_list.include?(_tag)
+					Printer.print_status "!", RED
+					print "Unknown tag [#{ _tag }] found, ignoring\n"
+					print "      You might want to include it in your RC or with the -t/--tags flag\n"
+					next
+				end
+
+				# Found a valid match (with recognized tag)
+				# Set flag for this issue_list (for file) to indicate that
+				_issue_list[:has_issues] = true
+
+				_title = _mtch[2]
+				debug_print "Issue found\n"
+				debug_print "Tag: #{ _tag }\n"
+				debug_print "Issue: #{ _title }\n"	
+
+				# Create hash for each issue found
+				_issue = Hash.new
+				_issue[:line_number] = _i + 1
+				_issue[:title] = _title
+
+				# Grab context of issue specified by Config param (+1 to include issue itself)
+				_context = _data[_i..(_i + @config.context_depth + 1)]
+
+				# [review] - There has got to be a better way to do this...	
+				# Go through each line of context and determine indentation
+				# Used to preserve indentation in post
+				_cut = Array.new 
+				_context.each do | _line |
+					_max = 0
+					# Until we reach a non indent OR the line is empty, keep slicin'
+					until !_line.match(/^( |\t|\n)/) || _line.empty?
+						# [fix] - Replace with inplace slice!
+						_line = _line.slice(1..-1)
+						_max = _max + 1
+
+						debug_print "New line: #{ _line }\n"
+						debug_print "Max indent: #{ _max }\n"
+					end
+					
+					# Push max indent for current line to the _cut array 
+					_cut.push(_max)	
+				end	
+	
+				# Print old _context
+				debug_print "\n\n Old Context \n"
+				debug_print PP.pp(_context, "")
+				debug_print "\n\n"
+
+				# Trim the context lines to be left aligned but maintain indentation
+				# Then add a single \t to the beginning so the Markdown is pretty on GitHub/Bitbucket
+				_context.map! { | _line | "\t#{ _line.slice(_cut.min .. -1) }" }
+			
+				# Print new _context	
+				debug_print("\n\n New Context \n")
+				debug_print PP.pp(_context, "")
+				debug_print("\n\n")
+
+				_issue[:context] = _context
+					
+				# These are accessible from _issue_list, but we pass individual issues
+				# to the remote poster, so we need this here to reference them for GitHub/Bitbucket
+				_issue[:tag] = _tag
+				_issue[:path] = _relative_path 
+
+				# Generate md5 hash for each specific issue (for bookkeeping)
+				_issue[:md5] = ::Digest::MD5.hexdigest("#{ _tag }, #{ _relative_path }, #{ _title }")
+				debug_print "#{ _issue }\n"
+
+
+				# [todo] - Figure out a way to queue up posts so user has a progress bar?
+				# That way user can tell that wait is because of http calls not app
+	
+				# If GitHub is valid, pass _issue to GitHub poster function
+				# [review] - Keep Remote as a static method and pass config every time?
+				#			 Or convert to a regular class and make an instance with @config
+
+					if @config.remote_valid
+						if @config.github_valid
+							debug_print "GitHub is valid, posting issue\n"
+							Remote::GitHub.post_issue(_issue, @config)
+						else
+							debug_print "GitHub invalid, not posting issue\n"
+						end	
+
+
+						if @config.bitbucket_valid
+							debug_print "Bitbucket is valid, posting issue\n"
+							Remote::Bitbucket.post_issue(_issue, @config)
+						else
+							debug_print "Bitbucket invalid, not posting issue\n"
+						end
+					end
+	
+					# [review] - Use _tag string as symbol reference in hash or keep as string?
+					# Look into to_sym to keep format of all _issue params the same
+					_issue_list[_tag].push( _issue )
+
+			end
+		
+			# [review] - Return of parse_file is different than watson-perl
+			# Not sure which makes more sense, ruby version seems simpler
+			# perl version might have to stay since hash scoping is weird in perl
+			debug_print "\nIssue list: #{ _issue_list }\n"
+
+			return _issue_list
+		end
+
+
+		###########################################################
+		# Get comment syntax for given file 
+		def get_comment_type(filename)
+
+			# Identify method entry
+			debug_print "#{ self } : #{ __method__ }\n"
+
+			# Grab the file extension (.something)
+			# Check to see whether it is recognized and set comment type
+			# If unrecognized, try to grab the next .something extension
+			# This is to account for file.cpp.1 or file.cpp.bak, ect
+
+			# [review] - Matz style while loop a la http://stackoverflow.com/a/10713963/1604424
+			# Create _mtch var so we can access it outside of the do loop
+		
+			_mtch = String.new()
+			loop do
+				_mtch = filename.match(/(\.(\w+))$/)
+				debug_print "Extension: #{ _mtch }\n"
+
+				# Break if we don't find a match 
+				break if _mtch.nil?
+
+				# Determine file type
+				case _mtch[0]
+				# C / C++, Java, C#
+				# [todo] - Add /* style comment
+				when ".cpp", ".cc", ".c", ".hpp", ".h",
+					 ".java", ".class", ".cs"
+					debug_print "Comment type is: //\n"
+					return "//"
+
+				# Bash, Ruby, Perl, Python
+				when ".sh", ".rb", ".pl", ".py"
+					debug_print "Comment type is: #\n"
+					return "#"
+
+				# Can't recognize extension, keep looping in case of .bk, .#, ect
+				else
+					filename = filename.gsub(/(\.(\w+))$/, "")
+					debug_print "Didn't recognize, searching #{ filename }\n"
+				
+				end
+			end
+
+			# We didn't find any matches from the filename, return error (0)
+			# Deal with what default to use in calling method
+			# [review] - Is Ruby convention to return 1 or 0 (or -1) on failure/error?
+			debug_print "Couldn't find any recognized extension type\n"
+			return false 
+			
+		end 
+
+
+	end
+end