sem 0.2.3 → 0.2.4

data/lib/sem/cli/shared_configs.rb

@@ -2,121 +2,125 @@ class Sem::CLI::SharedConfigs < Dracula
 
   desc "list", "list shared cofigurations"
   def list
-    shared_configs = Sem::API::SharedConfigs.list
+    shared_configs = Sem::API::SharedConfig.all
 
-    Sem::Views::SharedConfigs.list(shared_configs)
+    if !shared_configs.empty?
+      Sem::Views::SharedConfigs.list(shared_configs)
+    else
+      Sem::Views::SharedConfigs.setup_first_shared_config
+    end
   end
 
   desc "info", "show information about a shared configuration"
-  def info(shared_config)
-    org_name, shared_config_name = Sem::SRN.parse_shared_config(shared_config)
-
-    shared_config_instance = Sem::API::SharedConfigs.info(org_name, shared_config_name).to_h
+  def info(shared_config_name)
+    shared_config = Sem::API::SharedConfig.find!(shared_config_name)
 
-    Sem::Views::SharedConfigs.info(shared_config_instance)
+    Sem::Views::SharedConfigs.info(shared_config)
   end
 
   desc "create", "create a new shared configuration"
-  def create(shared_config)
-    org_name, shared_config_name = Sem::SRN.parse_shared_config(shared_config)
+  def create(shared_config_name)
+    shared_config = Sem::API::SharedConfig.create!(shared_config_name)
 
-    shared_config_instance = Sem::API::SharedConfigs.create(org_name, :name => shared_config_name)
-
-    Sem::Views::SharedConfigs.info(shared_config_instance)
+    Sem::Views::SharedConfigs.info(shared_config)
   end
 
   desc "rename", "rename a shared configuration"
-  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
+  def rename(old_shared_config_name, new_shared_config_name)
+    shared_config = Sem::API::SharedConfig.find!(old_shared_config_name)
+    shared_config = shared_config.update!(:name => new_shared_config_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_instance)
+    Sem::Views::SharedConfigs.info(shared_config)
   end
 
   desc "delete", "removes a shared configuration from your organization"
-  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)
+  def delete(shared_config_name)
+    shared_config = Sem::API::SharedConfig.find!(shared_config_name)
+    shared_config.delete!
 
-    puts "Deleted shared configuration #{org_name}/#{shared_config_name}"
+    puts "Deleted shared configuration #{shared_config_name}"
   end
 
   class Files < Dracula
-    desc "list", "list files in the shared configuration"
-    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)
+    desc "list", "list files in the shared configuration"
+    def list(shared_config_name)
+      shared_config = Sem::API::SharedConfig.find!(shared_config_name)
+      files = shared_config.files
+
+      if !files.empty?
+        Sem::Views::Files.list(files)
+      else
+        Sem::Views::SharedConfigs.add_first_file(shared_config)
+      end
     end
 
     desc "add", "add a file to the shared configuration"
-    option :file, :aliases => "f", :desc => "File to upload", :required => true
-    def add(shared_config, file)
-      org_name, shared_config_name = Sem::SRN.parse_shared_config(shared_config)
+    option "path-on-semaphore", :aliases => "p", :desc => "Path of the file in builds", :required => true
+    option "local-path", :aliases => "l", :desc => "Location of the file on the local machine", :required => true
+    def add(shared_config_name)
+      shared_config = Sem::API::SharedConfig.find!(shared_config_name)
+
+      local_path = options["local-path"]
 
-      content = File.read(options[:file])
+      abort "File #{local_path} not found" unless File.exist?(local_path)
 
-      Sem::API::Files.add_to_shared_config(org_name, shared_config_name, :path => file, :content => content)
+      path = options["path-on-semaphore"]
+      content = File.read(local_path)
 
-      puts "Added #{file} to #{org_name}/#{shared_config_name}"
+      shared_config.add_config_file(:path => path, :content => content)
+
+      puts "Added #{path} to #{shared_config_name}"
     end
 
     desc "remove", "remove a file from the shared configuration"
-    def remove(shared_config, file)
-      org_name, shared_config_name = Sem::SRN.parse_shared_config(shared_config)
+    option :path, :aliases => "p", :desc => "Path of the file in builds", :required => true
+    def remove(shared_config_name)
+      shared_config = Sem::API::SharedConfig.find!(shared_config_name)
 
-      Sem::API::Files.remove_from_shared_config(org_name, shared_config_name, file)
+      shared_config.remove_config_file(options[:path])
 
-      puts "Removed #{file} from #{org_name}/#{shared_config_name}"
+      puts "Removed #{options[:path]} from #{shared_config_name}"
     end
+
   end
 
   class EnvVars < Dracula
-    desc "list", "list environment variables in the shared configuration"
-    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)
+    desc "list", "list environment variables in the shared configuration"
+    def list(shared_config_name)
+      shared_config = Sem::API::SharedConfig.find!(shared_config_name)
+      env_vars = shared_config.env_vars
+
+      if !env_vars.empty?
+        Sem::Views::EnvVars.list(env_vars)
+      else
+        Sem::Views::SharedConfigs.add_first_env_var(shared_config)
+      end
     end
 
     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)
-      org_name, shared_config_name = Sem::SRN.parse_shared_config(shared_config)
+    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_name)
+      shared_config = Sem::API::SharedConfig.find!(shared_config_name)
 
-      Sem::API::EnvVars.add_to_shared_config(org_name,
-                                             shared_config_name,
-                                             :name => options[:name],
-                                             :content => options[:content])
+      shared_config.add_env_var(:name => options[:name], :content => options[:content])
 
-      puts "Added #{options[:name]} to #{org_name}/#{shared_config_name}"
+      puts "Added #{options[:name]} to #{shared_config_name}"
     end
 
     desc "remove", "remove an environment variable from the shared configuration"
-    def remove(shared_config, env_var)
-      org_name, shared_config_name = Sem::SRN.parse_shared_config(shared_config)
+    option :name, :aliases => "n", :desc => "Name of the variable", :required => true
+    def remove(shared_config_name)
+      shared_config = Sem::API::SharedConfig.find!(shared_config_name)
+      name = options[:name]
 
-      Sem::API::EnvVars.remove_from_shared_config(org_name, shared_config_name, env_var)
+      shared_config.remove_env_var(name)
 
-      puts "Removed #{env_var} from #{org_name}/#{shared_config_name}"
+      puts "Removed #{name} from #{shared_config_name}"
     end
+
   end
 
   register "files", "manage files", Files

data/lib/sem/cli/teams.rb

@@ -2,177 +2,155 @@ class Sem::CLI::Teams < Dracula
 
   desc "list", "list teams"
   def list
-    teams = Sem::API::Teams.list
+    teams = Sem::API::Team.all
 
-    Sem::Views::Teams.list(teams)
+    if !teams.empty?
+      Sem::Views::Teams.list(teams)
+    else
+      Sem::Views::Teams.create_first_team
+    end
   end
 
   desc "info", "show information about a team"
-  def info(team)
-    org_name, team_name = Sem::SRN.parse_team(team)
-
-    team_instance = Sem::API::Teams.info(org_name, team_name).to_h
+  def info(team_name)
+    team = Sem::API::Team.find!(team_name)
 
-    Sem::Views::Teams.info(team_instance)
+    Sem::Views::Teams.info(team)
   end
 
   desc "create", "create a new team"
   option :permission, :default => "read",
-                      :aliases => "-p",
+                      :aliases => "p",
                       :desc => "Permission level of the team in the organization"
-  def create(team)
-    org_name, team_name = Sem::SRN.parse_team(team)
+  def create(team_name)
+    team = Sem::API::Team.create!(team_name, :permission => options[:permission])
 
-    team_instance = Sem::API::Teams.create(org_name,
-                                           :name => team_name,
-                                           :permission => options[:permission])
-
-    Sem::Views::Teams.info(team_instance)
+    Sem::Views::Teams.info(team)
   end
 
   desc "rename", "change the name of the team"
-  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_instance = Sem::API::Teams.update(old_org_name, old_team_name, :name => new_team_name)
+  def rename(old_team_name, new_team_name)
+    team = Sem::API::Team.find!(old_team_name)
+    team = team.update(:name => new_team_name)
 
-    Sem::Views::Teams.info(team_instance)
+    Sem::Views::Teams.info(team)
   end
 
   desc "set-permission", "set the permission level of the team"
-  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)
+  option :permission, :default => "read",
+                      :required => true,
+                      :aliases => "p",
+                      :desc => "Permission level of the team in the organization"
+  def set_permission(team_name) # rubocop:disable Style/AccessorMethodName
+    team = Sem::API::Team.find!(team_name)
+    team = team.update(:permission => options[:permission])
 
-    Sem::Views::Teams.info(team_instance)
+    Sem::Views::Teams.info(team)
   end
 
   desc "delete", "removes a team from your organization"
-  def delete(team)
-    org_name, team_name = Sem::SRN.parse_team(team)
-
-    Sem::API::Teams.delete(org_name, team_name)
+  def delete(team_name)
+    team = Sem::API::Team.find!(team_name)
+    team.delete!
 
-    puts "Deleted team #{org_name}/#{team_name}"
+    puts "Team #{team_name} deleted."
   end
 
   class Members < Dracula
     desc "list", "lists members of the team"
-    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::Teams.list_members(team, members)
+    def list(team_name)
+      team = Sem::API::Team.find!(team_name)
+      users = team.users
+
+      if !users.empty?
+        Sem::Views::Users.list(users)
+      else
+        Sem::Views::Teams.add_first_team_member(team)
+      end
     end
 
     desc "add", "add a user to the team"
-    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)
+    def add(team_name, username)
+      team = Sem::API::Team.find!(team_name)
+      team.add_user(username)
 
-      puts "User #{user_name} added to the team."
+      puts "User #{username} added to the team."
     end
 
     desc "remove", "removes a user from the team"
-    def remove(team, user)
-      org_name, team_name = Sem::SRN.parse_team(team)
-      user_name = Sem::SRN.parse_user(user).first
+    def remove(team_name, username)
+      team = Sem::API::Team.find!(team_name)
+      team.remove_user(username)
 
-      Sem::API::Users.remove_from_team(org_name, team_name, user_name)
-
-      puts "User #{user_name} removed from the team."
+      puts "User #{username} removed from the team."
     end
   end
 
   class Projects < Dracula
     desc "list", "lists projects in a team"
-    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)
+    def list(team_name)
+      team = Sem::API::Team.find!(team_name)
+      projects = team.projects
+
+      if !projects.empty?
+        Sem::Views::Projects.list(projects)
+      else
+        Sem::Views::Teams.add_first_project(team)
+      end
     end
 
     desc "add", "add a project to a team"
-    def add(team, project)
-      team_org_name, team_name = Sem::SRN.parse_team(team)
-      project_org_name, project_name = Sem::SRN.parse_project(project)
+    def add(team_name, project_name)
+      team = Sem::API::Team.find!(team_name)
+      project = Sem::API::Project.find!(project_name)
 
-      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)
+      team.add_project(project)
 
-      puts "Project #{team_org_name}/#{project_name} added to the team."
+      puts "Project #{project_name} added to the team."
     end
 
     desc "remove", "removes a project from the team"
-    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
+    def remove(team_name, project_name)
+      team = Sem::API::Team.find!(team_name)
+      project = Sem::API::Project.find!(project_name)
 
-      Sem::API::Projects.remove_from_team(team_org_name, team_name, project_name)
+      team.remove_project(project)
 
-      puts "Project #{team_org_name}/#{project_name} removed from the team."
+      puts "Project #{project_name} removed from the team."
     end
   end
 
   class SharedConfigs < Dracula
     desc "list", "list shared configurations in a team"
-    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)
+    def list(team_name)
+      team = Sem::API::Team.find!(team_name)
+      configs = team.shared_configs
+
+      if !configs.empty?
+        Sem::Views::SharedConfigs.list(configs)
+      else
+        Sem::Views::Teams.add_first_shared_config(team)
+      end
     end
 
     desc "add", "add a shared configuration to a team"
-    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)
+    def add(team_name, shared_config_name)
+      team = Sem::API::Team.find!(team_name)
+      shared_config = Sem::API::SharedConfig.find!(shared_config_name)
 
-      if team_org_name != shared_config_org_name
-        abort Sem::Views::Teams.org_names_not_matching("team", "shared configuration", team, shared_config)
-      end
+      team.add_shared_config(shared_config)
 
-      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."
+      puts "Shared Configuration #{shared_config_name} added to the team."
     end
 
     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
+    def remove(team_name, shared_config_name)
+      team = Sem::API::Team.find!(team_name)
+      shared_config = Sem::API::SharedConfig.find!(shared_config_name)
 
-      Sem::API::SharedConfigs.remove_from_team(team_org_name, team_name, shared_config_name)
+      team.remove_shared_config(shared_config)
 
-      puts "Shared Configuration #{team_org_name}/#{shared_config_name} removed from the team."
+      puts "Shared Configuration #{shared_config_name} removed from the team."
     end
   end
 

data/lib/sem/version.rb

@@ -1,3 +1,3 @@
 module Sem
-  VERSION = "0.2.3".freeze
+  VERSION = "0.2.4".freeze
 end

data/lib/sem/views/env_vars.rb

@@ -3,8 +3,8 @@ class Sem::Views::EnvVars < Sem::Views::Base
   def self.list(env_vars)
     header = ["ID", "NAME", "ENCRYPTED?", "CONTENT"]
 
-    body = env_vars.map do |env_var|
-      [env_var[:id], env_var[:name], env_var[:encrypted?], env_var[:content]]
+    body = env_vars.map do |var|
+      [var.id, var.name, var.encrypted?, var.content]
     end
 
     print_table([header, *body])

data/lib/sem/views/files.rb

@@ -1,10 +1,10 @@
 class Sem::Views::Files < Sem::Views::Base
 
   def self.list(files)
-    header = ["ID", "NAME", "ENCRYPTED?"]
+    header = ["ID", "PATH", "ENCRYPTED?"]
 
     body = files.map do |file|
-      [file[:id], file[:name], file[:encrypted?]]
+      [file.id, file.path, file.encrypted?]
     end
 
     print_table([header, *body])

data/lib/sem/views/orgs.rb

@@ -1,19 +1,17 @@
 class Sem::Views::Orgs < Sem::Views::Base
 
-  def self.list(orgs)
-    if orgs.empty?
-      puts "You don't belong to any organization."
-      puts ""
-      puts "Create your first organization: https://semaphoreci.com/organizations/new."
-      puts ""
-
-      return
-    end
+  def self.create_first_org
+    puts "You don't belong to any organization."
+    puts ""
+    puts "Create your first organization: https://semaphoreci.com/organizations/new."
+    puts ""
+  end
 
+  def self.list(orgs)
     header = ["ID", "NAME"]
 
     body = orgs.map do |org|
-      [org[:id], org[:username]]
+      [org.id, org.username]
     end
 
     print_table [header, *body]
@@ -21,10 +19,10 @@ class Sem::Views::Orgs < Sem::Views::Base
 
   def self.info(org)
     print_table [
-      ["ID", org[:id]],
-      ["Name", org[:username]],
-      ["Created", org[:created_at]],
-      ["Updated", org[:updated_at]]
+      ["ID", org.id],
+      ["Name", org.username],
+      ["Created", org.created_at],
+      ["Updated", org.updated_at]
     ]
   end
 

data/lib/sem/views/projects.rb

@@ -1,39 +1,38 @@
 class Sem::Views::Projects < Sem::Views::Base
-  class << self
-    def list(projects)
-      if projects.empty?
-        puts "You don't have any project configured on Semaphore."
-        puts ""
-        puts "Add your first project: https://semaphoreci.com/new"
-        puts ""
 
-        return
-      end
-
-      header = ["ID", "NAME"]
-
-      body = projects.map do |project|
-        [project[:id], name(project)]
-      end
+  def self.setup_first_project
+    puts "You don't have any project configured on Semaphore."
+    puts ""
+    puts "Add your first project: https://semaphoreci.com/new"
+    puts ""
+  end
 
-      print_table([header, *body])
-    end
+  def self.list(projects)
+    header = ["ID", "NAME"]
 
-    def info(project)
-      print_table [
-        ["ID", project[:id]],
-        ["Name", name(project)],
-        ["Created", project[:created_at]],
-        ["Updated", project[:updated_at]]
-      ]
+    body = projects.map do |project|
+      [project.id, project.full_name]
     end
 
-    private
+    print_table([header, *body])
+  end
 
-    def name(project)
-      return unless project[:org] && project[:name]
+  def self.info(project)
+    print_table [
+      ["ID", project.id],
+      ["Name", project.full_name],
+      ["Created", project.created_at],
+      ["Updated", project.updated_at]
+    ]
+  end
 
-      "#{project[:org]}/#{project[:name]}"
-    end
+  def self.attach_first_shared_config(project)
+    puts "You don't have any shared configurations on this project."
+    puts ""
+    puts "Add your first shared configuration:"
+    puts ""
+    puts "  sem projects:shared-configs:add #{project.full_name} SHARED_CONFIG_NAME"
+    puts ""
   end
+
 end