sem 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 69ad26460c2a5f0370942054823818fd4628feb0
-  data.tar.gz: 3d66bfd1e6a4a0fc87ee9e34ac3a27795754774d
+  metadata.gz: ccd122f3ce04fc09324bb135463966fd91fe5d90
+  data.tar.gz: aff41dee6b2352c2844beb298c8a0ed5268ff5d0
 SHA512:
-  metadata.gz: 26889f21ff8805815526af5f70db424d007cf23ffec5b6978b18559a56427d4890d5baa95685545d1d110350b1407786a7a36d92f7306951529ecd13d11c011f
-  data.tar.gz: 687430ea92a6f952405e5a3a8983d301243bb58bef6fa8c58b2aa9135b20f7ee57bf36d8f8abd92f0536ba7d9928da00e6a91f8d25ecf3fa0f5551aca33cef8d
+  metadata.gz: fa93e1e6a31b3f5faf0ea12a32e1178acf2c3fa041105d403b95659b1321d75819b1862f3524fbcd64015f506a6736bf10ab50b82dab69097b85d030f2010448
+  data.tar.gz: a59bc4d8e6248700231099d8f36bac604bd7f0bfc6a15817addb1774b2b7b6082e58b7b2c784cb200a58d83785da1dffebc7279d90f77b086a679dc83ddc5d07

data/README.md

@@ -1,6 +1,7 @@
 # Semaphore CLI
 
 [![Build Status](https://semaphoreci.com/api/v1/renderedtext/cli/branches/master/badge.svg)](https://semaphoreci.com/renderedtext/cli)
+[![Gem Version](https://badge.fury.io/rb/sem.svg)](https://badge.fury.io/rb/sem)
 
 ![Semaphore logo](https://d1dkupr86d302v.cloudfront.net/assets/application_bootstrap/layout/semaphore-logo-a6d954e176b6975b511f314a0cc808dc94a8030210077e3a6e904fbe69dc5354.svg)
 
@@ -10,6 +11,22 @@ The Semaphore CLI is used to manage Semaphore projects from the command line.
 
 For more info about Semaphore see <https://www.semaphoreci.com>
 
+## Semaphore Resource Name (SRN)
+
+SRN is a way of identifying Semaphore resources. This CLI uses SRNs as arguments
+for all actions.
+
+Formats for individual resources are the following:
+
+- Organization: `organization_name`
+- Team: `organization_name/team_name`
+- Project: `organization_name/project_name`
+- Shared Configuration: `organization_name/shared_configuration_name`
+
+## Using custom API URL
+
+Create a file at `~/.sem/api_url` containing only the custom url.
+
 ## Issues
 
 For problems directly related to the CLI, [add an issue on GitHub](https://github.com/renderedtext/cli/issues/new).

data/lib/sem/api/base.rb

@@ -1,11 +1,13 @@
 module Sem
   module API
     class Base
-      def self.client
-        @client ||= begin
-          auth_token = Sem::Credentials.read
-
-          SemaphoreClient.new(auth_token)
+      class << self
+        def client
+          @client ||= SemaphoreClient.new(
+            Sem::Configuration.auth_token,
+            :api_url => Sem::Configuration.api_url,
+            :verbose => (Sem.log_level == Sem::LOG_LEVEL_TRACE)
+          )
         end
       end
     end

data/lib/sem/api/env_vars.rb

@@ -3,17 +3,19 @@ module Sem
     class EnvVars < Base
       extend Traits::AssociatedWithSharedConfig
 
-      def self.api
-        client.env_vars
-      end
+      class << self
+        def api
+          client.env_vars
+        end
 
-      def self.to_hash(env_var)
-        {
-          :id => env_var.id,
-          :name => env_var.name,
-          :encrypted? => env_var.encrypted,
-          :content => env_var.content
-        }
+        def to_hash(env_var)
+          {
+            :id => env_var.id,
+            :name => env_var.name,
+            :encrypted? => env_var.encrypted,
+            :content => env_var.content
+          }
+        end
       end
     end
   end

data/lib/sem/api/files.rb

@@ -3,16 +3,18 @@ module Sem
     class Files < Base
       extend Traits::AssociatedWithSharedConfig
 
-      def self.api
-        client.config_files
-      end
+      class << self
+        def api
+          client.config_files
+        end
 
-      def self.to_hash(files)
-        {
-          :id => files.id,
-          :name => files.path,
-          :encrypted? => files.encrypted
-        }
+        def to_hash(file)
+          {
+            :id => file.id,
+            :name => file.path,
+            :encrypted? => file.encrypted
+          }
+        end
       end
     end
   end

data/lib/sem/api/orgs.rb

@@ -1,53 +1,41 @@
 module Sem
   module API
     class Orgs < Base
-      def self.list
-        orgs = api.list
+      class << self
+        def list
+          orgs = api.list
 
-        orgs.map { |org| to_hash(org) }
-      end
-
-      def self.info(name)
-        org = api.get(name)
-
-        to_hash(org)
-      end
-
-      def self.list_teams(org_name)
-        Sem::API::Teams.list_for_org(org_name)
-      end
+          orgs.map { |org| to_hash(org) }
+        end
 
-      def self.list_users(org_name)
-        Sem::API::Users.list_for_org(org_name)
-      end
-
-      def self.list_admins(org_name)
-        admin_teams = list_teams(org_name).select { |team| team[:permission] == "admin" }
-
-        admins = admin_teams.map { |team| client.users.list_for_team(team[:id]) }.flatten
+        def info(name)
+          org = api.get(name)
 
-        admins.map { |admin| Sem::API::Users.to_hash(admin) }
-      end
+          raise Sem::Errors::ResourceNotFound.new("Organization", [name]) if org.nil?
 
-      def self.list_owners(org_name)
-        owners_team = list_teams(org_name).find { |team| team[:name] == "Owners" }
+          to_hash(org)
+        end
 
-        owners = client.users.list_for_team(owners_team[:id])
+        def list_teams(name)
+          Sem::API::Teams.list_for_org(name)
+        end
 
-        owners.map { |owner| Sem::API::Users.to_hash(owner) }
-      end
+        def list_users(name)
+          Sem::API::Users.list_for_org(name)
+        end
 
-      def self.api
-        client.orgs
-      end
+        def api
+          client.orgs
+        end
 
-      def self.to_hash(org)
-        {
-          :id => org.id,
-          :username => org.username,
-          :created_at => org.created_at,
-          :updated_at => org.updated_at
-        }
+        def to_hash(org)
+          {
+            :id => org.id,
+            :username => org.username,
+            :created_at => org.created_at,
+            :updated_at => org.updated_at
+          }
+        end
       end
     end
   end

data/lib/sem/api/projects.rb

@@ -4,29 +4,38 @@ 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(org_name, project_name)
+          info(org_name, project_name)[:id]
+        end
 
-        org_names.map { |name| list_for_org(name) }.flatten
-      end
+        def list
+          org_names = Orgs.list.map { |org| org[:username] }
 
-      def self.info(path)
-        org_name, project_name = path.split("/")
+          org_names.pmap { |name| list_for_org(name) }.flatten
+        end
 
-        list_for_org(org_name).find { |project| project[:name] == project_name }
-      end
+        def info(org_name, project_name)
+          project = api.list_for_org(org_name, :name => project_name).first
 
-      def self.api
-        client.projects
-      end
+          raise Sem::Errors::ResourceNotFound.new("Project", [org_name, project_name]) if project.nil?
+
+          to_hash(project, org_name)
+        end
+
+        def api
+          client.projects
+        end
 
-      def self.to_hash(project)
-        {
-          :id => project.id,
-          :name => project.name,
-          :created_at => project.created_at,
-          :updated_at => project.updated_at
-        }
+        def to_hash(project, org)
+          {
+            :id => project.id,
+            :name => project.name,
+            :org => org,
+            :created_at => project.created_at,
+            :updated_at => project.updated_at
+          }
+        end
       end
     end
   end

data/lib/sem/api/shared_configs.rb

@@ -3,71 +3,99 @@ module Sem
     class SharedConfigs < Base
       extend Traits::AssociatedWithTeam
       extend Traits::AssociatedWithOrg
+      extend Traits::AssociatedWithProject
 
-      def self.list
-        org_names = Orgs.list.map { |org| org[:username] }
+      class << self
+        def name_to_id(org_name, shared_config_name)
+          info(org_name, shared_config_name)[:id]
+        end
 
-        org_names.map { |name| list_for_org(name) }.flatten
-      end
+        def list
+          org_names = Orgs.list.map { |org| org[:username] }
 
-      def self.info(path)
-        org_name, config_name = path.split("/")
+          org_names.pmap { |name| list_for_org(name) }.flatten
+        end
 
-        list_for_org(org_name).find { |config| config[:name] == config_name }
-      end
+        def info(org_name, shared_config_name)
+          selected_shared_config = list_for_org(org_name).find do |shared_config|
+            shared_config[:name] == shared_config_name
+          end
 
-      def self.create(org_name, args)
-        config = api.create_for_org(org_name, args)
+          if selected_shared_config.nil?
+            raise Sem::Errors::ResourceNotFound.new("Shared Configuration", [org_name, shared_config_name])
+          end
 
-        to_hash(config)
-      end
+          selected_shared_config
+        end
 
-      def self.update(path, args)
-        shared_config = info(path)
+        def create(org_name, args)
+          shared_config = api.create_for_org(org_name, args)
 
-        shared_config = api.update(shared_config[:id], args)
+          if shared_config.nil?
+            raise Sem::Errors::ResourceNotCreated.new("Shared Configuration", [org_name, args[:name]])
+          end
 
-        to_hash(shared_config)
-      end
+          to_hash(shared_config, org_name)
+        end
 
-      def self.delete(path)
-        id = info(path)[:id]
+        def update(org_name, shared_config_name, args)
+          shared_config = info(org_name, shared_config_name)
 
-        api.delete(id)
-      end
+          shared_config = api.update(shared_config[:id], args)
 
-      def self.list_env_vars(path)
-        Sem::API::EnvVars.list_for_shared_config(path)
-      end
+          if shared_config.nil?
+            raise Sem::Errors::ResourceNotUpdated.new("Shared Configuration", [org_name, shared_config_name])
+          end
 
-      def self.list_files(path)
-        Sem::API::Files.list_for_shared_config(path)
-      end
+          to_hash(shared_config, org_name)
+        end
 
-      def self.api
-        client.shared_configs
-      end
+        def delete(org_name, shared_config_name)
+          shared_config = info(org_name, shared_config_name)
 
-      def self.to_hash(config)
-        {
-          :id => config.id,
-          :name => config.name,
-          :config_files => config_files_count(config.id),
-          :env_vars => env_vars_count(config.id),
-          :created_at => config.created_at,
-          :updated_at => config.updated_at
-        }
-      end
+          api.delete!(shared_config[:id])
+        rescue SemaphoreClient::Exceptions::RequestFailed
+          raise Sem::Errors::ResourceNotDeleted.new("Shared Configuration", [org_name, shared_config_name])
+        end
+
+        def list_env_vars(org_name, shared_config_name)
+          Sem::API::EnvVars.list_for_shared_config(org_name, shared_config_name)
+        end
+
+        def list_files(org_name, shared_config_name)
+          Sem::API::Files.list_for_shared_config(org_name, shared_config_name)
+        end
+
+        def api
+          client.shared_configs
+        end
+
+        def to_hash(shared_config, org)
+          network_actions = [:config_files_count, :env_vars_count]
+
+          config_files, env_vars = network_actions.pmap do |action|
+            send(action, shared_config.id)
+          end
+
+          {
+            :id => shared_config.id,
+            :name => shared_config.name,
+            :org => org,
+            :config_files => config_files,
+            :env_vars => env_vars,
+            :created_at => shared_config.created_at,
+            :updated_at => shared_config.updated_at
+          }
+        end
 
-      class << self
         private
 
-        def config_files_count(config_id)
-          client.config_files.list_for_shared_config(config_id).to_a.size
+        def config_files_count(shared_config_id)
+          client.config_files.list_for_shared_config(shared_config_id).to_a.size
         end
 
-        def env_vars_count(config_id)
-          client.env_vars.list_for_shared_config(config_id).to_a.size
+        def env_vars_count(shared_config_id)
+          client.env_vars.list_for_shared_config(shared_config_id).to_a.size
         end
       end
     end

data/lib/sem/api/teams.rb

@@ -3,51 +3,66 @@ module Sem
     class Teams < Base
       extend Traits::AssociatedWithOrg
 
-      def self.list
-        org_names = Sem::API::Orgs.list.map { |org| org[:username] }
+      class << self
+        def name_to_id(org_name, team_name)
+          info(org_name, team_name)[:id]
+        end
 
-        org_names.map { |name| list_for_org(name) }.flatten
-      end
+        def list
+          org_names = Sem::API::Orgs.list.map { |org| org[:username] }
 
-      def self.info(path)
-        org_name, team_name = path.split("/")
+          org_names.pmap { |name| list_for_org(name) }.flatten
+        end
 
-        list_for_org(org_name).find { |team| team[:name] == team_name }
-      end
+        def info(org_name, team_name)
+          selected_team = list_for_org(org_name).find { |team| team[:name] == team_name }
 
-      def self.create(org_name, args)
-        team = api.create_for_org(org_name, args)
+          raise Sem::Errors::ResourceNotFound.new("Team", [org_name, team_name]) if selected_team.nil?
 
-        to_hash(team)
-      end
+          selected_team
+        end
 
-      def self.update(path, args)
-        team = info(path)
+        def create(org_name, args)
+          team = api.create_for_org(org_name, args)
 
-        team = api.update(team[:id], args)
+          raise Sem::Errors::ResourceNotCreated.new("Team", [org_name, args[:name]]) if team.nil?
 
-        to_hash(team)
-      end
+          to_hash(team, org_name)
+        end
 
-      def self.delete(path)
-        id = info(path)[:id]
+        def update(org_name, team_name, args)
+          team = info(org_name, team_name)
 
-        api.delete(id)
-      end
+          team = api.update(team[:id], args)
 
-      def self.api
-        client.teams
-      end
+          raise Sem::Errors::ResourceNotUpdated.new("Team", [org_name, team_name]) if team.nil?
+
+          to_hash(team, org_name)
+        end
+
+        def delete(org_name, team_name)
+          team = info(org_name, team_name)
+
+          api.delete!(team[:id])
+        rescue SemaphoreClient::Exceptions::RequestFailed
+          raise Sem::Errors::ResourceNotDeleted.new("Team", [org_name, team_name])
+        end
+
+        def api
+          client.teams
+        end
 
-      def self.to_hash(team)
-        {
-          :id => team.id,
-          :name => team.name,
-          :permission => team.permission,
-          :members => client.users.list_for_team(team.id).count.to_s,
-          :created_at => team.created_at,
-          :updated_at => team.updated_at
-        }
+        def to_hash(team, org)
+          {
+            :id => team.id,
+            :name => team.name,
+            :org => org,
+            :permission => team.permission,
+            :members => client.users.list_for_team(team.id).to_a.size.to_s,
+            :created_at => team.created_at,
+            :updated_at => team.updated_at
+          }
+        end
       end
     end
   end

data/lib/sem/api/traits/associated_with_org.rb

@@ -2,10 +2,14 @@ module Sem
   module API
     module Traits
       module AssociatedWithOrg
+        PAGES_PER_CALL = 3
+
         def list_for_org(org_name)
-          instances = api.list_for_org(org_name)
+          pages = Sem::Pagination.pages(PAGES_PER_CALL) do |page_index|
+            api.list_for_org(org_name, :page => page_index).to_a
+          end
 
-          instances.map { |instance| to_hash(instance) }
+          pages.flatten.pmap { |instance| to_hash(instance, org_name) }
         end
       end
     end

data/lib/sem/api/traits/associated_with_project.rb

@@ -0,0 +1,29 @@
+module Sem
+  module API
+    module Traits
+      module AssociatedWithProject
+        def list_for_project(org_name, project_name)
+          project = Projects.info(org_name, project_name)
+
+          instances = api.list_for_project(project[:id]).to_a
+
+          instances.map { |instance| to_hash(instance, org_name) }
+        end
+
+        def add_to_project(org_name, project_name, instance_name)
+          instance = info(org_name, instance_name)
+          project = Projects.info(org_name, project_name)
+
+          api.attach_to_project(instance[:id], project[:id])
+        end
+
+        def remove_from_project(org_name, project_name, instance_name)
+          instance = info(org_name, instance_name)
+          project = Projects.info(org_name, project_name)
+
+          api.detach_from_project(instance[:id], project[:id])
+        end
+      end
+    end
+  end
+end

data/lib/sem/api/traits/associated_with_shared_config.rb

@@ -2,25 +2,27 @@ module Sem
   module API
     module Traits
       module AssociatedWithSharedConfig
-        def list_for_shared_config(shared_config_path)
-          shared_config = SharedConfigs.info(shared_config_path)
+        def list_for_shared_config(org_name, shared_config_name)
+          shared_config = SharedConfigs.info(org_name, shared_config_name)
 
-          instances = api.list_for_shared_config(shared_config[:id])
+          instances = api.list_for_shared_config(shared_config[:id]).to_a
 
           instances.map { |instance| to_hash(instance) }
         end
 
-        def add_to_shared_config(shared_config_path, params)
-          shared_config = SharedConfigs.info(shared_config_path)
+        def add_to_shared_config(org_name, shared_config_name, params)
+          shared_config = SharedConfigs.info(org_name, shared_config_name)
 
           api.create_for_shared_config(shared_config[:id], params)
         end
 
-        def remove_from_shared_config(shared_config_path, instance_name)
-          instances = list_for_shared_config(shared_config_path)
+        def remove_from_shared_config(org_name, shared_config_name, instance_name)
+          instances = list_for_shared_config(org_name, shared_config_name)
 
           selected_instance = instances.find { |instance| instance[:name] == instance_name }
 
+          raise Sem::Errors::ResourceNotFound.new("Resource", [org_name, instance_name]) if selected_instance.nil?
+
           api.delete(selected_instance[:id])
         end
       end

data/lib/sem/api/traits/associated_with_team.rb

@@ -2,26 +2,26 @@ module Sem
   module API
     module Traits
       module AssociatedWithTeam
-        def list_for_team(team_path)
-          team = Teams.info(team_path)
+        def list_for_team(org_name, team_name)
+          team_id = Teams.name_to_id(org_name, team_name)
 
-          instances = api.list_for_team(team[:id])
+          instances = api.list_for_team(team_id).to_a
 
-          instances.map { |instance| to_hash(instance) }
+          instances.map { |instance| to_hash(instance, org_name) }
         end
 
-        def add_to_team(team_path, instance_path)
-          instance = info(instance_path)
-          team = Teams.info(team_path)
+        def add_to_team(org_name, team_name, instance_name)
+          instance_id = name_to_id(org_name, instance_name)
+          team_id = Teams.name_to_id(org_name, team_name)
 
-          api.attach_to_team(instance[:id], team[:id])
+          api.attach_to_team(instance_id, team_id)
         end
 
-        def remove_from_team(team_path, instance_path)
-          instance = info(instance_path)
-          team = Teams.info(team_path)
+        def remove_from_team(org_name, team_name, instance_name)
+          instance_id = name_to_id(org_name, instance_name)
+          team_id = Teams.name_to_id(org_name, team_name)
 
-          api.detach_from_team(instance[:id], team[:id])
+          api.detach_from_team(instance_id, team_id)
         end
       end
     end

data/lib/sem/api/traits.rb

@@ -4,6 +4,7 @@ module Sem
       require_relative "traits/associated_with_org"
       require_relative "traits/associated_with_team"
       require_relative "traits/associated_with_shared_config"
+      require_relative "traits/associated_with_project"
     end
   end
 end