fgi 1.0.2 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2c10109eb480ab557f79d477ff770b7b4113d079
-  data.tar.gz: a718badc264ab8b9483e11ec76082db9a04aac99
+  metadata.gz: 01ff812f6d7df394c97c84fe04677f1421726d96
+  data.tar.gz: d8888bd13fd3f3b38ad99d3dc4ca659d438def4d
 SHA512:
-  metadata.gz: 7eab634762636cc11025a56296c9b20e3e8d767935c245db69acefc7313b8ed02646d1660737343d50bc71d75ac128d2cb775127777c6166745281ba78633a44
-  data.tar.gz: ce9f2d259e89d34e3ee9fb822d0b0dfa6516f71cf91b74d3a5f51dbffed28aea0ddf7077125d4cf567f789506586a3a390365b01992fe6ff14f77489b85cd12e
+  metadata.gz: a2a5e66b748bf7f182b2b0c4757e575bcad60f8a04016bbb9d91634e228415831a4bf3e5d40d0fa7982b98172c3210a01c1058e558277c7c83559dd4ac6898a3
+  data.tar.gz: 5a7965629498624bfd1f66a50708c9e9fc1da3ec35319e205baad5f2e976694989fafd01cbaef1ac7c1919494d53a4ca6443ab45314fe2f6cb519c51ad7231b3

data/bin/fgi

@@ -17,20 +17,32 @@ options_parser = OptionParser.new do |fgi|
   fgi.separator '    config              : run the FGI configurator.'
   fgi.separator '    token  [TOKEN]      : define the new user token.'
   fgi.separator '    new    [ISSUE_NAME] : create the issue with the given name.'
+  fgi.separator '    fix                 : fix the current issue.'
   fgi.separator '    ... more comming soon ...'
   fgi.separator ''
   fgi.separator 'Options'
 
+  fgi.on('-h', '--help', 'Display the FGI manual')
+
+  fgi.on('-v', '--version', 'Display the FGI version') do
+    puts "FGI #{Fgi::VERSION}"
+    exit!
+  end
+
   fgi.on('-e', '--estimate [ESTIMATION]', 'How many time do you think you will spend on this issue ? (example: 1d13h37m05s)') do |estimate|
     options[:estimate] = estimate
   end
 
-  fgi.on('-l', '--later', 'Tell FGI that you anly want to create an issue but not to create and switch branch.') do
+  fgi.on('-l', '--later', 'Tell FGI that you only want to create an issue but not to create and switch branch.') do
     options[:later] = true
   end
 
-  fgi.on('-h', '--help', 'Display the FGI manual') do
-    puts options_parser
+  fgi.on('-p', '--prefix [PREFIX]', 'Tell FGI that you want to add a prefix to the branch name.') do |prefix|
+    options[:prefix] = prefix
+  end
+
+  fgi.on('-m', '--fix-message [MESSAGE]', %q(Add a custom message with the basic 'Fix #ID')) do |message|
+    options[:fix_message] = message
   end
 end
 options_parser.parse!
@@ -50,15 +62,17 @@ when 'config'
   Fgi::Configuration.new_config
 when 'new'
   Fgi.configured?
-  if argv[1].start_with?('-')
+  if !argv[1].nil? && argv[1].start_with?('-')
     puts %q(You can't begin your issue's title with '-')
     exit!
   end
   title = get_full_issue_title(argv)
-  Fgi::GitService.create_issue(title: title, options: options)
+  Fgi::GitService.new_issue(title: title, options: options)
 when 'token'
   Fgi.configured?
   Fgi::Tokens.add_token(argv[1])
+when 'fix'
+  Fgi::GitService.fix_issue(options)
 else
   puts options_parser
 end

data/lib/fgi.rb

@@ -6,6 +6,7 @@ module Fgi
   require 'json'
   require 'yaml'
   require 'uri'
+  require 'cgi'
 
   require_relative 'fgi/git_services/gitlab'
   require_relative 'fgi/http_requests'
@@ -13,19 +14,28 @@ module Fgi
   require_relative 'fgi/configuration'
   require_relative 'fgi/git_service'
 
-  # Define const variables if fgi config files exists
+  VERSION = '1.1.1'.freeze
+
+  # Add FGI user's current issues to the gitignore
+  if `cat .gitignore | grep '.current_issues.fgi.yml'`.empty?
+    File.open('.gitignore', 'a') { |f| f.write("\n.current_issues.fgi.yml\n") }
+  end
+
+  ISSUES = YAML.load_file('.current_issues.fgi.yml') if File.exist?('.current_issues.fgi.yml')
+  # Define const variables if fgi config files exists
   # otherwise ask for configuration
-  if File.exists?('.config.fgi.yml')
+  if File.exist?('.config.fgi.yml')
     CONFIG = YAML.load_file('.config.fgi.yml')
     git_service = CONFIG[:git_service_class].new
-    if File.exists?("#{Dir.home}/.tokens.fgi.yml")
-      TOKEN = YAML.load_file("#{Dir.home}/.tokens.fgi.yml")[git_service.to_sym]
+    if File.exist?("#{Dir.home}/.tokens.fgi.yml")
+      TOKEN = YAML.load_file("#{Dir.home}/.tokens.fgi.yml")[git_service.to_sym][CONFIG[:url]]
     end
   end
 
   def self.configured?
-    return if File.exists?('.config.fgi.yml')
+    return if File.exist?('.config.fgi.yml')
     puts "\nThere is no FGI configuration file on this project. Please run 'fgi config'.\n\n"
     exit!
   end
+
 end

data/lib/fgi/configuration.rb

@@ -2,6 +2,7 @@
 module Fgi
   class Configuration
     class << self
+
       include HttpRequests
 
       # Launch the process to create the fresh project fgi config file
@@ -21,7 +22,6 @@ module Fgi
         #        INITIALIZERS        #
         # -------------------------- #
 
-
         # The hash that will contain the project's fgi configuration to save as yml
         # It will contain :
         #    :url
@@ -38,18 +38,17 @@ module Fgi
         # TODO - HARD REFECTO NEEDED HERE...
         git_service                = config[:git_service_class].new(config: config)
         config[:git_service]       = git_service.to_sym
-        user_token                 = save_user_token(git_service)
+        user_token                 = save_user_token(config: config, git_service: git_service)
         project_name_and_id        = define_project_name_and_id(git_service, user_token)
         config                     = config.merge(project_name_and_id)
         git_service                = config[:git_service_class].new(config: config)
         config[:default_branch]    = define_default_branch(git_service, user_token)
 
-
         # -------------------------- #
         #          CREATORS          #
         # -------------------------- #
 
-        Fgi::Tokens.create_user_tokens_file(config[:git_service], user_token)
+        Fgi::Tokens.create_user_tokens_file(config: config, git_service: git_service, token: user_token)
         create_fgi_config_file(config)
       end
 
@@ -57,21 +56,19 @@ module Fgi
 
       # Check if we are in a git repository. Exit FGI if not.
       def git_directory?
-        unless Dir.exists?('.git')
-          puts 'You are not in a git project repository.'
-          exit!
-        end
+        return if Dir.exist?('.git')
+        puts 'You are not in a git project repository.'
+        exit!
       end
 
       # Check if FGI has already been configured. Exit FGI if not.
       def already_configured?
-        if File.exists?('.config.fgi.yml')
-          puts 'There is already a FGI config on this project.'
-          exit!
-        end
+        return unless File.exist?('.config.fgi.yml')
+        puts 'There is already a FGI config on this project.'
+        exit!
       end
 
-      # Ask the user to shoose the project's Git service
+      # Ask the user to shoose the project's Git service
       # @return [Class] the project's Git service class
       def define_git_service
         puts "\nPlease insert the number of the used Git service :"
@@ -81,9 +78,9 @@ module Fgi
         git_services = Fgi::GitService.services
         # Display theses services to let the user choose the project's one
         git_services.each_with_index do |service, index|
-          puts "#{index+1} : #{service.capitalize}"
+          puts "#{index + 1} : #{service.capitalize}"
         end
-        puts "... More soon ..."
+        puts '... More soon ...'
 
         begin
           input = STDIN.gets.chomp
@@ -91,15 +88,15 @@ module Fgi
           # Convert the string input to an integer
           input = input.to_i
           # If the input isn't out of range...
-          if (1..git_services.count).include?(input)
+          if (1..git_services.count).cover?(input)
             # Set a variable with the Git service name for displays
-            @git_service = git_services[input-1].capitalize
+            @git_service = git_services[input - 1].capitalize
             Fgi::GitServices.const_get(@git_service)
           else
             puts "\nSorry, the option is out of range. Try again :"
             define_git_service
           end
-        rescue Interrupt => int
+        rescue Interrupt
           exit!
         end
       end
@@ -116,18 +113,18 @@ module Fgi
           exit! if input == 'quit'
           # force scheme if not specified
           # TODO - Find a way to clear this... Find the correct scheme.
-          input = if input.start_with?('gitlab.com')
-                    "https://#{input}"
-                  elsif !input.start_with?('http://', 'https://')
-                    "http://#{input}"
-                  end
+          if input.start_with?('gitlab.com')
+            input = "https://#{input}"
+          elsif !input.start_with?('http://', 'https://')
+            input = "http://#{input}"
+          end
           # Call the entered url to know if it exist or not.
           # If not, would raise an exception
           get(url: input)
           input
-        rescue Interrupt => int
+        rescue Interrupt
           exit!
-        rescue Exception => e
+        rescue Exception
           puts "\nOops, seems to be a bad url. Try again or quit (quit)"
           save_git_url
         end
@@ -136,10 +133,9 @@ module Fgi
       # Ask for the user for his Git service token
       # @param git_service [Class] the current project's git service class
       # @return [String] the user Git service token
-      def save_user_token(git_service)
-        token = Fgi::Tokens.get_token(git_service)
+      def save_user_token(config:, git_service:)
+        token = Fgi::Tokens.get_token(config: config, git_service: git_service)
         return token unless token.nil?
-        save_user_token(git_service)
       end
 
       # Ask the user to search for the project and to select the correct one.
@@ -161,7 +157,7 @@ module Fgi
           if response[:status] == '200' && !response[:body].empty?
             puts "\nFound #{response[:body].count} match(es):"
             response[:body].each_with_index do |project, index|
-              puts "#{index+1} - #{project['name_with_namespace']}"
+              puts "#{index + 1} - #{project['name_with_namespace']}"
             end
 
             puts "\nPlease insert the number of the current project :"
@@ -174,10 +170,10 @@ module Fgi
 
           else
             puts "\nOops, we couldn't find a project called #{input}. Try again or quit (quit) :"
-            puts '-------------------------------------------------------------------'+('-'*input.length) # Don't be upset, i'm a perfectionist <3
+            puts '-------------------------------------------------------------------' + ('-' * input.length) # Don't be upset, i'm a perfectionist <3
             define_project_name_and_id(git_service, user_token)
           end
-        rescue Interrupt => int
+        rescue Interrupt
           exit!
         end
       end
@@ -186,23 +182,21 @@ module Fgi
         puts "\nPlease define the default project branch :"
         puts '------------------------------------------'
 
-        url = "#{git_service.routes[:branches]}"
+        url = git_service.routes[:branches]
         response = get(url: url, headers: { git_service.token_header => user_token })
+        return unless response[:status] == '200' && !response[:body].empty?
 
-        if response[:status] == '200' && !response[:body].empty?
-          begin
-            response[:body].each_with_index do |branch, index|
-              puts "#{index+1} - #{branch['name']}"
-            end
-
-            puts "\nPlease insert the number of the default project branch :"
-            puts '--------------------------------------------------------'
-            input = validate_choice(response[:body])
-            response[:body][input - 1]['name']
-
-          rescue Interrupt => int
-            exit!
+        begin
+          response[:body].each_with_index do |branch, index|
+            puts "#{index + 1} - #{branch['name']}"
           end
+
+          puts "\nPlease insert the number of the default project branch :"
+          puts '--------------------------------------------------------'
+          input = validate_choice(response[:body])
+          response[:body][input - 1]['name']
+        rescue Interrupt
+          exit!
         end
       end
 
@@ -210,7 +204,7 @@ module Fgi
         input = STDIN.gets.chomp
         exit! if input == 'quit'
         input = input.to_i
-        if (1..response_body.count).include?(input)
+        if (1..response_body.count).cover?(input)
           input
         else
           puts "\nSorry, the option is out of range. Try again :"

data/lib/fgi/git_service.rb

@@ -2,120 +2,227 @@
 module Fgi
   class GitService
     class << self
+
       include HttpRequests
 
+      # @return [Array<String>] an array containing all the git services available.
       def services
         services = []
         Dir.entries("#{File.dirname(__FILE__)}/git_services").each do |service|
-          services << service.gsub(/.rb/, '').to_sym unless %w(. ..).include?(service)
+          services << service.gsub(/.rb/, '').to_sym unless %w[. ..].include?(service)
         end
         services
       end
 
-      def create_issue(title: title, options: {})
+      # All the process initiated by the issue creation
+      #   => Create issue
+      #   => Create a new branch from the default one
+      #   => Set the issue estimation time
+      # @param title [String] the issue title
+      # @param options [Hash] the options given by the user in the command line
+      def new_issue(title:, options: {})
         git_service = CONFIG[:git_service_class].new
         title = get_issue_title if title.nil?
-        description = get_issue_description
-
-        headers = { git_service.token_header => TOKEN, 'Content-Type' => 'application/json' }
-        url_with_querystring = "#{git_service.routes[:issues]}?title=#{URI.encode(title)}&description=#{URI.encode(description)}"
-
-        response = post(url: url_with_querystring, headers: headers)
-        response_body = JSON.parse(response[:body])
-
-        post_issue_display(response_body)
+        response = create_issue(title: title, git_service: git_service)
 
         if CONFIG[:default_branch].nil?
           puts "\n/!\\ FGI IS NOT UP-TO-DATE /!\\"
           puts 'We are not able to create and switch you to the new branch.'
           puts 'Delete .config.fgi.yml and reconfigure fgi by running `fgi config`'
-        else
-          create_new_branch(title) unless response_body['iid'].nil? || options[:later]
+        elsif !response['iid'].nil?
+          branch_name = snakify(title)
+          branch_name = "#{options[:prefix]}/#{branch_name}" unless options[:prefix].nil?
+          save_issue(branch: branch_name, id: response['iid'], title: response['title'].tr("'", ' '))
+          create_branch(branch_name) unless options[:later]
+          set_issue_estimation(
+            issue_id:    response['iid'],
+            estimation:  options[:estimate],
+            git_service: git_service
+          )
         end
+      end
 
-        unless options[:estimate].nil?
-          # Since GitLab version isn't up to date, we should be able to add estimations in issues comments (/estimate)
-          url_with_querystring = "#{git_service.routes[:issues]}/#{response_body['iid']}/time_estimate?duration=#{options[:estimate]}"
-          response = post(url: url_with_querystring, headers: headers)
-          # GitLab sucks sometimes... This API is an example
-          begin
-            response_body = JSON.parse(response[:body])
-          rescue Exception => e
-            response_body = response[:body]
+      # All the process initiated by the issue fix
+      #   => Commiting with a 'Fix #<id>' message
+      #   => Pushing the current branch to the remote repo
+      #   => Return to the default project branch
+      # @param options [Hash] the options given by the user in the command line
+      def fix_issue(options)
+        current_branch = `git branch | grep '*'`.gsub('* ', '').chomp
+        if ISSUES[current_branch].nil?
+          puts "We could not find any issues to fix on your current branch (#{current_branch})."
+          exit!
+        end
+        git_remote = ask_for_remote
+        `git add .`
+        puts "Are you sure to want to close the issue #{ISSUES[current_branch][:title]} ?"
+        begin
+          input = STDIN.gets.chomp
+          if %w[y yes].include?(input)
+            commit_message =  "Fix ##{ISSUES[current_branch][:id]}"
+            commit_message += " - #{options[:fix_message]}" unless options[:fix_message].nil?
+            `git commit -a --allow-empty -m '#{commit_message}'`
+            `git push #{git_remote} HEAD`
+            `git checkout #{CONFIG[:default_branch]}` # Be sure to be on the default branch.
+            remove_issue(current_branch)
+            puts "Congrat's ! You're now back to work on the default branch (#{CONFIG[:default_branch]})"
           end
-
-          post_estimation_display(response_body, options[:estimate])
+        rescue Interrupt
+          puts %q"Why did you killed me ? :'("
+          exit!
         end
       end
 
-      def create_new_branch(issue_title)
-        branch_name = snakecase(issue_title)
-        unless %x(git status -s).empty?
-          begin
-            puts "\nThere are unsaved changes on your current branch."
-            puts "Do you want to see them ? (y/n)"
-            puts '-------------------------------'
-            input = STDIN.gets.chomp
-            system('git diff') if %w[y yes].include?(input)
-
-            puts "\nDo you want to COMMIT theses changes ? (y/n)"
-            puts '--------------------------------------------'
-            input = STDIN.gets.chomp
-            if %w[y yes].include?(input)
-              commit_changes
-            else
-              stash_changes
-            end
-
-          rescue Interrupt => int
-            puts %q"Why did you killed me ? :'("
-            exit!
+      private
+
+      def ask_for_remote
+        remotes = `git remote`.split("\n")
+        return remotes.first if remotes.count == 1
+
+        puts "\nHere are your remotes :"
+        remotes.each_with_index do |remote, index|
+          puts "#{index + 1} - #{remote}"
+        end
+
+        begin
+          puts "\nPlease insert the number of the remote to use :"
+          puts '-----------------------------------------------'
+          input = STDIN.gets.chomp
+          exit! if input == 'quit'
+          input = input.to_i
+          if (1..remotes.count).cover?(input)
+            remotes[input-1]
+          else
+            puts "\nSorry, the option is out of range. Try again :"
+            ask_for_remote
           end
+        rescue Interrupt
+          puts %q"Why did you killed me ? :'("
+          exit!
         end
-        %x(git checkout #{CONFIG[:default_branch]}) # Be sure to be on the default branch.
-        from = %x(git branch | grep '*').gsub('* ', '').chomp
-        %x(git pull origin HEAD) # Be sure to get the remote changes locally.
-        %x(git checkout -b #{branch_name}) # Create the new branch.
-        to = %x(git branch | grep '*').gsub('* ', '').chomp
-        puts "\nYou are now working on branch #{to} created from #{from} !"
       end
 
-      private
+      # Save the current user's FGI created issue in the gitignored file 'current_issue.fgi.yml'
+      # @param id [Integer] the current issue id
+      # @param title [String] the current issue name
+      def save_issue(branch:, id:, title:)
+        if File.exist?('.current_issues.fgi.yml')
+          issues = YAML.load_file('.current_issues.fgi.yml')
+          issues[branch] = { id: id, title: title }
+        else
+          issues = {
+            branch => {
+              id:    id,
+              title: title
+            }
+          }
+        end
+        # Shouldn't we define some access restrictions on this file ?
+        File.open('.current_issues.fgi.yml', 'w') { |f| f.write(issues.to_yaml) }
+      end
+
+      def remove_issue(branch)
+        issues = YAML.load_file('.current_issues.fgi.yml')
+        issues.delete(branch) unless ISSUES[branch].nil?
+        File.open('.current_issues.fgi.yml', 'w') { |f| f.write(issues.to_yaml) }
+      end
+
+      # TODO, Make sure it works for all git services
+      # The method to set the estimation time to resolve the issue
+      # @param issue_id [Integer] the issue id to set its estimation time
+      # @param estimation [String] the estimation time given by the user
+      # @param git_service [Class] the git service class to use for this project
+      def set_issue_estimation(issue_id:, estimation:, git_service:)
+        return if estimation.nil?
+        # Since GitLab version isn't up to date, we should be able
+        #   to add estimations in issues comments (/estimate)
+        url_with_querystring = "#{git_service.routes[:issues]}/#{issue_id}/time_estimate?duration=#{estimation}"
+        response = post(url: url_with_querystring, headers: headers)
+        # GitLab sucks sometimes... This API is an example
+        begin
+          response_body = JSON.parse(response[:body])
+        rescue Exception
+          response_body = response[:body]
+        end
+        post_estimation_display(response_body['human_time_estimate'], estimation)
+      end
+
+      # TODO, Make sure it works for all git services
+      # The method used to create issues
+      # @param title [String] the issue title
+      # @param git_service [Class] the git service class to use for this project
+      # @return [Boolean] true if the issue has been created, false otherwise
+      def create_issue(title:, git_service:)
+        description = get_issue_description
+
+        headers = { git_service.token_header => TOKEN, 'Content-Type' => 'application/json' }
+        url_with_querystring = "#{git_service.routes[:issues]}?title=#{CGI.escape(title)}&description=#{CGI.escape(description)}"
+
+        response = post(url: url_with_querystring, headers: headers)
+        response_body = JSON.parse(response[:body])
+
+        post_issue_display(response_body['iid'])
+        response_body
+      end
 
+      # The method used to create branches
+      # @param name [String] the branch name
+      def create_branch(name)
+        check_status
+        git_remote = ask_for_remote
+        `git checkout #{CONFIG[:default_branch]}` # Be sure to be on the default branch.
+        from = `git branch | grep '*'`.gsub('* ', '').chomp
+        `git pull #{git_remote} HEAD` # Be sure to get the remote changes locally.
+        `git checkout -b #{name}` # Create the new branch.
+        to = `git branch | grep '*'`.gsub('* ', '').chomp
+        puts "\nYou are now working on branch #{to} created from #{from} !"
+      end
+
+      # The method used to get the issue description
+      # @return [String] the issue description
       def get_issue_description
         puts "\nWrite your issue description right bellow (save and quit with CTRL+D) :"
         puts "-----------------------------------------------------------------------\n\n"
         begin
           STDIN.read
-        rescue Interrupt => int
+        rescue Interrupt
           puts %q"Why did you killed me ? :'("
           exit!
         end
       end
 
+      # The method used to get the issue title if not given the first time
+      # @return [String] the issue title
       def get_issue_title
-        puts "\nWhat if your issue title :"
+        puts "\nWhat is your issue title :"
         puts "--------------------------\n\n"
         begin
           STDIN.gets.chomp
-        rescue Interrupt => int
+        rescue Interrupt
           puts %q"Why did you killed me ? :'("
           exit!
         end
       end
 
-      def post_issue_display(response)
-        unless response['iid'].nil?
+      # The display method to let the user know
+      #   if the issue has correctly been created
+      # @param issue_id [Integer] the id of the created issue
+      def post_issue_display(issue_id)
+        if !issue_id.nil?
           puts 'Your issue has been successfully created.'
           puts 'To view it, please follow the link bellow :'
-          puts "\n#{CONFIG[:url]}/#{CONFIG[:project_slug]}/issues/#{response['iid']}"
+          puts "\n#{CONFIG[:url]}/#{CONFIG[:project_slug]}/issues/#{issue_id}"
         else
           puts %q(Your issue couldn't be created. Check your FGI configuration.)
         end
       end
 
-      def post_estimation_display(response, estimation)
-        if response['human_time_estimate'].nil?
+      # The display method to let the user know if the
+      #   estimation time has correctly been set on the issue
+      # @param response_estimation [String] the estimation time response from the git service
+      # @param estimation [String] the estimation time given by the user
+      def post_estimation_display(response_estimation, estimation)
+        if response_estimation.nil?
           puts "\nWe weren't able to save your estimation."
           puts "You'll have to do it manually on #{CONFIG[:git_service].capitalize}."
         else
@@ -123,28 +230,59 @@ module Fgi
         end
       end
 
+      # The method used to commit the user's local changes
       def commit_changes
         puts 'Enter your commit message :'
         commit_message = STDIN.gets.chomp
-        %x(git add .)
-        %x(git commit -am '#{commit_message}')
+        `git add .`
+        `git commit -am '#{commit_message}'`
         puts 'Your changes have been commited !'
       end
 
+      # The method used to stash the user's local changes
       def stash_changes
-        %x(git add .)
-        %x(git stash)
+        `git add .`
+        `git stash`
         puts "\nYour changes have been stashed."
-        puts "We will let you manually `git stash pop` to get your work back if needed.\n"
+        puts "We will let you manually git stash pop to get your work back if needed.\n"
+      end
+
+      # The method used to check if there are local changes and to
+      #   ask the user if he want to commit or stash theses changes
+      def check_status
+        return if `git status -s`.empty?
+        begin
+          puts "\nThere are unsaved changes on your current branch."
+          puts 'Do you want to see them ? (y/n)'
+          puts '-------------------------------'
+          input = STDIN.gets.chomp
+          system('git diff') if %w[y yes].include?(input)
+
+          puts "\nDo you want to COMMIT theses changes ? (y/n)"
+          puts '--------------------------------------------'
+          input = STDIN.gets.chomp
+          if %w[y yes].include?(input)
+            commit_changes
+          else
+            stash_changes
+          end
+        rescue Interrupt
+          puts %q"Why did you killed me ? :'("
+          exit!
+        end
       end
 
-      def snakecase(string)
-        string.gsub(/::/, '/').
-               gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-               gsub(/([a-z\d])([A-Z])/,'\1_\2').
-               tr('-', '_').
-               tr(' ', '_').
-               downcase
+      # The method used to snakify strings
+      # @param string [String] the string to snakify
+      # @return [String] the snakified string
+      def snakify(string)
+        string.gsub(/::/, '/')
+              .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+              .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+              .tr('-', '_')
+              .tr(' ', '_')
+              .tr("'", '_')
+              .downcase
       end
 
     end

data/lib/fgi/git_services/gitlab.rb

@@ -3,27 +3,18 @@ module Fgi
   module GitServices
     class Gitlab
 
+      attr_reader :version, :token_header, :routes
+
       def initialize(config: CONFIG)
-        @version = 'v4'
+        @version      = 'v4'
+        @main_url     = "#{config[:url]}/api/#{@version}"
         @token_header = 'PRIVATE-TOKEN'
         @routes = {
-                     projects: "#{config[:url]}/api/#{@version}/projects",
-                     search_projects: "#{config[:url]}/api/#{@version}/projects?search=",
-                     issues: "#{config[:url]}/api/#{@version}/projects/#{config[:project_id]}/issues",
-                     branches: "#{config[:url]}/api/#{@version}/projects/#{config[:project_id]}/repository/branches"
-                   }
-      end
-
-      def version
-        @version
-      end
-
-      def token_header
-        @token_header
-      end
-
-      def routes
-        @routes
+          projects:        "#{@main_url}/projects",
+          search_projects: "#{@main_url}/projects?search=",
+          issues:          "#{@main_url}/projects/#{config[:project_id]}/issues",
+          branches:        "#{@main_url}/projects/#{config[:project_id]}/repository/branches"
+        }
       end
 
       def to_sym

data/lib/fgi/http_requests.rb

@@ -2,55 +2,56 @@
 module Fgi
   module HttpRequests
 
-      # Generic method to GET requests
-      # @param url [String] the given Git service API url for GET request
-      # @param headers [Hash] the headers to set for the request
-      # @return [String] the received response from the Git service API
-      def get(url:, headers: nil)
-        http_request(verb: :get, url: url, headers: headers)
+    # Generic method to GET requests
+    # @param url [String] the given Git service API url for GET request
+    # @param headers [Hash] the headers to set for the request
+    # @return [String] the received response from the Git service API
+    def get(url:, headers: nil)
+      http_request(verb: :get, url: url, headers: headers)
+    end
+
+    # Generic method to POST requests
+    # @param url [String] the given Git service API url for POST request
+    # @param headers [Hash] the headers to set for the request
+    # @param body [Hash] the body to set for the request
+    # @return [String] the received response from the Git service API
+    def post(url:, headers: nil, body: nil)
+      http_request(verb: :post, url: url, headers: headers, body: body)
+    end
+
+    private
+
+    # Generic method for HTTP requests
+    # @param url [String] the given Git service API url for a HTTP request
+    # @param headers [Hash] the headers to set for the request
+    # @param body [Hash] the body to set for the request
+    # @return [String] the received response from the Git service API
+    def http_request(verb:, url:, headers: nil, body: nil)
+      is_https = url.start_with?('https')
+      uri = URI.parse(url)
+
+      req = case verb
+            when :get
+              Net::HTTP::Get.new(url)
+            when :post
+              Net::HTTP::Post.new(url)
+            end
+
+      # Set headers if given
+      headers.each { |k, v| req[k] = v } unless headers.nil?
+      # Set body if given
+      req.body = body.to_json unless body.nil?
+
+      res = Net::HTTP.start(uri.host, uri.port, use_ssl: is_https) do |http|
+        http.request(req)
       end
 
-      # Generic method to POST requests
-      # @param url [String] the given Git service API url for POST request
-      # @param headers [Hash] the headers to set for the request
-      # @param body [Hash] the body to set for the request
-      # @return [String] the received response from the Git service API
-      def post(url:, headers: nil, body: nil)
-        http_request(verb: :post, url: url, headers: headers)
-      end
-
-      private
-
-      # Generic method for HTTP requests
-      # @param url [String] the given Git service API url for a HTTP request
-      # @param headers [Hash] the headers to set for the request
-      # @param body [Hash] the body to set for the request
-      # @return [String] the received response from the Git service API
-      def http_request(verb:, url:, headers: nil, body: nil)
-        is_https = url.start_with?('https')
-        uri = URI.parse(url)
-        req = case verb
-              when :get
-                Net::HTTP::Get.new(url)
-              when :post
-                Net::HTTP::Post.new(url)
-              end
-
-        # Set headers if given
-        headers.each { |k, v| req[k] = v } unless headers.nil?
-        # Set body if given
-        req.body = body.to_json unless body.nil?
-
-        res = Net::HTTP.start(uri.host, uri.port, use_ssl: is_https) do |http|
-          http.request(req)
-        end
-
-        if res.code == '200'
-          { status: '200', body: JSON.parse(res.body) }
-        else
-          { status: res.code, body: res.body }
-        end
+      if res.code == '200'
+        { status: '200', body: JSON.parse(res.body) }
+      else
+        { status: res.code, body: res.body }
       end
+    end
 
   end
 end

data/lib/fgi/tokens.rb

@@ -2,16 +2,21 @@
 module Fgi
   class Tokens
     class << self
+
       include HttpRequests
 
       # @param git_service_name [String] the git service to associate a token to
       # @param token [String] the token to associate to the git service
-      def create_user_tokens_file(git_service, token)
-        if File.exists?("#{Dir.home}/.tokens.fgi.yml")
+      def create_user_tokens_file(config:, git_service:, token:)
+        if File.exist?("#{Dir.home}/.tokens.fgi.yml")
           tokens = YAML.load_file("#{Dir.home}/.tokens.fgi.yml")
-          tokens[git_service] = token
+          tokens[git_service.to_sym] = { config[:url] => token }
         else
-          tokens = { git_service => token }
+          tokens = {
+            git_service => {
+              config[:url] => token
+            }
+          }
         end
         # Shouldn't we define some access restrictions on this file ?
         File.open("#{Dir.home}/.tokens.fgi.yml", 'w') { |f| f.write(tokens.to_yaml) }
@@ -34,12 +39,12 @@ module Fgi
       # @param git_service [Class] the current project's git service class
       # @return [String] the current token associated to the project's git service
       # @return [NilClass] if there is no token associated to the project's git service
-      def get_token(git_service)
-        if File.exists?("#{Dir.home}/.tokens.fgi.yml")
+      def get_token(config:, git_service:)
+        if File.exist?("#{Dir.home}/.tokens.fgi.yml")
           tokens = YAML.load_file("#{Dir.home}/.tokens.fgi.yml")
-          tokens[git_service.to_sym]
+          tokens[git_service.to_sym][config[:url]]
         else
-          puts "\nPlease enter your #{git_service.to_s} token :"
+          puts "\nPlease enter your #{git_service} token :"
           puts '(use `fgi --help` to check how to get your token)'
           puts '-------------------------------------------------'
           begin
@@ -47,7 +52,7 @@ module Fgi
             exit! if token == 'quit'
             return token if token_valid?(git_service, token)
             nil
-          rescue Interrupt => int
+          rescue Interrupt
             exit!
           end
         end
@@ -57,7 +62,10 @@ module Fgi
       # @param token [String] the token to check the validity
       # @return [Boolean] true if the token is valid, false otherwise
       def token_valid?(git_service, token)
-        response = get(url: git_service.routes[:projects], headers: { git_service.token_header => token })
+        response = get(
+          url:     git_service.routes[:projects],
+          headers: { git_service.token_header => token }
+        )
         response[:status] == '200'
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fgi
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.1
 platform: ruby
 authors:
 - Julien Philibin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-14 00:00:00.000000000 Z
+date: 2017-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler