watson-ruby 1.0.5 → 1.0.6

data/lib/watson/printer.rb

@@ -1,5 +1,5 @@
 module Watson
-    
+
     # Color definitions for pretty printing
     # Defined here because we need Global scope but makes sense to have them
     # in the printer.rb file at least
@@ -29,38 +29,38 @@ module Watson
     include Watson
 
     # Debug printing for this class
-    DEBUG = false     
+    DEBUG = false
 
     class << self
-  
+
     # Include for debug_print (for static methods)
     include Watson
 
     ###########################################################
-    # Custom color print for static call (only writes to STDOUT)   
+    # Custom color print for static call (only writes to STDOUT)
     def cprint (msg = "", color = "")
 
       # Identify method entry
       debug_print "#{ self } : #{ __method__ }\n"
-    
+
       # This little check will allow us to take a Constant defined color
       # As well as a [0-256] value if specified
-      if (color.is_a?(String))  
+      if (color.is_a?(String))
         debug_print "Custom color specified for cprint\n"
         STDOUT.write(color)
       elsif (color.between?(0, 256))
         debug_print "No or Default color specified for cprint\n"
         STDOUT.write("\e[38;5;#{ color }m")
       end
-    
+
       STDOUT.write(msg)
     end
 
 
     ###########################################################
-    # Standard header print for static call (uses static cprint) 
-    def print_header 
-    
+    # Standard header print for static call (uses static cprint)
+    def print_header
+
       # Identify method entry
       debug_print "#{ self } : #{ __method__ }\n"
 
@@ -76,9 +76,9 @@ module Watson
 
 
     ###########################################################
-    # Status printer for static call (uses static cprint) 
+    # Status printer for static call (uses static cprint)
     # Print status block in standard format
-    def print_status(msg, color) 
+    def print_status(msg, color)
       cprint RESET + BOLD
       cprint WHITE + "[ "
       cprint "#{ msg } ", color
@@ -93,19 +93,19 @@ module Watson
 
       # Identify method entry
       debug_print "#{ self } : #{ __method__ }\n"
-      
+
       @config = config
       return true
-    end 
+    end
+
 
-    
     ###########################################################
-    # Take parsed structure and print out in specified formatting 
+    # Take parsed structure and print out in specified formatting
     def run(structure)
 
       # Identify method entry
       debug_print "#{ self } : #{ __method__ }\n"
-    
+
       # Check Config to see if we have access to less for printing
       # If so, open our temp file as the output to write to
       # Else, just print out to STDOUT
@@ -115,8 +115,8 @@ module Watson
       else
         debug_print "Unix less is unavaliable, setting output to STDOUT\n"
         @output = STDOUT
-      end 
-      
+      end
+
       # Print header for output
       debug_print "Printing Header\n"
       print_header
@@ -148,7 +148,7 @@ module Watson
 
       # This little check will allow us to take a Constant defined color
       # As well as a [0-256] value if specified
-      if (color.is_a?(String))  
+      if (color.is_a?(String))
         debug_print "Custom color specified for cprint\n"
         @output.write(color)
       elsif (color.between?(0, 256))
@@ -159,10 +159,10 @@ module Watson
       @output.write(msg)
     end
 
-  
+
     ###########################################################
     # Standard header print for class call (uses member cprint)
-    def print_header 
+    def print_header
       # Identify method entry
 
       debug_print "#{ self } : #{ __method__ }\n"
@@ -183,7 +183,7 @@ module Watson
     ###########################################################
     # Status printer for member call (uses member cprint)
     # Print status block in standard format
-    def print_status(msg, color) 
+    def print_status(msg, color)
       cprint RESET + BOLD
       cprint WHITE + "[ "
       cprint "#{ msg } ", color
@@ -193,7 +193,7 @@ module Watson
 
     ###########################################################
     # Go through all files and directories and call necessary printing methods
-    # Print all individual entries, call print_structure on each subdir  
+    # Print all individual entries, call print_structure on each subdir
     def print_structure(structure)
 
       # Identify method entry
@@ -234,9 +234,9 @@ module Watson
         cprint "\n"
         print_status "x", RED
         cprint BOLD + UNDERLINE + RED + "#{entry[:relative_path]}" + RESET + "\n"
-      end 
+      end
+
 
-  
       # [review] - Should the tag structure be self contained in the hash
       #      Or is it ok to reference @config to figure out the tags
       @config.tag_list.each do | _tag |
@@ -249,7 +249,7 @@ module Watson
           cprint "\n"
           next
         end
-        
+
         debug_print "#{ _tag } has issues in it, print!\n"
         print_status "#{ _tag }", BLUE
         cprint "\n"
@@ -261,8 +261,8 @@ module Watson
 
 
           # 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 | 
+          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 BOLD + " [" + RESET
@@ -270,10 +270,10 @@ module Watson
               cprint BOLD + "]" + RESET
             end
             debug_print "Did not find in #{ _closed[:comment] }\n"
-          end 
+          end
 
           debug_print "Checking if issue has been resolved\n"
-          @config.bitbucket_issues[:closed].each do  | _closed | 
+          @config.bitbucket_issues[:closed].each do  | _closed |
             if _closed["content"].include?(_issue[:md5])
               debug_print "Found in #{ _closed["content"] }, not posting\n"
               cprint BOLD + " [" + RESET
@@ -288,6 +288,6 @@ module Watson
         cprint "\n"
       end
     end
-  
+
   end
-end 
+end

data/lib/watson/remote.rb

@@ -1,23 +1,23 @@
 module Watson
-  # Remote class that handles all remote HTTP calls to Bitbucket and GitHub 
+  # Remote class that handles all remote HTTP calls to Bitbucket and GitHub
   class Remote
 
     # Debug printing for this class
-    DEBUG = false     
-  
+    DEBUG = false
+
     class << self
-    
+
     # Include for debug_print
     include Watson
 
-    # Required libs   
+    # Required libs
     require 'net/https'
     require 'uri'
     require 'json'
-  
-  
+
+
     # Default options hash for http_call
-    # Will get merged with input argument hash to maintain defaults 
+    # Will get merged with input argument hash to maintain defaults
     HTTP_opts = {
         :url      => nil,     #--> URL of endpoint [String]
         :ssl      => false,     #--> Use SSL in connection (HTTPS) (True/False]
@@ -28,36 +28,36 @@ module Watson
       :data     => nil,     #--> Hash of data to be POST'd in HTTP request [Hash]
       :verbose    => false      #--> Turn on verbose debug for this call [True/False]
     }
-      
+
     ###########################################################
     # Generic HTTP call method
-    # Accepts input hash of options that dictate how the HTTP call is to be made 
+    # Accepts input hash of options that dictate how the HTTP call is to be made
     def http_call( opts )
     # [review] - Don't use DEBUG inside Remote class but pull from calling method's class?
     # [review] - Not sure if this is the best/proper way to do things but it works...
 
       # Identify method entry
       debug_print "#{ self.class } : #{ __method__ }\n"
-      
+
       # Merge default options with those passed in by user to form complete opt list
       opts = HTTP_opts.merge(opts)
 
 
       # Check URL in hash and get URI from it, then set up HTTP connection
       if opts[:url] =~ /^#{URI::regexp}$/
-        _uri = URI(opts[:url]) 
+        _uri = URI(opts[:url])
       else
         debug_print "No URL specified in input opts, exiting HTTP call\n"
         return false
       end
-      
+
       _http = Net::HTTP.new(_uri.host, _uri.port)
-      
+
       # Print out verbose HTTP request if :verbose is set
       # For hardcore debugging when shit really doesn't work
       _http.set_debug_output $stderr if opts[:verbose] == true
-      
-      # If SSL is set in hash, set HTTP connection to use SSL 
+
+      # If SSL is set in hash, set HTTP connection to use SSL
       _http.use_ssl = true if opts[:ssl] == true
 
       # Create request based on HTTP method
@@ -65,10 +65,10 @@ module Watson
       case opts[:method].upcase
       when "GET"
         _req = Net::HTTP::Get.new(_uri.request_uri)
-    
+
       when "POST"
         _req = Net::HTTP::Post.new(_uri.request_uri)
-      
+
       else
         debug_print "No method specified, cannot make HTTP request\n"
         return false
@@ -77,7 +77,7 @@ module Watson
       # Check for basic authentication key in hash
       if opts[:basic_auth].size == 2
         _req.basic_auth(opts[:basic_auth][0], opts[:basic_auth][1])
-      end 
+      end
 
       # Check for Authentication token key in hash to be used in header
       # I think this is pretty universal, but specifically works for GitHub
@@ -86,9 +86,9 @@ module Watson
       end
 
       # [review] - Add :data_format to use set_form_data vs json body?
-      # For now, use Hash or Array, this is to differentiate between 
+      # For now, use Hash or Array, this is to differentiate between
       # putting post data in body vs putting it in the form
-      
+
       # If a POST method, :data is present, and is a Hash, fill request body with data
       if opts[:method].upcase == "POST" && opts[:data] && opts[:data].is_a?(Hash)
         _req.body = opts[:data].to_json
@@ -106,14 +106,14 @@ module Watson
       debug_print "HTTP Response Code: #{ _resp.code }\n"
       debug_print "HTTP Response  Msg: #{ _resp.message }\n"
 
-      # [fix] - Not sure if 401 is the only code that gives nonparseable body? 
+      # [fix] - Not sure if 401 is the only code that gives nonparseable body?
       # Figure out what other response codes are bad news for JSON.parse
       _json = _resp.code == "401" ? Hash.new :  JSON.parse(_resp.body)
       debug_print "JSON: \n #{ _json }\n"
 
       # [review] - Returning hash of json + response the right thing to do?
       # return {:json => _json, :resp => _resp}
-      return _json, _resp 
+      return _json, _resp
     end
   end
   end

data/lib/watson/version.rb

@@ -1,3 +1,3 @@
-module Watson 
-  VERSION = "1.0.5"
+module Watson
+  VERSION = "1.0.6"
 end

data/spec/config_spec.rb

@@ -16,7 +16,7 @@ describe Config do
 
   describe '#create_conf' do
     it 'create config file, return true' do
-      @config.create_conf.should be_true  
+      @config.create_conf.should be_true
       File.exists?(@file).should be_true
     end
   end
@@ -35,7 +35,7 @@ describe Config do
         File.exists?(@file).should be_true
       end
     end
-  end 
+  end
 
   describe '#read_conf' do
     context 'config does not exist' do
@@ -53,24 +53,24 @@ describe Config do
         @config.dir_list.should include('.')
         @config.tag_list.should include('fix', 'review', 'todo')
         @config.ignore_list.should include('.git', '*.swp')
-        
+
       end
     end
   end
 
   describe '#update_conf' do
-    before do 
+    before do
       @config.check_conf
-      @config.parse_depth = 1000 
-      @config.update_conf('parse_depth') 
-    end 
+      @config.parse_depth = 1000
+      @config.update_conf('parse_depth')
+    end
 
     it 'updated config.parse_depth should be 1000' do
       @new_config = Config.new
       @new_config.check_conf.should be_true
       @new_config.read_conf.should be_true
       @new_config.parse_depth.to_i.should eql 1000
-    end   
+    end
   end
 
   # [review] - Should this be #initialize or #new?
@@ -81,7 +81,7 @@ describe Config do
       @config.cl_ignore_set.should be_false
 
       @config.use_less.should be_false
-      
+
       @config.ignore_list.should == []
       @config.dir_list.should == []
       @config.file_list.should == []
@@ -101,7 +101,7 @@ describe Config do
       @config.bitbucket_issues.should == {:open => Hash.new(),
                        :closed => Hash.new() }
 
-    end 
+    end
   end
 
   describe '#run' do
@@ -110,7 +110,7 @@ describe Config do
       @config.ignore_list.should include('.git', '*.swp')
       @config.tag_list.should include('fix', 'review', 'todo')
       @config.dir_list.should include('.')
-    end 
+    end
 
   end
 

data/spec/fs_spec.rb

@@ -29,7 +29,7 @@ describe FS do
         FS.check_file('spec/fs_spec.rb').should be_true
       end
     end
-  end 
+  end
 
   describe '.check_dir' do
     context 'blank input dir' do

data/spec/helper_spec.rb

@@ -1,5 +1,5 @@
 # [review] - Using own funky path loading because traditional way seems wrong?
-# Commented out version is traditional, seen in many apps. If you use that and 
+# Commented out version is traditional, seen in many apps. If you use that and
 # look at load_path you get path/../lib (I'd expect those to be separate?)
 # My funky version adds path/., path/bin, path/assets separately
 # Maybe I don't get how the load path is supposed to look though...

data/spec/parser_spec.rb

@@ -18,16 +18,80 @@ describe Parser do
 
   describe '#get_comment_type' do
     context 'known extension' do
-      it 'return correct extension (# for ruby)' do
-        @parser.get_comment_type('lib/watson.rb').should eql '#'  
+      it 'return correct extension for c++' do
+        @parser.get_comment_type('lib/watson.cpp').should eql ['//', '/*']
+        @parser.get_comment_type('lib/watson.cc').should  eql ['//', '/*']
+        @parser.get_comment_type('lib/watson.hpp').should eql ['//', '/*']
+        @parser.get_comment_type('lib/watson.c').should   eql ['//', '/*']
+        @parser.get_comment_type('lib/watson.h').should   eql ['//', '/*']
       end
 
-      it 'return correct extension (# for coffee)' do
-        @parser.get_comment_type('lib/watson.coffee').should eql '#'  
+      it 'return correct extension for java' do
+        @parser.get_comment_type('lib/watson.java').should  eql ['//', '/*', '/**']
+        @parser.get_comment_type('lib/watson.class').should eql ['//', '/*', '/**']
       end
 
-      it 'return correct extension (// for c/c++)' do
-        @parser.get_comment_type('lib/watson.cpp').should eql '//'
+      it 'return correct extension for csharp' do
+        @parser.get_comment_type('lib/watson.cs').should  eql ['//', '/*']
+      end
+
+      it 'return correct extension for javascript' do
+        @parser.get_comment_type('lib/watson.js').should  eql ['//', '/*']
+      end
+
+      it 'return correct extension for php' do
+        @parser.get_comment_type('lib/watson.php').should  eql ['//', '/*', '#']
+      end
+
+      it 'return correct extension for objectivec' do
+        @parser.get_comment_type('lib/watson.m').should   eql ['//', '/*']
+        @parser.get_comment_type('lib/watson.mm').should  eql ['//', '/*']
+      end
+
+      it 'return correct extension for go' do
+        @parser.get_comment_type('lib/watson.go').should  eql ['//', '/*']
+      end
+
+      it 'return correct extension for scala' do
+        @parser.get_comment_type('lib/watson.scala').should  eql ['//', '/*']
+      end
+
+      it 'return correct extension for erlang' do
+        @parser.get_comment_type('lib/watson.erl').should  eql ['%%', '%']
+      end
+
+      it 'return correct extension haskell' do
+        @parser.get_comment_type('lib/watson.hs').should eql ['--']
+      end
+
+      it 'return correct extension bash' do
+        @parser.get_comment_type('lib/watson.sh').should eql ['#']
+      end
+
+      it 'return correct extension ruby' do
+        @parser.get_comment_type('lib/watson.rb').should eql ['#']
+      end
+
+      it 'return correct extension perl' do
+        @parser.get_comment_type('lib/watson.pl').should eql ['#']
+        @parser.get_comment_type('lib/watson.pm').should eql ['#']
+        @parser.get_comment_type('lib/watson.t').should eql ['#']
+      end
+
+      it 'return correct extension python' do
+        @parser.get_comment_type('lib/watson.py').should eql ['#']
+      end
+
+      it 'return correct extension coffeescript' do
+        @parser.get_comment_type('lib/watson.coffee').should eql ['#']
+      end
+
+      it 'return correct extension zsh' do
+        @parser.get_comment_type('lib/watson.zsh').should eql ['#']
+      end
+
+      it 'return correct extension (;; for clojure)' do
+        @parser.get_comment_type('lib/watson.clj').should eql [';;']
       end
     end
 
@@ -72,7 +136,7 @@ describe Parser do
         FileUtils.mkdir('test_dir')
         FileUtils.cp('assets/examples/main.cpp', 'test_dir/')
       end
-    
+
       it 'generate populated hash structure from file' do
         @structure = @parser.parse_file('test_dir/main.cpp')
 
@@ -85,7 +149,7 @@ describe Parser do
         FileUtils.rm_rf('test_dir')
       end
     end
-    
+
   end
 
   describe '#parse_dir' do
@@ -112,7 +176,7 @@ describe Parser do
         FileUtils.mkdir('test_dir')
         FileUtils.cp('assets/examples/main.cpp', 'test_dir/')
       end
-      
+
       it 'generate hash structure with parsed file' do
         @structure = @parser.parse_dir('test_dir/', 0)
         @structure[:files][0][:relative_path].should == 'test_dir/main.cpp'