sem 0.2.3 → 0.2.4

data/lib/sem/api/shared_configs.rb

@@ -1,103 +0,0 @@
-module Sem
-  module API
-    class SharedConfigs < Base
-      extend Traits::AssociatedWithTeam
-      extend Traits::AssociatedWithOrg
-      extend Traits::AssociatedWithProject
-
-      class << self
-        def name_to_id(org_name, shared_config_name)
-          info(org_name, shared_config_name)[:id]
-        end
-
-        def list
-          org_names = Orgs.list.map { |org| org[:username] }
-
-          org_names.to_a.pmap { |name| list_for_org(name) }.flatten
-        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
-
-          if selected_shared_config.nil?
-            raise Sem::Errors::ResourceNotFound.new("Shared Configuration", [org_name, shared_config_name])
-          end
-
-          selected_shared_config
-        end
-
-        def create(org_name, args)
-          shared_config = api.create_for_org(org_name, args)
-
-          if shared_config.nil?
-            raise Sem::Errors::ResourceNotCreated.new("Shared Configuration", [org_name, args[:name]])
-          end
-
-          to_hash(shared_config, org_name)
-        end
-
-        def update(org_name, shared_config_name, args)
-          shared_config = info(org_name, shared_config_name)
-
-          shared_config = api.update(shared_config[:id], args)
-
-          if shared_config.nil?
-            raise Sem::Errors::ResourceNotUpdated.new("Shared Configuration", [org_name, shared_config_name])
-          end
-
-          to_hash(shared_config, org_name)
-        end
-
-        def delete(org_name, shared_config_name)
-          shared_config = info(org_name, shared_config_name)
-
-          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
-
-        private
-
-        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(shared_config_id)
-          client.env_vars.list_for_shared_config(shared_config_id).to_a.size
-        end
-      end
-    end
-  end
-end

data/lib/sem/api/teams.rb

@@ -1,69 +0,0 @@
-module Sem
-  module API
-    class Teams < Base
-      extend Traits::AssociatedWithOrg
-
-      class << self
-        def name_to_id(org_name, team_name)
-          info(org_name, team_name)[:id]
-        end
-
-        def list
-          org_names = Sem::API::Orgs.list.map { |org| org[:username] }
-
-          org_names.to_a.pmap { |name| list_for_org(name) }.flatten
-        end
-
-        def info(org_name, team_name)
-          selected_team = list_for_org(org_name).find { |team| team[:name] == team_name }
-
-          raise Sem::Errors::ResourceNotFound.new("Team", [org_name, team_name]) if selected_team.nil?
-
-          selected_team
-        end
-
-        def create(org_name, args)
-          team = api.create_for_org(org_name, args)
-
-          raise Sem::Errors::ResourceNotCreated.new("Team", [org_name, args[:name]]) if team.nil?
-
-          to_hash(team, org_name)
-        end
-
-        def update(org_name, team_name, args)
-          team = info(org_name, team_name)
-
-          team = api.update(team[:id], args)
-
-          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 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
-end

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

@@ -1,17 +0,0 @@
-module Sem
-  module API
-    module Traits
-      module AssociatedWithOrg
-        PAGES_PER_CALL = 3
-
-        def 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
-
-          pages.flatten.pmap { |instance| to_hash(instance, org_name) }
-        end
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-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

@@ -1,31 +0,0 @@
-module Sem
-  module API
-    module Traits
-      module AssociatedWithSharedConfig
-        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]).to_a
-
-          instances.map { |instance| to_hash(instance) }
-        end
-
-        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(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
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-module Sem
-  module API
-    module Traits
-      module AssociatedWithTeam
-        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).to_a
-
-          instances.map { |instance| to_hash(instance, org_name) }
-        end
-
-        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)
-        end
-
-        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)
-        end
-      end
-    end
-  end
-end

data/lib/sem/api/traits.rb

@@ -1,10 +0,0 @@
-module Sem
-  module API
-    module Traits
-      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

data/lib/sem/api/users.rb

@@ -1,44 +0,0 @@
-module Sem
-  module API
-    class Users < Base
-      extend Traits::AssociatedWithOrg
-      extend Traits::AssociatedWithTeam
-
-      class << self
-        def name_to_id(_, name)
-          name
-        end
-
-        def list
-          org_names = Orgs.list.map { |org| org[:username] }
-
-          org_names.to_a.pmap { |name| list_for_org(name) }.flatten
-        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 to_hash(user, _ = nil)
-          { :id => user.username }
-        end
-      end
-    end
-  end
-end