sem 0.1.4 → 0.2.0

data/lib/sem/api/users.rb

@@ -4,22 +4,40 @@ module Sem
       extend Traits::AssociatedWithOrg
       extend Traits::AssociatedWithTeam
 
-      def self.list
-        org_names = Orgs.list.map { |org| org[:username] }
+      class << self
+        def name_to_id(_, name)
+          name
+        end
 
-        org_names.map { |name| list_for_org(name) }.flatten
-      end
+        def list
+          org_names = Orgs.list.map { |org| org[:username] }
 
-      def self.info(name)
-        list.find { |user| user[:id] == name }
-      end
+          org_names.pmap { |name| list_for_org(name) }.flatten
+        end
 
-      def self.api
-        client.users
-      end
+        def info(*args)
+          if args.count == 2
+            org_name, user_name = args
+            users = list_for_org(org_name)
+          else
+            user_name = args.first
+            users = list
+          end
+
+          selected_user = users.find { |user| user[:id] == user_name }
+
+          raise Sem::Errors::ResourceNotFound.new("User", [user_name]) if selected_user.nil?
+
+          selected_user
+        end
+
+        def api
+          client.users
+        end
 
-      def self.to_hash(user)
-        { :id => user.username }
+        def to_hash(user, _ = nil)
+          { :id => user.username }
+        end
       end
     end
   end

data/lib/sem/api.rb

@@ -2,7 +2,6 @@ module Sem
   module API
     require_relative "api/traits"
     require_relative "api/base"
-    require_relative "api/users_with_permissions"
     require_relative "api/orgs"
     require_relative "api/users"
     require_relative "api/projects"

data/lib/sem/cli/orgs.rb

@@ -8,38 +8,21 @@ class Sem::CLI::Orgs < Dracula
   end
 
   desc "info", "shows detailed information about an organization"
-  def info(org_name)
-    org = Sem::API::Orgs.info(org_name)
+  def info(org)
+    org_name = Sem::SRN.parse_org(org).first
 
-    Sem::Views::Orgs.info(org)
+    org_instance = Sem::API::Orgs.info(org_name).to_h
+
+    Sem::Views::Orgs.info(org_instance)
   end
 
   desc "members", "list members of an organization"
-  option :with_2fa,
-         :default => false,
-         :type => :boolean,
-         :desc => "list members that have two factor authentication enabled"
-  option :admins,
-         :default => false,
-         :type => :boolean,
-         :desc => "list only admins in the organization"
-  option :owners,
-         :default => false,
-         :type => :boolean,
-         :desc => "list only owners in the organization"
-  def members(org_name)
-    raise "Not Implemented" if options[:with_2fa]
-
-    users =
-      if options[:owners]
-        Sem::API::UsersWithPermissions.list_owners_for_org(org_name)
-      elsif options[:admins]
-        Sem::API::UsersWithPermissions.list_admins_for_org(org_name)
-      else
-        Sem::API::UsersWithPermissions.list_for_org(org_name)
-      end
-
-    Sem::Views::UsersWithPermissions.list(users)
+  def members(org)
+    org_name = Sem::SRN.parse_org(org).first
+
+    users = Sem::API::Users.list_for_org(org_name)
+
+    Sem::Views::Users.list(users)
   end
 
 end

data/lib/sem/cli/projects.rb

@@ -8,10 +8,53 @@ class Sem::CLI::Projects < Dracula
   end
 
   desc "info", "shows detailed information about a project"
-  def info(project_path)
-    project = Sem::API::Projects.info(project_path)
+  def info(project)
+    org_name, project_name = Sem::SRN.parse_project(project)
 
-    Sem::Views::Projects.info(project)
+    project_instance = Sem::API::Projects.info(org_name, project_name).to_h
+
+    Sem::Views::Projects.info(project_instance)
+  end
+
+  class SharedConfigs < Dracula
+    desc "list", "list shared configurations on a project"
+    def list(project)
+      org_name, project_name = Sem::SRN.parse_project(project)
+
+      configs = Sem::API::SharedConfigs.list_for_project(org_name, project_name)
+
+      Sem::Views::SharedConfigs.list(configs)
+    end
+
+    desc "add", "attach a shared configuration to a project"
+    def add(project, shared_config)
+      project_org_name, project_name = Sem::SRN.parse_project(project)
+      shared_config_org_name, shared_config_name = Sem::SRN.parse_shared_config(shared_config)
+
+      if project_org_name != shared_config_org_name
+        abort Sem::Views::Projects.org_names_not_matching("project", "shared configuration", project, shared_config)
+      end
+
+      Sem::API::SharedConfigs.add_to_project(project_org_name, project_name, shared_config_name)
+
+      puts "Shared Configuration #{project_org_name}/#{shared_config_name} added to the project."
+    end
+
+    desc "remove", "removes a shared configuration from the project"
+    def remove(project, shared_config)
+      project_org_name, project_name = Sem::SRN.parse_project(project)
+      shared_config_org_name, shared_config_name = Sem::SRN.parse_shared_config(shared_config)
+
+      if project_org_name != shared_config_org_name
+        abort Sem::Views::Projects.org_names_not_matching("project", "shared configuration", project, shared_config)
+      end
+
+      Sem::API::SharedConfigs.remove_from_project(project_org_name, project_name, shared_config_name)
+
+      puts "Shared Configuration #{project_org_name}/#{shared_config_name} removed from the project."
+    end
   end
 
+  register "shared-configs", "manage shared configurations", SharedConfigs
+
 end

data/lib/sem/cli/shared_configs.rb

@@ -8,67 +8,89 @@ class Sem::CLI::SharedConfigs < Dracula
   end
 
   desc "info", "show information about a shared configuration"
-  def info(path)
-    shared_config = Sem::API::SharedConfigs.info(path)
+  def info(shared_config)
+    org_name, shared_config_name = Sem::SRN.parse_shared_config(shared_config)
 
-    Sem::Views::SharedConfigs.info(shared_config)
+    shared_config_instance = Sem::API::SharedConfigs.info(org_name, shared_config_name).to_h
+
+    Sem::Views::SharedConfigs.info(shared_config_instance)
   end
 
   desc "create", "create a new shared configuration"
-  def create(path)
-    org_name, shared_config_name = path.split("/")
+  def create(shared_config)
+    org_name, shared_config_name = Sem::SRN.parse_shared_config(shared_config)
 
-    shared_config = Sem::API::SharedConfigs.create(org_name, :name => shared_config_name)
+    shared_config_instance = Sem::API::SharedConfigs.create(org_name, :name => shared_config_name)
 
-    Sem::Views::SharedConfigs.info(shared_config)
+    Sem::Views::SharedConfigs.info(shared_config_instance)
   end
 
   desc "rename", "rename a shared configuration"
-  def rename(old_path, new_path)
-    _, name = new_path.split("/")
+  def rename(old_shared_config, new_shared_config)
+    old_org_name, old_shared_config_name = Sem::SRN.parse_shared_config(old_shared_config)
+    new_org_name, new_shared_config_name = Sem::SRN.parse_shared_config(new_shared_config)
+
+    if old_org_name != new_org_name
+      abort Sem::Views::SharedConfigs.org_names_not_matching("old shared configuration name",
+                                                             "new shared configuration name",
+                                                             old_shared_config,
+                                                             new_shared_config)
+    end
 
-    shared_config = Sem::API::SharedConfigs.update(old_path, :name => name)
+    shared_config_instance = Sem::API::SharedConfigs.update(old_org_name,
+                                                            old_shared_config_name,
+                                                            :name => new_shared_config_name)
 
-    Sem::Views::SharedConfigs.info(shared_config)
+    Sem::Views::SharedConfigs.info(shared_config_instance)
   end
 
   desc "delete", "removes a shared configuration from your organization"
-  def delete(path)
-    Sem::API::SharedConfigs.delete(path)
+  def delete(shared_config)
+    org_name, shared_config_name = Sem::SRN.parse_shared_config(shared_config)
+
+    Sem::API::SharedConfigs.delete(org_name, shared_config_name)
 
-    puts "Deleted shared configuration #{path}"
+    puts "Deleted shared configuration #{org_name}/#{shared_config_name}"
   end
 
   class Files < Dracula
     desc "list", "list files in the shared configuration"
-    def list(shared_config_path)
-      files = Sem::API::SharedConfigs.list_files(shared_config_path)
+    def list(shared_config)
+      org_name, shared_config_name = Sem::SRN.parse_shared_config(shared_config)
+
+      files = Sem::API::SharedConfigs.list_files(org_name, shared_config_name)
 
       Sem::Views::Files.list(files)
     end
 
     desc "add", "add a file to the shared configuration"
     option :file, :aliases => "f", :desc => "File to upload", :required => true
-    def add(shared_config_path, file_name)
+    def add(shared_config, file)
+      org_name, shared_config_name = Sem::SRN.parse_shared_config(shared_config)
+
       content = File.read(options[:file])
 
-      Sem::API::Files.add_to_shared_config(shared_config_path, :path => file_name, :content => content)
+      Sem::API::Files.add_to_shared_config(org_name, shared_config_name, :path => file, :content => content)
 
-      puts "Added #{file_name} to #{shared_config_path}"
+      puts "Added #{file} to #{org_name}/#{shared_config_name}"
     end
 
     desc "remove", "remove a file from the shared configuration"
-    def remove(shared_config_path, file_name)
-      Sem::API::Files.remove_from_shared_config(shared_config_path, file_name)
+    def remove(shared_config, file)
+      org_name, shared_config_name = Sem::SRN.parse_shared_config(shared_config)
 
-      puts "Removed #{file_name} from #{shared_config_path}"
+      Sem::API::Files.remove_from_shared_config(org_name, shared_config_name, file)
+
+      puts "Removed #{file} from #{org_name}/#{shared_config_name}"
     end
   end
 
   class EnvVars < Dracula
     desc "list", "list environment variables in the shared configuration"
-    def list(shared_config_path)
-      env_vars = Sem::API::SharedConfigs.list_env_vars(shared_config_path)
+    def list(shared_config)
+      org_name, shared_config_name = Sem::SRN.parse_shared_config(shared_config)
+
+      env_vars = Sem::API::SharedConfigs.list_env_vars(org_name, shared_config_name)
 
       Sem::Views::EnvVars.list(env_vars)
     end
@@ -76,19 +98,24 @@ class Sem::CLI::SharedConfigs < Dracula
     desc "add", "add an environment variable to the shared configuration"
     option :name, :aliases => "-n", :desc => "Name of the variable", :required => true
     option :content, :aliases => "-c", :desc => "Content of the variable", :required => true
-    def add(shared_config_path)
-      Sem::API::EnvVars.add_to_shared_config(shared_config_path,
+    def add(shared_config)
+      org_name, shared_config_name = Sem::SRN.parse_shared_config(shared_config)
+
+      Sem::API::EnvVars.add_to_shared_config(org_name,
+                                             shared_config_name,
                                              :name => options[:name],
                                              :content => options[:content])
 
-      puts "Added #{options[:name]} to #{shared_config_path}"
+      puts "Added #{options[:name]} to #{org_name}/#{shared_config_name}"
     end
 
     desc "remove", "remove an environment variable from the shared configuration"
-    def remove(shared_config_path, env_var_name)
-      Sem::API::EnvVars.remove_from_shared_config(shared_config_path, env_var_name)
+    def remove(shared_config, env_var)
+      org_name, shared_config_name = Sem::SRN.parse_shared_config(shared_config)
+
+      Sem::API::EnvVars.remove_from_shared_config(org_name, shared_config_name, env_var)
 
-      puts "Removed #{env_var_name} from #{shared_config_path}"
+      puts "Removed #{env_var} from #{org_name}/#{shared_config_name}"
     end
   end
 

data/lib/sem/cli/teams.rb

@@ -8,115 +8,171 @@ class Sem::CLI::Teams < Dracula
   end
 
   desc "info", "show information about a team"
-  def info(name)
-    team = Sem::API::Teams.info(name)
+  def info(team)
+    org_name, team_name = Sem::SRN.parse_team(team)
 
-    Sem::Views::Teams.info(team)
+    team_instance = Sem::API::Teams.info(org_name, team_name).to_h
+
+    Sem::Views::Teams.info(team_instance)
   end
 
   desc "create", "create a new team"
   option :permission, :default => "read",
                       :aliases => "-p",
                       :desc => "Permission level of the team in the organization"
-  def create(name)
-    org_name, team_name = name.split("/")
+  def create(team)
+    org_name, team_name = Sem::SRN.parse_team(team)
 
-    team = Sem::API::Teams.create(org_name,
-                                  :name => team_name,
-                                  :permission => options[:permission])
+    team_instance = Sem::API::Teams.create(org_name,
+                                           :name => team_name,
+                                           :permission => options[:permission])
 
-    Sem::Views::Teams.info(team)
+    Sem::Views::Teams.info(team_instance)
   end
 
   desc "rename", "change the name of the team"
-  def rename(old_name, new_name)
-    _, name = new_name.split("/")
+  def rename(old_team, new_team)
+    old_org_name, old_team_name = Sem::SRN.parse_team(old_team)
+    new_org_name, new_team_name = Sem::SRN.parse_team(new_team)
+
+    if old_org_name != new_org_name
+      abort Sem::Views::Teams.org_names_not_matching("old team name", "new team name", old_team, new_team)
+    end
 
-    team = Sem::API::Teams.update(old_name, :name => name)
+    team_instance = Sem::API::Teams.update(old_org_name, old_team_name, :name => new_team_name)
 
-    Sem::Views::Teams.info(team)
+    Sem::Views::Teams.info(team_instance)
   end
 
   desc "set-permission", "set the permission level of the team"
-  def set_permission(team_name, permission)
-    team = Sem::API::Teams.update(team_name, :permission => permission)
+  def set_permission(team, permission)
+    unless ["read", "write", "admin"].include?(permission)
+      abort "Permission \"#{permission}\" doesn't exist.\n" \
+        "Choose one of the following: read, write, admin."
+    end
+
+    org_name, team_name = Sem::SRN.parse_team(team)
+
+    team_instance = Sem::API::Teams.update(org_name, team_name, :permission => permission)
 
-    Sem::Views::Teams.info(team)
+    Sem::Views::Teams.info(team_instance)
   end
 
   desc "delete", "removes a team from your organization"
-  def delete(name)
-    Sem::API::Teams.delete(name)
+  def delete(team)
+    org_name, team_name = Sem::SRN.parse_team(team)
 
-    puts "Deleted team #{name}"
+    Sem::API::Teams.delete(org_name, team_name)
+
+    puts "Deleted team #{org_name}/#{team_name}"
   end
 
   class Members < Dracula
     desc "list", "lists members of the team"
-    def list(team_name)
-      members = Sem::API::Users.list_for_team(team_name)
+    def list(team)
+      org_name, team_name = Sem::SRN.parse_team(team)
+
+      members = Sem::API::Users.list_for_team(org_name, team_name)
 
-      Sem::Views::Users.list(members)
+      Sem::Views::Teams.list_members(team, members)
     end
 
     desc "add", "add a user to the team"
-    def add(team_name, username)
-      Sem::API::Users.add_to_team(team_name, username)
+    def add(team, user)
+      org_name, team_name = Sem::SRN.parse_team(team)
+      user_name = Sem::SRN.parse_user(user).first
+
+      Sem::API::Users.add_to_team(org_name, team_name, user_name)
 
-      puts "User #{username} added to the team."
+      puts "User #{user_name} added to the team."
     end
 
     desc "remove", "removes a user from the team"
-    def remove(team_name, username)
-      Sem::API::Users.remove_from_team(team_name, username)
+    def remove(team, user)
+      org_name, team_name = Sem::SRN.parse_team(team)
+      user_name = Sem::SRN.parse_user(user).first
 
-      puts "User #{username} removed from the team."
+      Sem::API::Users.remove_from_team(org_name, team_name, user_name)
+
+      puts "User #{user_name} removed from the team."
     end
   end
 
   class Projects < Dracula
     desc "list", "lists projects in a team"
-    def list(team_name)
-      projects = Sem::API::Projects.list_for_team(team_name)
+    def list(team)
+      org_name, team_name = Sem::SRN.parse_team(team)
+
+      projects = Sem::API::Projects.list_for_team(org_name, team_name)
 
       Sem::Views::Projects.list(projects)
     end
 
     desc "add", "add a project to a team"
-    def add(team_name, project_name)
-      Sem::API::Projects.add_to_team(team_name, project_name)
+    def add(team, project)
+      team_org_name, team_name = Sem::SRN.parse_team(team)
+      project_org_name, project_name = Sem::SRN.parse_project(project)
 
-      puts "Project #{project_name} added to the team."
+      if team_org_name != project_org_name
+        abort Sem::Views::Teams.org_names_not_matching("team", "project", team, project)
+      end
+
+      Sem::API::Projects.add_to_team(team_org_name, team_name, project_name)
+
+      puts "Project #{team_org_name}/#{project_name} added to the team."
     end
 
     desc "remove", "removes a project from the team"
-    def remove(team_name, project_name)
-      Sem::API::Projects.remove_from_team(team_name, project_name)
+    def remove(team, project)
+      team_org_name, team_name = Sem::SRN.parse_team(team)
+      project_org_name, project_name = Sem::SRN.parse_project(project)
+
+      if team_org_name != project_org_name
+        abort Sem::Views::Teams.org_names_not_matching("team", "project", team, project)
+      end
 
-      puts "Project #{project_name} removed from the team."
+      Sem::API::Projects.remove_from_team(team_org_name, team_name, project_name)
+
+      puts "Project #{team_org_name}/#{project_name} removed from the team."
     end
   end
 
   class SharedConfigs < Dracula
     desc "list", "list shared configurations in a team"
-    def list(team_name)
-      configs = Sem::API::SharedConfigs.list_for_team(team_name)
+    def list(team)
+      org_name, team_name = Sem::SRN.parse_team(team)
+
+      configs = Sem::API::SharedConfigs.list_for_team(org_name, team_name)
 
       Sem::Views::SharedConfigs.list(configs)
     end
 
     desc "add", "add a shared configuration to a team"
-    def add(team_name, shared_config_name)
-      Sem::API::SharedConfigs.add_to_team(team_name, shared_config_name)
+    def add(team, shared_config)
+      team_org_name, team_name = Sem::SRN.parse_team(team)
+      shared_config_org_name, shared_config_name = Sem::SRN.parse_shared_config(shared_config)
 
-      puts "Shared Configuration #{shared_config_name} added to the team."
+      if team_org_name != shared_config_org_name
+        abort Sem::Views::Teams.org_names_not_matching("team", "shared configuration", team, shared_config)
+      end
+
+      Sem::API::SharedConfigs.add_to_team(team_org_name, team_name, shared_config_name)
+
+      puts "Shared Configuration #{team_org_name}/#{shared_config_name} added to the team."
     end
 
-    desc "remove", "removes a project from the team"
-    def remove(team_name, shared_config_name)
-      Sem::API::SharedConfigs.remove_from_team(team_name, shared_config_name)
+    desc "remove", "removes a shared Configuration from the team"
+    def remove(team, shared_config)
+      team_org_name, team_name = Sem::SRN.parse_team(team)
+      shared_config_org_name, shared_config_name = Sem::SRN.parse_shared_config(shared_config)
+
+      if team_org_name != shared_config_org_name
+        abort Sem::Views::Teams.org_names_not_matching("team", "shared configuration", team, shared_config)
+      end
+
+      Sem::API::SharedConfigs.remove_from_team(team_org_name, team_name, shared_config_name)
 
-      puts "Shared Configuration #{shared_config_name} removed from the team."
+      puts "Shared Configuration #{team_org_name}/#{shared_config_name} removed from the team."
     end
   end
 

data/lib/sem/cli.rb

@@ -7,11 +7,28 @@ module Sem
     require_relative "cli/teams"
     require_relative "cli/shared_configs"
 
-    desc "login", "log in to semaphore from the command line"
-    def login(auth_token)
-      Sem::Credentials.write(auth_token)
+    desc "login", "Log in to semaphore from the command line"
+    option :auth_token, :required => true
+    long_desc <<-DESC
+You can find your auth_token on the bottom of the users settings page https://semaphoreci.com/users/edit.
+DESC
+    def login
+      auth_token = options[:auth_token]
 
-      puts "Your credentials have been saved to #{Sem::Credentials::PATH}"
+      if Sem::Configuration.valid_auth_token?(auth_token)
+        Sem::Configuration.export_auth_token(auth_token)
+
+        puts "Your credentials have been saved to #{Sem::Configuration::CREDENTIALS_PATH}."
+      else
+        abort "[ERROR] Token is invalid!"
+      end
+    end
+
+    desc "logout", "Log out from semaphore"
+    def logout
+      Sem::Configuration.delete_auth_token
+
+      puts "Loged out."
     end
 
     register "orgs", "manage organizations", Sem::CLI::Orgs

data/lib/sem/configuration.rb

@@ -0,0 +1,48 @@
+module Sem
+  class Configuration
+    CREDENTIALS_PATH = File.expand_path("~/.sem/credentials").freeze
+    API_URL_PATH = File.expand_path("~/.sem/api_url").freeze
+
+    DEFAULT_API_URL = "https://api.semaphoreci.com".freeze
+
+    class << self
+      def valid_auth_token?(auth_token)
+        client = SemaphoreClient.new(
+          auth_token,
+          :api_url => api_url,
+          :verbose => (Sem.log_level == Sem::LOG_LEVEL_TRACE)
+        )
+
+        client.orgs.list!
+
+        true
+      rescue SemaphoreClient::Exceptions::RequestFailed
+        false
+      end
+
+      def export_auth_token(auth_token)
+        dirname = File.dirname(CREDENTIALS_PATH)
+        FileUtils.mkdir_p(dirname)
+
+        File.write(CREDENTIALS_PATH, auth_token)
+        File.chmod(0o0600, CREDENTIALS_PATH)
+      end
+
+      def delete_auth_token
+        FileUtils.rm_f(CREDENTIALS_PATH)
+      end
+
+      def auth_token
+        raise Sem::Errors::Auth::NoCredentials unless File.file?(CREDENTIALS_PATH)
+
+        File.read(CREDENTIALS_PATH).strip
+      end
+
+      def api_url
+        return DEFAULT_API_URL unless File.file?(API_URL_PATH)
+
+        File.read(API_URL_PATH).strip
+      end
+    end
+  end
+end

data/lib/sem/errors.rb

@@ -1,6 +1,39 @@
 module Sem::Errors
   Base = Class.new(StandardError)
 
+  InvalidSRN = Class.new(StandardError)
+
+  class ResourceException < Base
+    def initialize(resource, path)
+      @resource = resource
+      @path = path
+    end
+  end
+
+  class ResourceNotFound < ResourceException
+    def message
+      "[ERROR] #{@resource} lookup failed\n\n#{@resource} #{@path.join("/")} not found."
+    end
+  end
+
+  class ResourceNotCreated < ResourceException
+    def message
+      "[ERROR] #{@resource} creation failed\n\n#{@resource} #{@path.join("/")} not created."
+    end
+  end
+
+  class ResourceNotUpdated < ResourceException
+    def message
+      "[ERROR] #{@resource} update failed\n\n#{@resource} #{@path.join("/")} not updated."
+    end
+  end
+
+  class ResourceNotDeleted < ResourceException
+    def message
+      "[ERROR] #{@resource} deletion failed\n\n#{@resource} #{@path.join("/")} not deleted."
+    end
+  end
+
   module Auth
     NoCredentials = Class.new(Sem::Errors::Base)
     InvalidCredentials = Class.new(Sem::Errors::Base)