ghedsh 1.1.40 → 2.3.8

data/lib/actions/orgs.rb

@@ -1,955 +1,749 @@
-require 'readline'
-require 'octokit'
 require 'json'
 require 'csv'
+require 'fileutils'
 require 'require_all'
-require_rel '.'
-require 'readline'
-
-GITHUB_LIST=['githubid','github','idgithub','github_id','id_github','githubuser','github_user']
-MAIL_LIST=['email','mail','e-mail']
-
-class Organizations
-
-  attr_accessor :orgslist
-  attr_accessor :assiglist
-  attr_accessor :peoplelist
-
-
-  def load_assig()
-    @assiglist=Hash.new()
-    @assiglist=Sys.new.load_assig_db("#{ENV['HOME']}/.ghedsh")
-    return @assiglist
+require 'rainbow'
+require 'tty-spinner'
+require 'tty-prompt'
+require_relative '../helpers'
+
+# Class containing actions available inside an organization
+#
+# @see http://octokit.github.io/octokit.rb/Octokit/Client/Organizations.html
+class Organization
+  # CLI prompt, info about the current (CLI) scope
+  # @param config [Hash] user configuration tracking current org, repo, etc.
+  def self.shell_prompt(config)
+    if config['Repo'].nil?
+      Rainbow("#{config['User']}> ").aqua << Rainbow("#{config['Org']}> ").magenta
+    else
+      Rainbow("#{config['User']}> ").aqua << Rainbow("#{config['Org']}> ").magenta << Rainbow("#{config['Repo']}> ").color(236, 151, 21)
+    end
   end
 
-  def load_people()
-    @peoplelist=Hash.new()
-    @peoplelist=Sys.new.load_people_db("#{ENV['HOME']}/.ghedsh")
-    return @peoplelist
+  # Builds final cd syntax. Transforms user's CLI input to valid Ruby expression doing some parsing.
+  # @param type [String] scope of cd command
+  # @param name [String, Regexp] name of repo, org, team etc. inside current organization
+  # @return syntax_map [String] Valid Ruby expression to perform eval.
+  def build_cd_syntax(type, name)
+    syntax_map = { 'repo' => "Organization.new.cd('repo', #{name}, client, env)",
+                   'team' => "Organization.new.cd('team', #{name}, client, env)" }
+    unless syntax_map.key?(type)
+      raise Rainbow("cd #{type} currently not supported.").color(ERROR_CODE)
+    end
+    syntax_map[type]
   end
 
-  def show_assignments(client, config) #client,orgs
-    list=self.load_assig()
-
-    assig=list["orgs"].detect{|aux| aux["name"]==config["Org"]}
-    if assig!=nil
-      if assig["assigs"].empty?
-        puts "No assignments are available yet"
-      else
-        assig["assigs"].each do |i|
-          puts "\n"
-          puts i["name_assig"]
-          i.each{|key, value| if key.include?("repo") then  puts "Repository #{key.delete("repo")}: #{value}" end}
-          if i["groups"]!=[] and i["groups"]!=nil
-            puts "\tGroups: "
-            i["groups"].each do |y|
-              puts "\t\t#{y}"
-            end
-          end
-          if i["people"]!=[] and i["people"]!=nil
-            puts "\tStudents: "
-            i["people"].each do |y|
-              puts "\t\t#{y}"
-            end
-            puts "\n"
-          end
-          print "\n"
-        end
-      end
+  # Open info on default browser.
+  #
+  # If 'params' is String or Regexp user selects referred organization members
+  #
+  # @param config [Hash] user configuration tracking current org, repo, etc.
+  # @params [String, Regexp]
+  # @param client [Object] Octokit client object
+  # @example open user profile URL with String provided
+  #   User > Org > open 'some_user'
+  # @example open user URL with Regexp provided
+  #   User > Org > open /pattern/
+  def open_info(config, params, client)
+    unless params.nil?
+      # looking for org member by regexp
+      pattern = build_regexp_from_string(params)
+      member_url = select_member(config, pattern, client)
+      open_url(member_url.to_s) unless member_url.nil?
+      return
+    end
+
+    if config['Repo'].nil?
+      open_url(config['org_url'].to_s)
     else
-      puts "No assignments are available yet"
-      list["orgs"].push({"name"=>config["Org"],"assigs"=>[]})
-      Sys.new.save_assigs("#{ENV['HOME']}/.ghedsh",list)
+      open_url(config['repo_url'].to_s)
     end
+  rescue StandardError => exception
+    puts Rainbow(exception.message.to_s).color(ERROR_CODE)
+    puts
   end
 
-  def assignment_repository(client,config,name)
-    ex=false
-    until ex==true
-      puts "\n"
-      puts "Assignment: #{name}"
-      puts "1) Add a repository already created "
-      puts "2) Create a new empty repository"
-      puts "3) Don't assign a repository yet"
-      print "option => "
-      op=gets.chomp
-      puts "\n"
-      if op=="1" or op=="2" or op=="3"
-        ex=true
-      end
+  # Display organization repos
+  #
+  # @param client [Object] Octokit client object
+  # @param config [Hash] user configuration tracking current org, repo, etc.
+  # @param params [Regexp] regexp to check repo name
+  def show_repos(client, config, params)
+    spinner = custom_spinner("Fetching #{config['Org']} repositories :spinner ...")
+    spinner.auto_spin
+    org_repos = []
+    client.organization_repositories(config['Org'].to_s).each do |repo|
+      org_repos << repo[:name]
+    end
+    org_repos.sort_by!(&:downcase)
+    spinner.stop(Rainbow('done!').color(4, 255, 0))
+    if params.nil?
+      item_counter = 0
+      org_repos.each do |repo_name|
+        puts repo_name
+        item_counter += 1
+      end
+      puts "\n#{item_counter} #{config['Org']} repositories listed."
+    else
+      pattern = build_regexp_from_string(params)
+      occurrences = show_matching_items(org_repos, pattern)
+      puts Rainbow("No repository inside #{config['Org']} matched  \/#{pattern.source}\/").color(INFO_CODE) if occurrences.zero?
+      puts "\n#{occurrences} #{config['Org']} repositories listed."
     end
-    case
-    when op=="1" || op=="2"
+  end
 
-      if op=="1"
-        ex2=false
-        until ex2==true
-          exname=false
-          until exname==true
-            puts "Name of the repository -> Owner/Repository or Organization/Repository :"
-            reponame=gets.chomp
-            if reponame.split("/").size!=2 and reponame!=""
-              puts "Please introduce a valid format."
-            else
-              exname=true
-            end
-            if reponame==""
-              exname=true
-              ex2=true
-            end
-          end
-          if reponame!=""
-            if client.repository?("#{reponame}")==false
-              puts "\e[31m The repository #{reponame} doesn't exist\n \e[0m"
-              puts "\nName of the repository (To skip and add the repository later, only press enter): "
-              if reponame==""
-                ex2=true
-              end
-            else
-              ex2=true
-            end
-          end
-        end
-      end
-      if op=="2"
-        ex2=false
-        until ex2==true
-          puts "Name of the repository (To skip and add the repository later, press enter): "
-          reponame=gets.chomp
-          if reponame==""
-             ex2=true
-          else
-            # ex2=Repositories.new().create_repository(client,config,reponame,false,ORGS)
-            if client.repository?("#{config["Org"]}/#{reponame}")
-              puts "\e[31m Already exists a repository with that name in #{config["Org"]}\e[0m"
-            else
-              reponame="#{config["Org"]}/#{reponame}"
-              ex2=true
-            end
-          end
-        end
-      end
-    when op=="3" then reponame=""
-    end
-    return reponame
+  # Set organization repos privacy to private. You need a paid plan to set private repos inside an organization
+  #
+  # @param client [Object] Octokit client object
+  # @param config [Hash] user configuration tracking current org, repo, etc.
+  # @param params [Regexp] regexp to change privacy of matching repos.
+  def change_to_private_repo(client, config, params)
+    pattern = build_regexp_from_string(params)
+    spinner = custom_spinner('Setting private repos :spinner ...')
+    spinner.auto_spin
+    repos = []
+    client.organization_repositories(config['Org'].to_s).each do |repo|
+      repos.push(repo[:name]) if pattern.match(repo[:name])
+    end
+    repos.each do |i|
+      client.set_private("#{config['Org']}/#{i}")
+    end
+    spinner.stop(Rainbow('done!').color(4, 255, 0))
+  rescue StandardError => exception
+    puts Rainbow(exception.message.to_s).color(ERROR_CODE)
+  end
+
+  # Set organization repos privacy to public.
+  #
+  # @param client [Object] Octokit client object
+  # @param config [Hash] user configuration tracking current org, repo, etc.
+  # @param params [Regexp] regexp to change privacy of matching repos.
+  def change_to_public_repo(client, config, params)
+    pattern = build_regexp_from_string(params)
+    spinner = custom_spinner('Setting public repos :spinner ...')
+    spinner.auto_spin
+    repos = []
+    client.organization_repositories(config['Org'].to_s).each do |repo|
+      repos.push(repo[:name]) if pattern.match(repo[:name])
+    end
+    repos.each do |i|
+      client.set_public("#{config['Org']}/#{i}")
+    end
+    spinner.stop(Rainbow('done!').color(4, 255, 0))
+  rescue StandardError => exception
+    puts Rainbow(exception.message.to_s).color(ERROR_CODE)
   end
 
-  def assignment_groups(client,config)
-    team=Teams.new()
-    sys=Sys.new()
-    groupslist=team.get_groupslist(config)
-    groupsadd=[]
-    teamlist=team.read_teamlist(client,config)
+  # Create a 'super repo' containing assignment repositories as submodules
+  #
+  # @param [Object] client Octokit client object
+  # @param [Hash] config user configuration tracking current org, repo, etc.
+  # @param [Array<String>] params 'super repo's' name and Regexp to match submodules
+  #   params[0] is the evaluation repository's name
+  #   params[1] Regexp of submodules
+  def new_eval(client, config, params)
+    options = { private: true, organization: config['Org'].to_s, description: 'Evaluation repository created using ghedsh.' }
+    repo_name = params[0]
+    submodules = []
+    evaluation_repo = client.create_repository(repo_name, options)
+    pattern = build_regexp_from_string(params[1])
+    client.organization_repositories(config['Org'].to_s).each do |repo|
+      submodules << repo[:ssh_url] if pattern.match(repo[:name]) && (repo[:name] != repo_name)
+    end
+    unless submodules.empty?
+      local_repo_path = "#{Dir.pwd}/#{repo_name}"
+      FileUtils.mkdir_p(local_repo_path)
+      FileUtils.cd(local_repo_path) do
+        system('git init')
+        submodules.each do |i|
+          system("git submodule add #{i}")
+        end
+        system('git add .')
+        system('git commit -m "First commit"')
+        system("git remote add origin #{evaluation_repo[:ssh_url]}")
+        system('git push -u origin master')
+      end
+    end
+    puts Rainbow("No submodule found with /#{pattern.source}/") if submodules.empty?
+  rescue StandardError => e
+    puts Rainbow(e.message.to_s).color(ERROR_CODE)
+  end
 
-    puts "\n"
-    puts "Groups currently available:\n\n"
-    groupslist.each do |aux|
-      puts "\t#{aux}"
+  def repo_has_submodules?(client, config)
+    repo_content = []
+    client.contents("#{config['Org']}/#{config['Repo']}").each do |i|
+      repo_content << i[:name]
     end
+    unless repo_content.include?('.gitmodules')
+      puts Rainbow('Current repo does not include .gitmodules and command will not work.').color(WARNING_CODE)
+      return false
+    end
+    true
+  end
 
-    puts "\nAdd groups to your assignment (Press enter to skip): "
-    op=gets.chomp
-    if op==""
-      puts "Do you want to create a new group? (Press any key and enter to proceed, or only enter to skip)"
-      an=gets.chomp
-
-      if an!=""
-        time=Time.new
-        puts "Put the name of the group (If you skip with enter, the group's name will be \"Group-#{time.ctime}\")"
-        name=gets.chomp
-        if name==""
-           name="Group-#{time.ctime}"
-           name=name.split(" ").join("-")
-        end
-        puts "\nTeams currently available:\n\n"
-        teamlist.each do |aux|
-          puts "\t#{aux[0]}"
-        end
-        begin
-          puts "\n1)Put a list of Teams"
-          puts "2)Take all the Teams available"
-          puts "3)Take the teams from a file\n"
-          puts "4)Add the teams to the group later"
-          print "option => "
-          op2=gets.chomp
-        end while (op2!="1" && op2!="2" && op2!="3" && op2!="4")
-        refuse=false         #para no añadirlo cuando se niege en la repeticion de la busqueda de fichero
-        if op2=="1"
-          puts "\nPut a list of Teams (Separeted with space): "
-          list=gets.chomp
-          list=list.split(" ")
-        end
-        if op2=="2"
-          puts "All the teams have been taken"
-          list=teamlist.keys
-        end
-        if op2=="3"
-          begin
-            ex=2
-            puts "Put the name of the file: "
-            file=gets.chomp
-            list=sys.loadfile(file)
-            if list==nil
-              puts "The file doesn't exist or It's empty. Do you like to try again? (y/n):"
-              op3=gets.chomp
-              if op3 == "n" or op3 == "N"
-                ex=1
-                refuse=true
-              end
-            else
-              ex=1
-            end
-          end while ex!=1
-        end
-        if op!="4" and refuse==false
-          team.new_group(client,config,name,list)
-        end
-        groupsadd.push(name)
-      else
-        groupsadd=[]
+  # Evaluate a bash command in each submodule
+  #
+  # @param [Object] client Octokit client object
+  # @param [Hash] config user configuration tracking current org, repo, etc.
+  # @param [Array<String>] params bash command
+  def foreach_eval(client, config, params)
+    if config['Repo']
+      return unless repo_has_submodules?(client, config)
+      command = params.join(' ')
+      FileUtils.cd(Dir.pwd) do
+        system("git submodule foreach '#{command} || :'")
       end
-
     else
-      groupsadd=op.split(" ")
-      groupsadd.each do |item|
-        if groupslist.detect{|aux| aux==item}==nil
-          groupsadd.delete(item)
-        end
-      end
+      puts Rainbow('Please change to an organization repository to run this command.').color(INFO_CODE)
+      return
     end
-    return groupsadd
+  rescue StandardError => e
+    puts Rainbow(e.message.to_s).color(ERROR_CODE)
   end
 
-  def assignment_people(client,config)
-    refuse=false
-    members=self.get_organization_members(client,config)
-    sys=Sys.new()
-    begin
-      puts "\n1)Put a list of students"
-      puts "2)Take all the list"
-      puts "3)Take the students from a file\n"
-      puts "4)Add the students later"
-      print "option => "
-      op2=gets.chomp
-    end while (op2!="1" && op2!="2" && op2!="3" && op2!="4")
-    if op2=="1"
-      puts members
-      puts "\nPut a list of students (Separeted with space): "
-      list=gets.chomp
-      list=list.split(" ")
-    end
-    if op2=="2"
-      puts "All the students have been taken"
-      list=members
-    end
-    if op2=="3"
-      begin
-        ex=2
-        puts "Put the name of the file: "
-        file=gets.chomp
-        list=sys.loadfile(file)
-        if list==nil
-          puts "The file doesn't exist or It's empty. Do you like to try again? (y/n):"
-          op3=gets.chomp
-          if op3 == "n" or op3 == "N"
-            ex=1
-            refuse=true
-          end
-        else
-          ex=1
-        end
-      end while ex!=1
-    end
-    if op2!=4 and refuse==false
-      if op2!=2
-        if list!=nil
-          list.each do |i|
-            if !members.include?(i)
-              list.delete(i)
-            end
-          end
-        end
+  def foreach_try(client, config, params)
+    if config['Repo']
+      return unless repo_has_submodules?(client, config)
+      command = params.join(' ')
+      FileUtils.cd(Dir.pwd) do
+        system("git submodule foreach '#{command}'")
       end
-      return list
     else
-      return []
+      puts Rainbow('Please change to an organization repository to run this command.').color(INFO_CODE)
+      return
     end
+  rescue StandardError => e
+    puts Rainbow(e.message.to_s).color(ERROR_CODE)
   end
 
-  def create_assig(client,config,name)
-    list=self.load_assig()
-    assigs=list["orgs"].detect{|aux| aux["name"]==config["Org"]}
-
-    if assigs==nil
-      list["orgs"].push({"name"=>config["Org"],"assigs"=>[]})
-      Sys.new.save_assigs("#{ENV['HOME']}/.ghedsh",list)
-    end
-
-    assig_exist=list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux| aux["name_assig"]==name}
-    if assig_exist==nil
-      begin
-        puts "\n1)Individual assignment"
-        puts "2)Group assignment"
-        puts "3)Discard assignment"
-        print "option => "
-        op=gets.chomp
-      end while op!="1" && op!="2" && op!="3"
-
-      if op!="3"
-        reponame=self.assignment_repository(client,config,name)
-        if op=="2"
-          groupsadd=self.assignment_groups(client,config)
-          peopleadd=[]
-        end
-        if op=="1"
-          peopleadd=self.assignment_people(client,config)
-          groupsadd=[]
-        end
-        begin
-          list["orgs"][list["orgs"].index{|aux| aux["name"]==config["Org"]}]["assigs"].push({"name_assig"=>name,"teams"=>[],"people"=>peopleadd,"groups"=>groupsadd,"repo"=>reponame})
-        rescue Exception => e
-          puts e
-        end
-        Sys.new.save_assigs("#{ENV['HOME']}/.ghedsh",list)
-      end
+  # Display files and directories within a repository
+  #
+  # @param client [Object] Octokit client object
+  # @param config [Hash] user configuration tracking current org, repo, etc.
+  # @params params [String] Subdirectory within a repo, if not provided shows root directory
+  def show_files(client, config, params)
+    if config['Repo']
+      options = { path: '' }
+      options[:path] = params[0] unless params.empty?
+      file_names_and_types = []
+      client.contents("#{config['Org']}/#{config['Repo']}", options).each do |i|
+        file_names_and_types << "#{i[:name]} (#{i[:type]})"
+      end
+      file_names_and_types.sort_by!(&:downcase)
+      puts file_names_and_types
     else
-      puts "Already exists an Assignment with that name"
+      puts Rainbow('Please change to organization repository to see its files.').color(INFO_CODE)
     end
+  rescue StandardError => e
+    puts Rainbow(e.message.to_s).color(ERROR_CODE)
   end
 
-  def get_assigs(client,config,show)
-    list=self.load_assig()
-    assiglist=[]
-    assig=list["orgs"].detect{|aux| aux["name"]==config["Org"]}
-    if assig!=nil
-      if assig["assigs"].empty?
-        if show==true
-          puts "\e[31m No assignments are available yet\e[0m"
-        end
-      else
-        assig["assigs"].each do |i|
-          assiglist.push(i["name_assig"])
-        end
+  # Display organization teams
+  #
+  # @param client [Object] Octokit client object
+  # @param config [Hash] user configuration tracking current org, repo, etc.
+  # @param params [Regexp] regexp to check team name
+  def show_teams(client, config, params)
+    org_teams = []
+    spinner = custom_spinner("Fetching #{config['Org']} teams :spinner ...")
+    spinner.auto_spin
+    client.organization_teams(config['Org'].to_s).each do |team|
+      org_teams << team[:name]
+    end
+    org_teams.sort_by!(&:downcase)
+    spinner.stop(Rainbow('done!').color(4, 255, 0))
+    if params.nil?
+      org_teams.each do |name|
+        puts name
       end
     else
-      list["orgs"].push({"name"=>config["Org"],"assigs"=>[]})
-      Sys.new.save_assigs("#{ENV['HOME']}/.ghedsh",list)
+      pattern = build_regexp_from_string(params)
+      occurrences = show_matching_items(org_teams, pattern)
+      puts Rainbow("No team inside #{config['Org']} matched  \/#{pattern.source}\/").color(INFO_CODE) if occurrences.zero?
     end
-    return assiglist
-  end
-
-  def get_single_assig(config,wanted)
-    list=self.load_assig()
-    as=list["orgs"].detect{|aux| aux["name"]==config["Org"]}
-    as=as["assigs"].detect{|aux| aux["name_assig"]==wanted}
-    return as
   end
 
-  def show_assig_info(config,assig)
-    assig=self.get_single_assig(config,assig)
-    team=Teams.new()
-    puts "\n"
-    puts assig["name_assig"]
-    assig=assig.sort.to_h
-    assig.each{|key, value| if key.include?("repo") then  puts "Repository #{key.delete("repo")}: #{value}" end}
-    puts
-    assig.each{|key, value| if key.include?("sufix") then  puts "Sufix of Repository #{key.delete("sufix")} : #{value}" end}
-    print "\n"
-    if assig["groups"]!=[]
-      puts "\tGroups: "
-      assig["groups"].each do |y|
-        puts "\t\t#{y}"
-        t=team.get_single_group(config,y)
-        if t!=nil
-          t.each do |z|
-            puts "\t\t\t#{z}"
-          end
-        end
-      end
+  # Clone a repository, if repo_name is Regexp it will clone all org repositories matching pattern
+  #   if repo_name is String searches for that repo and clones it
+  #
+  # @param enviroment [ShellContext] contains the shell context, including Octokit client and user config
+  # @param repo_name [Regexp, String] pattern or name of repo
+  # @param custom_path [String] if is not provided default path is HOME/ghedsh-cloned else is some
+  #   path under HOME (already existing or not)
+  def clone_repository(enviroment, repo_name, custom_path)
+    client = enviroment.client
+    config = enviroment.config
+    repos_to_clone = []
+    if repo_name.include?('/')
+      pattern = build_regexp_from_string(repo_name)
+      client.organization_repositories(config['Org'].to_s).each do |repo|
+        repos_to_clone << { name: repo[:name], ssh_url: repo[:clone_url] } if pattern.match(repo[:name])
+      end
+      puts Rainbow("No repository matched \/#{pattern.source}\/").color(INFO_CODE) if repos_to_clone.empty?
+    else
+      repo = client.repository("#{config['Org']}/#{repo_name}")
+      repos_to_clone << { name: repo[:name], ssh_url: repo[:clone_url] }
     end
-    if assig["people"]!=[] and assig["people"]!=nil
-      puts "\tStudents: "
-      assig["people"].each do |y|
-        puts "\t\t#{y}"
+    unless repos_to_clone.empty?
+      perform_git_clone(repos_to_clone, custom_path)
+      if custom_path.nil?
+        puts Rainbow("Cloned into #{Dir.pwd}").color(INFO_CODE).underline
+      else
+        puts Rainbow("Cloned into #{Dir.home}#{custom_path}").color(INFO_CODE).underline
       end
-      puts "\n"
+      puts
     end
+  rescue StandardError => exception
+    puts Rainbow(exception.message.to_s).color(ERROR_CODE)
+    puts
   end
 
-  def make_assig(client,config,assig)
-    web="https://github.com/"
-    web2="git@github.com:"
-    r=Repositories.new()
-    team=Teams.new()
-    sys=Sys.new()
-    teamlist=team.read_teamlist(client,config)
-    assig=self.get_single_assig(config,assig)
-    repolist=[]
-    point=1
-    assig.each{|key, value| if key.include?("repo") then  repolist.push(value) end}
-
-    if repolist!=[]
-      repolist.each do |repo|
-        sys.create_temp("#{ENV['HOME']}/.ghedsh/temp")
-        puts repo
-        if repolist.size>1
-          if point>1 || assig.has_key?("sufix1")
-            sufix="sufix#{point}"
-            sufix="-#{assig["#{sufix}"]}"
-          else
-            sufix=""
-          end
-        else
-          sufix=""
-        end
-        point=point+1
-        if !client.repository?(repo)
-          aux=repo.split("/")
-          aux=aux[1]
-          r.create_repository(client,config,aux,false,ORGS)
-        end
-        system("git clone #{web2}#{repo}.git #{ENV['HOME']}/.ghedsh/temp/#{repo}")
-        if assig["groups"]!=[]
-          assig["groups"].each do |i|
-
-            teamsforgroup=team.get_single_group(config,i)
-            if teamsforgroup!=nil
-              teamsforgroup.each do |y|
-                config["TeamID"]=teamlist["#{y}"]
-                config["Team"]=y
-                puts y
-                puts sufix
-                r.create_repository(client,config,"#{assig["name_assig"]}#{sufix}-#{y}",true,TEAM)
-                system("git -C #{ENV['HOME']}/.ghedsh/temp/#{repo} remote rm origin")
-                system("git -C #{ENV['HOME']}/.ghedsh/temp/#{repo} remote add origin #{web2}#{config["Org"]}/#{assig["name_assig"]}#{sufix}-#{y}.git")
-
-                system("git -C #{ENV['HOME']}/.ghedsh/temp/#{repo} push origin --all")
-              end
-            end
-          end
-        end
-        if assig["people"]!=[] and assig["people"]!=nil
-          assig["people"].each do |i|
-              r.create_repository(client,config,"#{assig["name_assig"]}#{sufix}-#{i}",true,ORGS)
-              system("git -C #{ENV['HOME']}/.ghedsh/temp/#{repo} remote rm origin")
-              system("git -C #{ENV['HOME']}/.ghedsh/temp/#{repo} remote add origin #{web2}#{config["Org"]}/#{assig["name_assig"]}#{sufix}-#{i}.git")
-              system("git -C #{ENV['HOME']}/.ghedsh/temp/#{repo} push origin --all")
-              r.add_collaborator(client,"#{config["Org"]}/#{assig["name_assig"]}#{sufix}-#{i}",i)
-           end
-        end
-      end
+  # Open default browser ready to create an issue with GitHub form.
+  #
+  # @param config [Hash] user configuration tracking current org, repo, etc.
+  # @example create issue
+  #   User > Org > Repo > new_issue
+  def create_issue(config)
+    if config['Repo']
+      issue_creation_url = "https://github.com/#{config['Org']}/#{config['Repo']}/issues/new"
+      open_url(issue_creation_url)
     else
-      puts "\e[31m No repository is given for this assignment\e[0m"
+      puts Rainbow('Change to repo in order to create an issue.').color(INFO_CODE)
     end
   end
 
-  def add_team_to_assig(client,config,assig,data)
-    assig=self.get_single_assig(config,assig)
-  end
-
-  def add_people_to_assig(client,config,assig)
-    list=self.load_assig()
-    people=self.assignment_people(client,config)
-    if list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux2| aux2["name_assig"]==assig}["people"]==nil
-      list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux2| aux2["name_assig"]==assig}["people"]=[]
-    end
-
-    if people!=""
+  # Add members typing them separately
+  #
+  # @param client [Object] Octokit client object
+  # @param config [Hash] user configuration tracking current org, repo, etc.
+  # @example add two members to current org (separated with commas)
+  #   User > Org > invite_member member1, member2
+  # @example add two members to current org (separated with blanks)
+  #   User > Org > invite_member member1 member2
+  # @example add members to current org (commas and blanks combined)
+  #   User > Org > invite_member member1, member2 member4, member5
+  def add_members(client, config, members)
+    if members.empty?
+      puts Rainbow('Please type each member you would like to add.').color(INFO_CODE)
+    else
+      people = split_members(members)
+      spinner = custom_spinner('Adding member(s) :spinner ...')
       people.each do |i|
-        if !list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux2| aux2["name_assig"]==assig}["people"].include?(i)
-          list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux2| aux2["name_assig"]==assig}["people"].push(i)
-        else
-          puts "#{i} is already in this assignment."
-        end
+        options = { role: 'member', user: i.to_s }
+        client.update_organization_membership(config['Org'].to_s, options)
       end
-      Sys.new.save_assigs("#{ENV['HOME']}/.ghedsh",list)
+      spinner.stop(Rainbow('done!').color(4, 255, 0))
     end
+  rescue StandardError => exception
+    puts Rainbow(exception.message.to_s).color(ERROR_CODE)
   end
 
-  def add_group_to_assig(client,config,assig)
-    list=self.load_assig()
-
-    groups=self.assignment_groups(client,config)
-    if groups!=""
-      groups.each do |i|
-        list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux2| aux2["name_assig"]==assig}["groups"].push(i)
-      end
-      Sys.new.save_assigs("#{ENV['HOME']}/.ghedsh",list)
-    end
+  # Add members from file (JSON). File must be located somewhere in HOME.
+  #
+  # @param client [Object] Octokit client object
+  # @param config [Hash] user configuration tracking current org, repo, etc.
+  def add_members_from_file(client, config, path)
+    file_path = "#{Dir.home}#{path}"
+    members_json = File.read(file_path)
+    members_file = JSON.parse(members_json)
+    spinner = custom_spinner('Adding members from file :spinner ...')
+    members_file['members'].each do |member|
+      options = { role: 'member', user: member['id'].to_s }
+      client.update_organization_membership(config['Org'].to_s, options)
+    end
+    spinner.stop(Rainbow('done!').color(4, 255, 0))
+  rescue Errno::ENOENT
+    puts Rainbow('Could not open file, check file location.').color(ERROR_CODE)
+  rescue StandardError => exception
+    puts Rainbow(exception.message.to_s).color(ERROR_CODE)
   end
 
-  def open_assig(config,assig)
-    Sys.new.open_url("https://github.com/search?q=org%3A#{config["Org"]}+#{assig}")
-  end
-
-  #Takes people info froma a csv file and gets into ghedsh people information
-  def add_people_info(client,config,file,relation)
-    list=self.load_people()
-    csvoptions={:quote_char => "|",:headers=>true,:skip_blanks=>true}
-    members=self.get_organization_members(client,config)  #members of the organization
-    change=false
-    indexname=""
-
-    inpeople=list["orgs"].detect{|aux| aux["name"]==config["Org"]}
-    if inpeople==nil
-      list["orgs"].push({"name"=>config["Org"],"users"=>[]})
-      Sys.new.save_people("#{ENV['HOME']}/.ghedsh",list)
-    end
-
-    if file.end_with?(".csv")==false
-      file=file+".csv"
-    end
-    if File.exist?(file)
-      begin
-        mem = CSV.read(file,csvoptions)
-      rescue
-        print "Invalid csv format."
-      end
-
-      fields=mem.headers
-      users=Hash.new;
-      users=[]
-      puts "\nFields found: "
-      puts fields
-      puts
-      mem.each do |i|
-        aux=Hash.new
-        fields.each do |j|
-          if i[j]!=nil
-            if GITHUB_LIST.include?(j.gsub("\"", "").downcase.strip)
-              data=i[j]
-              data=data.gsub("\"", "")
-              aux["github"]=data
-              j="github"
-            else
-              if MAIL_LIST.include?(j.gsub("\"", "").downcase.strip)
-                aux["email"]=i[j].gsub("\"", "").strip
-                indexname=j
-                j="email"
-                change=true
-              else
-                data=i[j].gsub("\"", "")
-                aux[j.gsub("\"", "").downcase.strip]=data.strip
-              end
-            end
-          else
-            data=i[j].gsub("\"", "")
-            aux[j.gsub("\"", "").downcase.strip]=data.strip
-          end
-        end
-        users.push(aux)
-      end
-      ## Aqui empiezan las diferenciaa
-      if relation==true
-        if change==true
-          fields[fields.index(indexname)]="email"
-        end
-        fields=users[0].keys
-        # if users.keys.include?("github") and users.keys.include?("email") and users.keys.size==2
-        if fields.include?("github") and fields.include?("email") and fields.size==2
-          users.each do |i|
-            if members.include?(i["github"].delete("\""))
-              here=list["orgs"].detect{|aux| aux["name"]==config["Org"]}["users"].detect{|aux2| aux2["github"]==i["github"]} #miro si ya esta registrado
-              if here==nil
-                list["orgs"].detect{|aux| aux["name"]==config["Org"]}["users"]<<i
-                puts "#{i["github"]} information correctly added"
-              else                                                                        #si ya esta registrado...
-                puts "#{i["github"]} is already registered in this organization"
-              end
-            else
-              puts "#{i["github"]} is not registered in this organization"
-            end
-          end
-        else
-          puts "No relationship found between github users and emails."
-          return nil
-        end
-      else                                                                           #insercion normal, relacion ya hecha
-        users.each do |i|
-          here=list["orgs"].detect{|aux| aux["name"]==config["Org"]}["users"].detect{|aux2| aux2["email"]==i["email"]}
-          if here!=nil
-            i.each do |j|
-              list["orgs"].detect{|aux| aux["name"]==config["Org"]}["users"].detect{|aux2| aux2["email"]==i["email"]}["#{j[0]}"]=j[1]
-            end
-          else
-            puts "No relation found of #{i["email"]} in #{config["Org"]}"
-          end
+  # Removes a group of members form current organization. It is possible to specify them
+  # in a file or with Regexp to match GitHub IDs.
+  #
+  # @param client [Object] Octokit client object
+  # @param config [Hash] user configuration tracking current org, repo, etc.
+  # @param param [String, Regexp] if string must be file path to remove memebers from file
+  # if Regexp will remove matching GitHub IDs from organization
+  def delete_member(client, config, param)
+    permissions = client.organization_membership(config['Org'], opts = { user: client.login })
+    unless permissions[:role] == 'admin'
+      puts Rainbow("You must have Admin permissions on #{config['Org']} to run this command.").underline.color(WARNING_CODE)
+      return
+    end
+    if is_file?("#{Dir.home}#{param}")
+      puts 'Removing member/members from file.'
+      file_path = "#{Dir.home}#{param}"
+      remove_json = File.read(file_path)
+      remove_member_file = JSON.parse(remove_json)
+      remove_member_file['remove'].each do |member|
+        client.remove_organization_member(congif['Org'], member['id'].to_s)
+      end
+    elsif eval(param).is_a?(Regexp)
+      members_to_remove = []
+      pattern = build_regexp_from_string(param)
+      client.organization_members(config['Org'].to_s).each do |member|
+        members_to_remove.push(member[:login]) if pattern.match(member[:login])
+      end
+      if members_to_remove.empty?
+        puts Rainbow("No members to remove matched with \/#{pattern.source}\/").color(WARNING_CODE)
+      else
+        members_to_remove.each do |i|
+          client.remove_organization_member(congif['Org'], i.to_s)
         end
       end
-      #tocho
-      Sys.new.save_people("#{ENV['HOME']}/.ghedsh",list)
-    else
-      print "\n#{file} file not found.\n\n"
     end
+  rescue SyntaxError => e
+    puts Rainbow('Parameter is not a file and there was a Syntax Error building Regexp.').color(ERROR_CODE)
+  rescue StandardError => e
+    puts Rainbow(e.message.to_s).color(ERROR_CODE)
   end
 
-  def rm_people_info(client,config)
-    list=self.load_people()
-    inpeople=list["orgs"].detect{|aux| aux["name"]==config["Org"]}
-    if inpeople==nil
-      puts "Extended information has not been added yet"
+  # Invite as members all outside collaborators from organization.
+  # This action needs admin permissions on the organization.
+  # This method checks first if parameter is an existing file, then checks Regexp, else invites all
+  # outside collaborators of current organization.
+  #
+  # @param client [Object] Octokit client object
+  # @param config [Hash] user configuration tracking current org, repo, etc.
+  # @param param [String, Regexp] file path or Regexp to invite outside collabs
+  def invite_all_outside_collaborators(client, config, param)
+    permissions = client.organization_membership(config['Org'], opts = { user: client.login })
+    unless permissions[:role] == 'admin'
+      puts Rainbow("You must have Admin permissions on #{config['Org']} to run this command.").underline.color(WARNING_CODE)
+      return
+    end
+    outside_collaborators = []
+    spinner = custom_spinner('Sending invitations :spinner ...')
+    if is_file?("#{Dir.home}#{param}")
+      puts 'Adding outside collaborators from file'
+      file_path = "#{Dir.home}#{param}"
+      collab_json = File.read(file_path)
+      collab_file = JSON.parse(collab_json)
+      collab_file['collabs'].each do |collab|
+        outside_collaborators.push(collab['id'])
+      end
+    elsif eval(param).is_a?(Regexp)
+      pattern = build_regexp_from_string(param)
+      client.outside_collaborators(config['Org']).each do |i|
+        outside_collaborators.push(i[:login]) if pattern.match(i[:login])
+      end
     else
-      if inpeople["users"].empty?
-        puts "Extended information has not been added yet"
-      else
-        list["orgs"].detect{|aux| aux["name"]==config["Org"]}["users"]=[]
-        Sys.new.save_people("#{ENV['HOME']}/.ghedsh",list)
-        puts "The aditional information of #{config["Org"]} has been removed"
+      begin
+        client.outside_collaborators(config['Org']).each do |i|
+          outside_collaborators.push(i[:login])
+        end
+      rescue StandardError => exception
+        puts Rainbow('If you entered file path, please ensure that is the correct path.').color(ERROR_CODE)
       end
     end
+    outside_collaborators.each do |j|
+      options = { role: 'member', user: j.to_s }
+      client.update_organization_membership(config['Org'], options)
+    end
+    spinner.stop(Rainbow('done!').color(4, 255, 0))
+  rescue SyntaxError => e
+    puts Rainbow('Parameter is not a file and there was a Syntax Error building Regexp.').color(ERROR_CODE)
+  rescue StandardError => exception
+    puts Rainbow(exception.message.to_s).color(ERROR_CODE)
   end
 
-  def search_rexp_people_info(client,config,exp)
-    list=self.load_people()
-    if list!=nil
-      if list["users"]!=[]
-        list=list["orgs"].detect{|aux| aux["name"]==config["Org"]}
-        if exp.match(/^\//)
-          sp=exp.split('/')
-          exp=Regexp.new(sp[1],sp[2])
-        end
-        list=Sys.new.search_rexp_peoplehash(list["users"],exp)
-
-        if list!=[]
-          fields=list[0].keys
-          list.each do |i|
-            puts "\n\e[31m#{i["github"]}\e[0m"
-            fields.each do |j|
-              puts "#{j.capitalize}:\t #{i[j]}"
-            end
-            puts
-          end
-        end
-      else
-        puts "Extended information has not been added yet"
-      end
+  # Open default browser and shows open issues
+  #
+  # @param config [Hash] user configuration tracking current org, repo, etc.
+  # @example open issue's list
+  #   User > Org > Repo > issues
+  def show_issues(config)
+    if config['Repo']
+      issues_url = "https://github.com/#{config['Org']}/#{config['Repo']}/issues"
+      open_url(issues_url)
     else
-      list["orgs"].push({"name"=>config["Org"],"users"=>[]})
-      Sys.new.save_people("#{ENV['HOME']}/.ghedsh",list)
-      puts "Extended information has not been added yet"
+      puts Rainbow('Change to repo in order to view all issues').color(INFO_CODE)
     end
   end
 
-  def show_people_info(client,config,user)
-    list=self.load_people()
-
-    inpeople=list["orgs"].detect{|aux| aux["name"]==config["Org"]}
-    peopleinfolist=[]
-
-    if inpeople==nil
-      list["orgs"].push({"name"=>config["Org"],"users"=>[]})
-      Sys.new.save_people("#{ENV['HOME']}/.ghedsh",list)
-      puts "Extended information has not been added yet"
+  # Display organization people. It shows all members and if the authenticated user is org admin
+  #   also displays outside collaborators.
+  #
+  # @param client [Object] Octokit client object
+  # @param config [Hash] user configuration tracking current org, repo, etc.
+  # @param params [Regexp] if provided, it must be a Regexp
+  # @example Display organization people
+  #   User > Org > people
+  # @example Display people matching Regexp
+  #   User > Org > people /alu/
+  def show_people(client, config, params)
+    spinner = custom_spinner("Fetching #{config['Org']} people :spinner ...")
+    spinner.auto_spin
+    org_members = []
+    client.organization_members(config['Org'].to_s).each do |member|
+      org_members << [member[:login], 'member']
+    end
+    membership = {}
+    client.organization_membership(config['Org'].to_s).each do |key, value|
+      membership[key] = value
+    end
+    if membership[:role] == 'admin'
+      client.outside_collaborators(config['Org'].to_s).each do |collab|
+        org_members << [collab[:login], 'outside collaborator']
+      end
+    end
+    spinner.stop(Rainbow('done!').color(4, 255, 0))
+    if params.nil?
+      table = Terminal::Table.new headings: ['Github ID', 'Role'], rows: org_members
+      puts table
     else
-      if inpeople["users"]!=[]
-        if user==nil
-          fields=list["orgs"].detect{|aux| aux["name"]==config["Org"]}["users"][0].keys
-          list["orgs"].detect{|aux| aux["name"]==config["Org"]}["users"].each do |i|
-            puts "\n\e[31m#{i["github"]}\e[0m"
-            fields.each do |j|
-              puts "#{j.capitalize}:\t #{i[j]}"
-            end
-            peopleinfolist<<i["github"]
-          end
-          return peopleinfolist
-        else
-          if user.include?("@")
-            inuser=list["orgs"].detect{|aux| aux["name"]==config["Org"]}["users"].detect{|aux2| aux2["email"]==user}
-          else
-            inuser=list["orgs"].detect{|aux| aux["name"]==config["Org"]}["users"].detect{|aux2| aux2["github"]==user}
-          end
-          if inuser==nil
-            puts "Not extended information has been added of that user."
-          else
-            fields=inuser.keys
-            puts "\n\e[31m#{inuser["github"]}\e[0m"
-            fields.each do |j|
-              puts "#{j.capitalize}:\t #{inuser[j]}"
-            end
-            puts
-          end
-        end
-      else
-        puts "Extended information has not been added yet"
+      unless params.include?('/')
+        raise Rainbow('Parameter must be a Regexp. Example: /pattern/').color(ERROR_CODE)
+        return
       end
+      pattern = build_regexp_from_string(params)
+      occurrences = build_item_table(org_members, pattern)
+      puts Rainbow("No member inside #{config['Org']} matched  \/#{pattern.source}\/").color(INFO_CODE) if occurrences.zero?
     end
   end
 
-  def add_repo_to_assig(client,config,assig,change)
-    list=self.load_assig()
-    notexist=false
-
-    if change!=nil      #change an specific repository
-      reponumber=change
-      fields=list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux2| aux2["name_assig"]==assig}.keys
-      if reponumber=="1"
-        if !fields.include?("repo")
-          notexist=true
-        end
+  # perform cd to repo scope, if 'name' is a Regexp, matches are stored and then we let the user select one
+  #   if is not a Regexp, check that the string provided is a vale repository name
+  #
+  # @param name [String, Regexp] repo name
+  # @param client [Object] Octokit client object
+  # @param enviroment [ShellContext] contains the shell context, including Octokit client and user config
+  # @return [ShellContext] changed context is returned if there is not an error during process.
+  def cd_repo(name, client, enviroment)
+    if name.class == Regexp
+      pattern = Regexp.new(name.source, name.options)
+      org_repos = []
+      org_repos_url = {}
+      spinner = custom_spinner("Matching #{enviroment.config['Org']} repositories :spinner ...")
+      spinner.auto_spin
+      client.organization_repositories(enviroment.config['Org'].to_s).each do |org_repo|
+        if pattern.match(org_repo[:name].to_s)
+          org_repos << org_repo[:name]
+          org_repos_url[org_repo[:name].to_s] = org_repo[:html_url]
+        end
+      end
+      spinner.stop(Rainbow('done!').color(4, 255, 0))
+      if org_repos.empty?
+        puts Rainbow("No repository matched with #{name.source} inside organization #{enviroment.config['Org']}").color(WARNING_CODE)
+        puts
+        return
       else
-        if !fields.include?("repo"+change.to_s)
-          notexist=true
-        end
-      end
-    else                #adding new repository
-      fields=list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux2| aux2["name_assig"]==assig}.keys
-      reponumber=1
-      ex=0
-      while ex==0
-        if reponumber==1
-          if fields.include?("repo")
-            reponumber=reponumber+1
-          else
-            ex=1
-          end
-        else
-          if fields.include?("repo#{reponumber}")
-            reponumber=reponumber+1
-          else
-            ex=1
-          end
-        end
+        prompt = TTY::Prompt.new
+        answer = prompt.select('Select desired organization repository', org_repos)
+        enviroment.config['Repo'] = answer
+        enviroment.config['repo_url'] = org_repos_url[answer]
+        enviroment.deep = Organization
       end
-    end
-
-    if notexist==true
-      puts "Doesn't exist that repository"
     else
-      reponame=self.assignment_repository(client,config,assig["name_assig"])
-      if reponumber.to_i>1
-        sufix="sufix#{reponumber}"
-        sufixname=self.assignment_repo_sufix(reponumber,1)
-      end
-    end
-
-    if reponame!="" and notexist==false
-      if reponumber.to_i==1
-        list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux2| aux2["name_assig"]==assig}["repo"]=reponame
-        Sys.new.save_assigs("#{ENV['HOME']}/.ghedsh",list)
+      if client.repository?("#{enviroment.config['Org']}/#{name}")
+        org_repo_url = 'https://github.com/' << enviroment.config['Org'].to_s << '/' << name.to_s
+        enviroment.config['Repo'] = name
+        enviroment.config['repo_url'] = org_repo_url
+        enviroment.deep = Organization
       else
-        list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux2| aux2["name_assig"]==assig}["repo#{reponumber}"]=reponame
-        list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux2| aux2["name_assig"]==assig}["#{sufix}"]=sufixname
-        Sys.new.save_assigs("#{ENV['HOME']}/.ghedsh",list)
+        puts Rainbow("Maybe #{name} is not an organizaton or currently does not exist.").color(WARNING_CODE)
+        return
       end
     end
+    enviroment
   end
 
-  def rm_assigment_repo(config,assig,reponumber)
-    list=self.load_assig()
-
-    if reponumber==1
-      if list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux2| aux2["name_assig"]==assig}["repo"]!=nil
-        list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux2| aux2["name_assig"]==assig}.delete("repo")
-        list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux2| aux2["name_assig"]==assig}.delete("sufix1")
-        Sys.new.save_assigs("#{ENV['HOME']}/.ghedsh",list)
+  # perform cd to team scope, first we retrieve all user's orgs, then we check 'name'
+  #   if its a Regexp then matches are displayed on screen and user selects one (if no match warning
+  #   is shown and we return nil)
+  #   if 'name' is not a Regexp then it must be the full team's name so we check that is inside org_teams
+  #   Last option is showing a warning and return nil (so we dont push to the stack_context)
+  #
+  # @param name [String, Regexp] team name
+  # @param client [Object] Octokit client object
+  # @param enviroment [ShellContext] contains the shell context, including Octokit client and user config
+  # @return [ShellContext] changed context is returned if there is not an error during process.
+  def cd_team(name, client, enviroment)
+    org_teams = []
+    org_teams_id = {}
+    spinner = custom_spinner("Fetching #{enviroment.config['Org']} teams :spinner ...")
+    spinner.auto_spin
+    client.organization_teams(enviroment.config['Org'].to_s).each do |team|
+      org_teams << team[:name]
+      org_teams_id[team[:name].to_s] = team[:id]
+    end
+    spinner.stop(Rainbow('done!').color(4, 255, 0))
+    if name.class == Regexp
+      pattern = Regexp.new(name.source, name.options)
+      name_matches = []
+      org_teams.each do |team_name|
+        name_matches << team_name if pattern.match(team_name.to_s)
+      end
+      if name_matches.empty?
+        puts Rainbow("No team matched with \/#{name.source}\/ inside organization #{enviroment.config['Org']}").color(WARNING_CODE)
+        puts
+        return
       else
-        puts "Doesn't exist that repository"
+        prompt = TTY::Prompt.new
+        answer = prompt.select('Select desired organization', name_matches)
+        enviroment.config['Team'] = answer
+        enviroment.config['TeamID'] = org_teams_id[answer]
+        enviroment.config['team_url'] = 'https://github.com/orgs/' << enviroment.config['Org'] << '/teams/' << enviroment.config['Team']
+        enviroment.deep = Team
       end
     else
-      if list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux2| aux2["name_assig"]==assig}["repo#{reponumber}"]!=nil
-        list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux2| aux2["name_assig"]==assig}.delete("repo#{reponumber}")
-        list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux2| aux2["name_assig"]==assig}.delete("sufix#{reponumber}")
-        Sys.new.save_assigs("#{ENV['HOME']}/.ghedsh",list)
+      if org_teams.include?(name)
+        enviroment.config['Team'] = name
+        enviroment.config['TeamID'] = org_teams_id[name]
+        enviroment.config['team_url'] = 'https://github.com/orgs/' << enviroment.config['Org'] << '/teams/' << enviroment.config['Team']
+        enviroment.deep = Team
       else
-        puts "Doesn't exist that repository"
+        puts Rainbow("Maybe #{name} is not a #{enviroment.config['Org']} team or currently does not exist.").color(WARNING_CODE)
+        puts
+        return
       end
     end
+    enviroment
   end
 
-  def rm_assigment_student(config,assig,student,mode)
-    list=self.load_assig()
-    if mode==1
-      if list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux2| aux2["name_assig"]==assig}["people"].include?(student)
-        list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux2| aux2["name_assig"]==assig}["people"].delete(student)
-        puts "Student #{student} correctly deleted from the assignment"
-        Sys.new.save_assigs("#{ENV['HOME']}/.ghedsh",list)
-      else
-        puts "Student not found"
-      end
-    else
-      list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux2| aux2["name_assig"]==assig}["people"].clear()
-      puts "All the students has been deleted from the assignment"
-      Sys.new.save_assigs("#{ENV['HOME']}/.ghedsh",list)
-    end
+  # cd method contains a hash representing where user can navigate depending on context. In this case
+  #   inside an organization user is allowed to change to a org repo and org team.
+  #   In order to add new 'cd types' see example below.
+  #
+  # @param type [String] name of the navigating option (repo, org, team, etc.)
+  # @param name [String, Regexp] String or Regexp to find the repository.
+  # @example add 'chuchu' cd scope
+  #   add to cd_scopes = {'chuchu => method(:cd_chuchu)}
+  #   call it with (name, client, enviroment) parameters
+  def cd(type, name, client, enviroment)
+    cd_scopes = { 'repo' => method(:cd_repo), 'team' => method(:cd_team) }
+    cd_scopes[type].call(name, client, enviroment)
   end
 
-  def rm_assigment_group(config,assig,group,mode)
-    list=self.load_assig()
-    if mode==1
-      if list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux2| aux2["name_assig"]==assig}["groups"].include?(group)
-        list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux2| aux2["name_assig"]==assig}["groups"].delete(group)
-        puts "Group #{group} correctly deleted from the assignment"
-        Sys.new.save_assigs("#{ENV['HOME']}/.ghedsh",list)
-      else
-        puts "Group not found"
-      end
+  # Show commits of current repo. If user is not in a repo, repository name for commit showing must be provided.
+  #
+  # @param enviroment [ShellContext] contains the shell context, including Octokit client and user config
+  # @param params [Array<String>] if user is not on a repo then params[0] is repo name. Optionally,
+  #   branch can be specified (value is in params[1]), if not provided default branch is master
+  def show_commits(enviroment, params)
+    options = {}
+    if !enviroment.config['Repo'].nil?
+      repo = enviroment.config['Repo']
+      options[:sha] = if params.empty?
+                        'master'
+                      else
+                        params[0]
+                      end
     else
-      list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux2| aux2["name_assig"]==assig}["groups"].clear()
-      puts "All the groups has been deleted from the assignment"
-      Sys.new.save_assigs("#{ENV['HOME']}/.ghedsh",list)
+      repo = params[0]
+      options[:sha] = if params[1].nil?
+                        'master'
+                      else
+                        params[1]
+                      end
     end
-  end
-
-  def assignment_repo_sufix(reponumber,order)
-    op=""
-    print "\n"
-    if order==1
-      while op=="" or op=="\n"
-        puts "Add the suffix of the repository \"#{reponumber}\", in order to differentiate it from the other repositories: "
-        op=gets.chomp
-      end
-    else
-      while op=="" or op=="\n"
-        puts "Add the suffix of the first repository, in order to differentiate it from the other repositories: "
-        op=gets.chomp
+    begin
+      enviroment.client.commits("#{enviroment.config['Org']}/#{repo}", options).each do |i|
+        puts "\tSHA: #{i[:sha]}"
+        puts "\t\t Commit date: #{i[:commit][:author][:date]}"
+        puts "\t\t Commit author: #{i[:commit][:author][:name]}"
+        puts "\t\t\t Commit message: #{i[:commit][:message]}"
+        puts
       end
+    rescue StandardError => exception
+      puts exception
+      puts Rainbow("If you are not currently on a repo, USAGE TIP: `commits <repo_name> [branch_name]` (default: 'master')").color(INFO_CODE)
     end
-    return op
   end
 
-  def change_repo_sufix(config,assig,reponumber)
-    list=self.load_assig()
-    if list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux2| aux2["name_assig"]==assig}["sufix#{reponumber}"]!=nil
-      if reponumber==1
-        sufixname=self.assignment_repo_sufix(reponumber,2)
-        sufix="sufix1"
-      else
-        sufixname=self.assignment_repo_sufix(reponumber,1)
-        sufix="sufix#{reponumber}"
-      end
-
-      list["orgs"].detect{|aux| aux["name"]==config["Org"]}["assigs"].detect{|aux2| aux2["name_assig"]==assig}["#{sufix}"]=sufixname
-      Sys.new.save_assigs("#{ENV['HOME']}/.ghedsh",list)
-    else
-      puts "Doesn't exist a repository with that identifier"
-    end
+  # Repo creation: creates new repo inside current org
+  #
+  # @param enviroment [ShellContext] contains the shell context, including Octokit client and user config
+  # @param repo_name [String] repository name
+  # @param options [Hash] repository options (repo organization, visibility, etc)
+  def create_repo(enviroment, repo_name, options)
+    client = enviroment.client
+    options[:organization] = enviroment.config['Org'].to_s
+    client.create_repository(repo_name, options)
+    puts Rainbow('Repository created correctly!').color(79, 138, 16)
+  rescue StandardError => exception
+    puts Rainbow(exception.message.to_s).color(ERROR_CODE)
+    puts
   end
 
-  def show_organization_members_bs(client,config)
-    orgslist=[]
-    print "\n"
-    mem=client.organization_members(config["Org"])
-    mem.each do |i|
-      m=eval(i.inspect)
-      orgslist.push(m[:login])
-      puts m[:login]
-    end
+  # Removes repository by name
+  #
+  # @param enviroment [ShellContext] contains the shell context, including Octokit client and user config
+  # @param repo_name [String] name of the repo to be removed
+  def remove_repo(enviroment, repo_name)
+    client = enviroment.client
+    client.delete_repository("#{enviroment.config['Org']}/#{repo_name}")
+    puts Rainbow('Repository deleted.').color(INFO_CODE)
+  rescue StandardError => exception
+    puts Rainbow(exception.message.to_s).color(ERROR_CODE)
     puts
-    return orgslist
   end
 
-  def get_organization_members(client,config)
-    mem=client.organization_members(config["Org"])
-    list=[]
-    if mem!=nil
-      mem.each do |i|
-        list<<i[:login]
+  # Removes a group of GitHub users from an organization
+  #
+  #
+  def remove_org_member; end
+
+  # Team creation: opens team creation page on default browser when calling new_team
+  #   with no options. If option provided, it must be the directory and name of the JSON file
+  #   somewhere in your HOME directory for bulk creation of teams and members.
+  #
+  # @param client [Object] Octokit client object
+  # @param config [Hash] user configuration tracking current org, repo, etc.
+  # @param params [Array<String>] user specified parameters, if not nil must be path to teams JSON file.
+  # @example Open current org URL and create new team
+  #   User > Org > new_team
+  # @example Create multiple teams with its members inside current org
+  #   User > Org > new_team (HOME)/path/to/file/creation.json
+  def create_team(client, config, params)
+    if params.nil?
+      team_creation_url = "https://github.com/orgs/#{config['Org']}/new-team"
+      open_url(team_creation_url)
+    else
+      members_not_added = []
+      begin
+        file_path = "#{Dir.home}#{params}"
+        teams_json = File.read(file_path)
+        teams_file = JSON.parse(teams_json)
+        spinner = custom_spinner("Creating teams in #{config['Orgs']} :spinner ...")
+        teams_file['teams'].each do |team|
+          # assigned to 'created_team' to grab the ID (and use it for adding members)
+          # of the newly created team
+          created_team = client.create_team(config['Org'].to_s,
+                                            name: team['name'].to_s,
+                                            privacy: team['privacy'])
+          team['members'].each do |member|
+            member_addition = client.add_team_member(created_team[:id], member)
+            members_not_added.push(member) if member_addition == false # if !!member_adition
+          end
+        end
+        spinner.stop(Rainbow('done!').color(4, 255, 0))
+        puts Rainbow('Teams created correctly!').color(79, 138, 16)
+        puts Rainbow("Could not add following members: #{members_not_added}").color(WARNING_CODE) unless members_not_added.empty?
+      rescue StandardError => e
+        puts Rainbow(e.message.to_s).color(ERROR_CODE)
       end
     end
-    return list
   end
 
-  def show_orgs(client,config)
-    orgslist=[]
-    print "\n"
-    org=client.organizations
-    org.each do |i|
-      o=eval(i.inspect)
-      puts o[:login]
-      orgslist.push(o[:login])
-    end
-    print "\n"
-    return orgslist
+  # Open org's team list and delete manually (faster than checking teams IDs and delete it)
+  #
+  # @param client [Object] Octokit client object
+  # @param config [Hash] user configuration tracking current org, repo, etc.
+  def remove_team(config)
+    teams_url = "https://github.com/orgs/#{config['Org']}/teams"
+    open_url(teams_url)
   end
 
   def read_orgs(client)
-    orgslist=[]
-    org=client.organizations
+    orgslist = []
+    org = client.organizations
     org.each do |i|
-      o=eval(i.inspect)
+      o = eval(i.inspect)
       orgslist.push(o[:login])
     end
-    return orgslist
-  end
-
-  def open_org(client,config)
-    mem=client.organization(config["Org"])
-    Sys.new.open_url(mem[:html_url])
-  end
-
-  def open_user_url(client,config,user,field)
-    list=self.load_people()
-    inpeople=list["orgs"].detect{|aux| aux["name"]==config["Org"]}
-    found=0
-
-    if inpeople==nil
-      list["orgs"].push({"name"=>config["Org"],"users"=>[]})
-      Sys.new.save_people("#{ENV['HOME']}/.ghedsh",list)
-      puts "Extended information has not been added yet"
-    else
-      if user.downcase.start_with?("/") and user.downcase.count("/")==2
-        sp=user.split('/')
-        exp=Regexp.new(sp[1],sp[2])
-        inuser=Sys.new.search_rexp_peoplehash(list["orgs"].detect{|aux| aux["name"]==config["Org"]}["users"],exp)
-        user.slice!(0); user=user.chop
-      else
-        inuser=[]
-        inuser.push(list["orgs"].detect{|aux| aux["name"]==config["Org"]}["users"].detect{|aux2| aux2["github"]==user})
-      end
-      if inuser==nil
-        puts "Not extended information has been added of that user."
-      else
-        if field==nil
-          inuser.each do |i|
-            i.each_value do |j|
-              if j.include?("github.com")
-                if !j.include?("https://") && !j.include?("http://")
-                  Sys.new.open_url("https://"+j)
-                else
-                  Sys.new.open_url(j)
-                end
-                found=1
-              end
-            end
-          end
-          if found==0
-            puts "No github web profile in the aditional information"
-          end
-        else
-          if inuser!=[]
-            if field.downcase.start_with?("/") and field.downcase.end_with?("/")  ##regexp
-              field=field.delete("/")
-              inuser.each do |i|
-                if i!=nil
-                  i.each_value do |j|
-                    if j.include?(field)
-                      if j.include?("https://") || j.include?("http://")
-                        Sys.new.open_url(j)
-                      end
-                    end
-                  end
-                end
-              end
-            else
-              inuser.each do |i|
-                if inuser.keys.include?(field.downcase)
-                  if inuser[field.downcase].include?("https://") or inuser[field.downcase].include?("http://")
-                    url=inuser["#{field.downcase}"]
-                  else
-                    url="http://"+inuser["#{field.downcase}"]
-                  end
-                  Sys.new.open_url(url)
-                else
-                  puts "No field found with that name"
-                end
-              end
-            end
-          else
-            puts "No field found with that name"
-          end
-        end
-      end
-    end
+    orgslist
   end
-
 end