terraform-enterprise-cli 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8c43077659ff18b0945a0e89a23bb660791cda2b439fbb840465b32172be348
-  data.tar.gz: 12191251744cca852d945b4062df6ff127c1327ef94938adeee0dbc39af49981
+  metadata.gz: 6f8ce8edb289989b106e16d161d8c7e6429a34fc938c6366ad77c55a266bcb0f
+  data.tar.gz: '029df67dff6d7626a8f021b366cf4eb5e179cf61d48d558be68c1c5259abb082'
 SHA512:
-  metadata.gz: 755bb19cc68eaa0e5ddb4da594a5579f4a6e74cfda211d51539669e9af66b01e797c023112978ca16755525d1f94aef0b80a59f547b8f557f1eadefa33c0f119
-  data.tar.gz: c3756d0d12e98d9d524f8abb8bfc00069ef62f6126c1f4fb353766ff75341a5b8421e477fd0508011c11ca25c3da314955430d3f572105aa24a7029c4fc90ba0
+  metadata.gz: a16d986d9358faee6f58e7f5433007f0c946ef920b57a24ed369dcae2026e53a28c65058ec2ac9493d16d646b0033cbe1e693d862acc5012152e2a3fed2b0b0c
+  data.tar.gz: e7eb62c94f4b534d9117548ef68b4e0360fd02d5536721ca1bef33bcedb8c7e8e3148fe9ca1da71eb72e360dec6174e2a2dba3092ffe253b3b0d523fbf4600fa

data/lib/terraform-enterprise-command-line.rb

@@ -1,79 +1,3 @@
-require 'thor'
+require 'terraform_enterprise/command_line/commands/main'
 
-require_relative 'terraform_enterprise/command_line/command'
-require_relative 'terraform_enterprise/command_line/commands/configuration_versions'
-require_relative 'terraform_enterprise/command_line/commands/oauth_tokens'
-require_relative 'terraform_enterprise/command_line/commands/organizations'
-require_relative 'terraform_enterprise/command_line/commands/policies'
-require_relative 'terraform_enterprise/command_line/commands/policy_checks'
-require_relative 'terraform_enterprise/command_line/commands/runs'
-require_relative 'terraform_enterprise/command_line/commands/teams'
-require_relative 'terraform_enterprise/command_line/commands/variables'
-require_relative 'terraform_enterprise/command_line/commands/workspaces'
-
-module TerraformEnterprise
-  # Terraform Enterprise Command Line class
-  class MainCommand < TerraformEnterprise::CommandLine::Command
-    include TerraformEnterprise::CommandLine
-
-    desc 'organizations <subcommand>', 'Manage organizations'
-    subcommand 'organizations', OrganizationsCommand
-
-    desc 'workspaces <subcommand>', 'Manage workspaces'
-    subcommand 'workspaces', WorkspacesCommand
-
-    desc 'oauth-tokens <subcommand>', 'Manage OAuth tokens'
-    subcommand 'oauth_tokens', OAuthTokensCommand
-
-    desc 'teams <subcommand>', 'Manage teams'
-    subcommand 'teams', TeamsCommand
-
-    desc 'variables <subcommand>', 'Manage variables'
-    subcommand 'variables', VariablesCommand
-
-    desc 'configuration-versions <subcommand>', 'Manage configuration versions'
-    subcommand 'configuration_versions', ConfigurationVersionsCommand
-
-    desc 'policies <subcommand>', 'Manage policies'
-    subcommand 'policies', PoliciesCommand
-
-    desc 'policy-checks <subcommand>', 'Manage policy checks'
-    subcommand 'policy_checks', PolicyChecksCommand
-
-    desc 'runs <subcommand>', 'Manage runs'
-    subcommand 'runs', RunsCommand
-
-    desc 'push <organization>/<workspace>', STRINGS[:push][:commands][:push]
-    option :path, required: true, default: '.', desc: STRINGS[:push][:attributes][:path]
-    def push(name)
-      name_parts        = name.split('/')
-      organization_name = name_parts[0]
-      workspace_name    = name_parts[1]
-      workspace_params  = {
-        organization: organization_name,
-        workspace: workspace_name
-      }
-
-      begin
-        content = tarball(options[:path])
-      rescue
-        error! "could not open that file or directory"
-      end
-
-      # Look up the workspace ID
-      workspace_response = client.workspaces.get(workspace_params)
-      workspace_id = workspace_response&.resource&.id
-      error! "workspace '#{organization_name}/#{workspace_name}' was not found!" unless workspace_id
-
-      # Create a configuration version and get upload-url
-      configuration_version_response = client.configuration_versions.create(workspace: workspace_id)
-      upload_url = (configuration_version_response&.resource&.attributes || {})['upload-url']
-      error! "failed creationg configuration version with workspace id `#{workspace_id}`" unless upload_url      
-
-      upload_params = { content: content, url: upload_url }
-      render client.configuration_versions.upload(upload_params)
-    end
-  end
-end
-
-TerraformEnterprise::MainCommand.start(ARGV)
+TerraformEnterprise::CommandLine::Commands::MainCommand.start(ARGV)

data/lib/terraform_enterprise/command_line/command.rb

@@ -1,3 +1,4 @@
+require 'thor'
 require 'json'
 require 'terraform-enterprise-client'
 
@@ -16,12 +17,12 @@ module TerraformEnterprise
 
       class_option :host, type: :string, desc: CMD_STR[:host]
       class_option :token, type: :string, desc: CMD_STR[:token]
-      class_option :color, type: :boolean, default: true, desc: CMD_STR[:color]
+      class_option :color, type: :boolean, desc: CMD_STR[:color]
       class_option :except, type: :array, desc: CMD_STR[:except]
       class_option :only, type: :array, desc: CMD_STR[:only]
-      class_option :all, type: :boolean, default: false, desc: CMD_STR[:all]
-      class_option :value, type: :boolean, default: false, desc: CMD_STR[:value]
-      class_option :debug, type: :boolean, default: false, desc: CMD_STR[:debug]
+      class_option :all, type: :boolean, desc: CMD_STR[:all]
+      class_option :value, type: :boolean, desc: CMD_STR[:value]
+      class_option :debug, type: :boolean, desc: CMD_STR[:debug]
 
       no_commands do
         def render(obj, default_options = {})

data/lib/terraform_enterprise/command_line/commands/configuration_versions.rb

@@ -2,35 +2,37 @@ require 'terraform_enterprise/command_line/command'
 
 module TerraformEnterprise
   module CommandLine
-    # Configuration Version Commoand
-    class ConfigurationVersionsCommand < TerraformEnterprise::CommandLine::Command
-      ATTR_STR = STRINGS[:configuration_versions][:attributes]
-      CMD_STR = STRINGS[:configuration_versions][:commands]
+    module Commands
+      # Configuration Version Commoand
+      class ConfigurationVersionsCommand < TerraformEnterprise::CommandLine::Command
+        ATTR_STR = STRINGS[:configuration_versions][:attributes]
+        CMD_STR = STRINGS[:configuration_versions][:commands]
 
-      desc 'list', CMD_STR[:list]
-      option :table, type: :boolean, default: true, desc: STRINGS[:options][:table]
-      option :workspace_id, required: true, type: :string, desc: ATTR_STR[:workspace_id]
-      def list
-        render client.configuration_versions.list(workspace: options[:workspace_id])
-      end
+        desc 'list', CMD_STR[:list]
+        option :table, type: :boolean, default: true, desc: STRINGS[:options][:table]
+        option :workspace_id, required: true, type: :string, desc: ATTR_STR[:workspace_id]
+        def list
+          render client.configuration_versions.list(workspace: options[:workspace_id])
+        end
 
-      desc 'create', CMD_STR[:list]
-      option :workspace_id, required: true, type: :string, desc: STRINGS[:options][:workspace_id]
-      def create
-        render client.configuration_versions.create(workspace: options[:workspace_id])
-      end
+        desc 'create', CMD_STR[:list]
+        option :workspace_id, required: true, type: :string, desc: STRINGS[:options][:workspace_id]
+        def create
+          render client.configuration_versions.create(workspace: options[:workspace_id])
+        end
 
-      desc 'get <id>', CMD_STR[:get]
-      def get(id)
-        render client.configuration_versions.get(id: id)
-      end
+        desc 'get <id>', CMD_STR[:get]
+        def get(id)
+          render client.configuration_versions.get(id: id)
+        end
 
-      desc 'upload <path> <upload-url>', CMD_STR[:upload]
-      def upload(path, url)
-        content = tarball(path)
-        params  = { content: content, url: url }
+        desc 'upload <path> <upload-url>', CMD_STR[:upload]
+        def upload(path, url)
+          content = tarball(path)
+          params  = { content: content, url: url }
 
-        render client.configuration_versions.upload(params)
+          render client.configuration_versions.upload(params)
+        end
       end
     end
   end

data/lib/terraform_enterprise/command_line/commands/main.rb

@@ -0,0 +1,80 @@
+require 'terraform_enterprise/command_line/command'
+
+require_relative 'configuration_versions'
+require_relative 'oauth_tokens'
+require_relative 'organizations'
+require_relative 'policies'
+require_relative 'policy_checks'
+require_relative 'runs'
+require_relative 'teams'
+require_relative 'variables'
+require_relative 'workspaces'
+
+module TerraformEnterprise
+  module CommandLine
+    module Commands
+      # Terraform Enterprise Command Line class
+      class MainCommand < TerraformEnterprise::CommandLine::Command
+        include TerraformEnterprise::CommandLine::Commands
+
+        desc 'organizations <subcommand>', 'Manage organizations'
+        subcommand 'organizations', OrganizationsCommand
+
+        desc 'workspaces <subcommand>', 'Manage workspaces'
+        subcommand 'workspaces', WorkspacesCommand
+
+        desc 'oauth-tokens <subcommand>', 'Manage OAuth tokens'
+        subcommand 'oauth_tokens', OAuthTokensCommand
+
+        desc 'teams <subcommand>', 'Manage teams'
+        subcommand 'teams', TeamsCommand
+
+        desc 'variables <subcommand>', 'Manage variables'
+        subcommand 'variables', VariablesCommand
+
+        desc 'configuration-versions <subcommand>', 'Manage configuration versions'
+        subcommand 'configuration_versions', ConfigurationVersionsCommand
+
+        desc 'policies <subcommand>', 'Manage policies'
+        subcommand 'policies', PoliciesCommand
+
+        desc 'policy-checks <subcommand>', 'Manage policy checks'
+        subcommand 'policy_checks', PolicyChecksCommand
+
+        desc 'runs <subcommand>', 'Manage runs'
+        subcommand 'runs', RunsCommand
+
+        desc 'push <organization>/<workspace>', STRINGS[:push][:commands][:push]
+        option :path, required: true, default: '.', desc: STRINGS[:push][:attributes][:path]
+        def push(name)
+          name_parts        = name.split('/')
+          organization_name = name_parts[0]
+          workspace_name    = name_parts[1]
+          workspace_params  = {
+            organization: organization_name,
+            workspace: workspace_name
+          }
+
+          begin
+            content = tarball(options[:path])
+          rescue
+            error! "could not open that file or directory"
+          end
+
+          # Look up the workspace ID
+          workspace_response = client.workspaces.get(workspace_params)
+          workspace_id = workspace_response&.resource&.id
+          error! "workspace '#{organization_name}/#{workspace_name}' was not found!" unless workspace_id
+
+          # Create a configuration version and get upload-url
+          configuration_version_response = client.configuration_versions.create(workspace: workspace_id)
+          upload_url = (configuration_version_response&.resource&.attributes || {})['upload-url']
+          error! "failed creationg configuration version with workspace id `#{workspace_id}`" unless upload_url      
+
+          upload_params = { content: content, url: upload_url }
+          render client.configuration_versions.upload(upload_params)
+        end
+      end
+    end
+  end
+end

data/lib/terraform_enterprise/command_line/commands/oauth_tokens.rb

@@ -2,14 +2,16 @@ require 'terraform_enterprise/command_line/command'
 
 module TerraformEnterprise
   module CommandLine
-    class OAuthTokensCommand < TerraformEnterprise::CommandLine::Command
-      class_option :organization, required: true, type: :string, desc: STRINGS[:oauth_tokens][:attributes][:organization]
+    module Commands
+      class OAuthTokensCommand < TerraformEnterprise::CommandLine::Command
+        class_option :organization, required: true, type: :string, desc: STRINGS[:oauth_tokens][:attributes][:organization]
 
-      desc 'list', STRINGS[:oauth_tokens][:commands][:list]
-      option :table, type: :boolean, default: true, desc: STRINGS[:options][:table]
-      def list
-        render client.oauth_tokens.list(options)
+        desc 'list', STRINGS[:oauth_tokens][:commands][:list]
+        option :table, type: :boolean, default: true, desc: STRINGS[:options][:table]
+        def list
+          render client.oauth_tokens.list(options)
+        end
       end
     end
   end
-end
+end

data/lib/terraform_enterprise/command_line/commands/organizations.rb

@@ -2,29 +2,31 @@ require 'terraform_enterprise/command_line/command'
 
 module TerraformEnterprise
   module CommandLine
-    class OrganizationsCommand < TerraformEnterprise::CommandLine::Command
-      CMD_STR = STRINGS[:organizations][:commands]
+    module Commands
+      class OrganizationsCommand < TerraformEnterprise::CommandLine::Command
+        CMD_STR = STRINGS[:organizations][:commands]
 
-      desc 'list', CMD_STR[:list]
-      option :table, type: :boolean, default: true, desc: STRINGS[:options][:table]
-      def list
-        render client.organizations.list, only: [:id, :name, 'created-at', :email]
-      end
+        desc 'list', CMD_STR[:list]
+        option :table, type: :boolean, default: true, desc: STRINGS[:options][:table]
+        def list
+          render client.organizations.list, only: [:id, :name, 'created-at', :email]
+        end
 
-      desc 'create <name> <email>', CMD_STR[:create]
-      def create(name, email)
-        render client.organizations.create(name: name, email: email)
-      end
+        desc 'create <name> <email>', CMD_STR[:create]
+        def create(name, email)
+          render client.organizations.create(name: name, email: email)
+        end
 
-      desc 'get <name>', CMD_STR[:get]
-      def get(name)
-        render client.organizations.get(name:name)
-      end
+        desc 'get <name>', CMD_STR[:get]
+        def get(name)
+          render client.organizations.get(name:name)
+        end
 
-      desc 'delete <name>', CMD_STR[:delete]
-      def delete(name)
-        render client.organizations.delete(name:name)
+        desc 'delete <name>', CMD_STR[:delete]
+        def delete(name)
+          render client.organizations.delete(name:name)
+        end
       end
     end
   end
-end
+end

data/lib/terraform_enterprise/command_line/commands/policies.rb

@@ -2,71 +2,73 @@ require 'terraform_enterprise/command_line/command'
 
 module TerraformEnterprise
   module CommandLine
-    class PoliciesCommand < TerraformEnterprise::CommandLine::Command
-      ATTR_STR = STRINGS[:policies][:attributes]
-      CMD_STR = STRINGS[:policies][:commands]
+    module Commands
+      class PoliciesCommand < TerraformEnterprise::CommandLine::Command
+        ATTR_STR = STRINGS[:policies][:attributes]
+        CMD_STR = STRINGS[:policies][:commands]
 
-      desc 'list', CMD_STR[:list]
-      option :table, type: :boolean, default: true, desc: STRINGS[:options][:table]
-      option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
-      def list
-        render client.policies.list(organization: options[:organization])
-      end
+        desc 'list', CMD_STR[:list]
+        option :table, type: :boolean, default: true, desc: STRINGS[:options][:table]
+        option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
+        def list
+          render client.policies.list(organization: options[:organization])
+        end
 
-      desc 'create <name>', CMD_STR[:create]
-      option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
-      option :mode, type: :string, required: true, enum: ['soft-mandatory', 'hard-mandatory', 'advisory']
-      def create(name)
-        params = {
-          name: name,
-          organization: options[:organization],
-          enforce: [
-            {
-              path: "#{name}.sentinel",
-              mode: options[:mode]
-            }
-          ]
-        }
-        render client.policies.create(params)
-      end
+        desc 'create <name>', CMD_STR[:create]
+        option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
+        option :mode, type: :string, required: true, enum: ['soft-mandatory', 'hard-mandatory', 'advisory']
+        def create(name)
+          params = {
+            name: name,
+            organization: options[:organization],
+            enforce: [
+              {
+                path: "#{name}.sentinel",
+                mode: options[:mode]
+              }
+            ]
+          }
+          render client.policies.create(params)
+        end
 
-      desc 'update <id>', CMD_STR[:create]
-      option :mode, type: :string, required: true, enum: ['soft-mandatory', 'hard-mandatory', 'advisory'], desc: ATTR_STR[:mode]
-      def update(id)
-        name = ''
-        params = {
-          id: id,
-          name: name,
-          enforce: [
-            {
-              path: 'default.sentinel',
-              mode: options[:mode]
-            }
-          ]
-        }
+        desc 'update <id>', CMD_STR[:create]
+        option :mode, type: :string, required: true, enum: ['soft-mandatory', 'hard-mandatory', 'advisory'], desc: ATTR_STR[:mode]
+        def update(id)
+          name = ''
+          params = {
+            id: id,
+            name: name,
+            enforce: [
+              {
+                path: 'default.sentinel',
+                mode: options[:mode]
+              }
+            ]
+          }
 
-        render client.policies.update(params)
-      end
+          render client.policies.update(params)
+        end
 
-      desc 'get <id>', CMD_STR[:get]
-      def get(id)
-        render client.policies.get(id:id)
-      end
+        desc 'get <id>', CMD_STR[:get]
+        def get(id)
+          render client.policies.get(id:id)
+        end
 
-      desc 'delete <id>', CMD_STR[:delete]
-      def delete(id)
-        render client.policies.delete(id: id)
-      end
+        desc 'delete <id>', CMD_STR[:delete]
+        def delete(id)
+          render client.policies.delete(id: id)
+        end
 
-      desc 'upload <path> <policy-id>', CMD_STR[:upload]
-      def upload(path, policy_id)
-        full_path = File.expand_path(path)
-        content = File.read(full_path)
+        desc 'upload <path> <policy-id>', CMD_STR[:upload]
+        def upload(path, policy_id)
+          full_path = File.expand_path(path)
+          content = File.read(full_path)
 
-        params = { content: content, id: policy_id }
+          params = { content: content, id: policy_id }
 
-        render client.policies.upload(params)
+          render client.policies.upload(params)
+        end
       end
     end
   end
-end
+end

data/lib/terraform_enterprise/command_line/commands/policy_checks.rb

@@ -3,26 +3,28 @@ require 'terraform_enterprise/command_line/util'
 
 module TerraformEnterprise
   module CommandLine
-    # Configuration Version Commoand
-    class PolicyChecksCommand < TerraformEnterprise::CommandLine::Command
-      include TerraformEnterprise::CommandLine::Util::Tar
+    module Commands
+      # Configuration Version Commoand
+      class PolicyChecksCommand < TerraformEnterprise::CommandLine::Command
+        include TerraformEnterprise::CommandLine::Util::Tar
 
-      ATTR_STR = STRINGS[:policy_checks][:attributes]
-      CMD_STR = STRINGS[:policy_checks][:commands]
+        ATTR_STR = STRINGS[:policy_checks][:attributes]
+        CMD_STR = STRINGS[:policy_checks][:commands]
 
-      desc 'list', CMD_STR[:list]
-      option :table, type: :boolean, default: false, desc: STRINGS[:options][:table]
-      option :run_id, required: true, type: :string, desc: ATTR_STR[:run_id]
-      def list
-        render client.policy_checks.list(run_id: options[:run_id])
-      end
+        desc 'list', CMD_STR[:list]
+        option :table, type: :boolean, default: false, desc: STRINGS[:options][:table]
+        option :run_id, required: true, type: :string, desc: ATTR_STR[:run_id]
+        def list
+          render client.policy_checks.list(run_id: options[:run_id])
+        end
 
-      desc 'override <policy-check-id>', CMD_STR[:override]
-      option :comment, type: :string, desc: ATTR_STR[:comment]
-      def override(id)
-        params = { id: id, action: :override }
-        params[:comment] = options[:comment] if options[:comment]
-        render client.policy_checks.action(params)
+        desc 'override <policy-check-id>', CMD_STR[:override]
+        option :comment, type: :string, desc: ATTR_STR[:comment]
+        def override(id)
+          params = { id: id, action: :override }
+          params[:comment] = options[:comment] if options[:comment]
+          render client.policy_checks.action(params)
+        end
       end
     end
   end

data/lib/terraform_enterprise/command_line/commands/runs.rb

@@ -2,87 +2,89 @@ require 'terraform_enterprise/command_line/command'
 
 module TerraformEnterprise
   module CommandLine
-    class RunsCommand < TerraformEnterprise::CommandLine::Command
-      ATTR_STR = STRINGS[:runs][:attributes]
-      CMD_STR = STRINGS[:runs][:commands]
+    module Commands
+      class RunsCommand < TerraformEnterprise::CommandLine::Command
+        ATTR_STR = STRINGS[:runs][:attributes]
+        CMD_STR = STRINGS[:runs][:commands]
 
-      desc 'list', CMD_STR[:list]
-      option :table, type: :boolean, default: true, desc: STRINGS[:options][:table]
-      option :workspace_id, required: true, type: :string, desc: ATTR_STR[:workspace_id]
-      def list
-        render client.runs.list(id: options[:workspace_id]), except: [:permissions]
-      end
+        desc 'list', CMD_STR[:list]
+        option :table, type: :boolean, default: true, desc: STRINGS[:options][:table]
+        option :workspace_id, required: true, type: :string, desc: ATTR_STR[:workspace_id]
+        def list
+          render client.runs.list(id: options[:workspace_id]), except: [:permissions]
+        end
 
-      desc 'create', CMD_STR[:create]
-      option :workspace_id, required: true, type: :string, desc: ATTR_STR[:workspace_id]
-      option :configuration_version_id, type: :string, desc: ATTR_STR[:configuration_version_id]
-      option :destroy, type: :boolean, default: false, desc: ATTR_STR[:destroy]
-      def create
-        render client.runs.create(options), except: [:permissions]
-      end
+        desc 'create', CMD_STR[:create]
+        option :workspace_id, required: true, type: :string, desc: ATTR_STR[:workspace_id]
+        option :configuration_version_id, type: :string, desc: ATTR_STR[:configuration_version_id]
+        option :destroy, type: :boolean, default: false, desc: ATTR_STR[:destroy]
+        def create
+          render client.runs.create(options), except: [:permissions]
+        end
 
-      desc 'get <id>', CMD_STR[:get]
-      def get(id)
-        render client.runs.get(id: id), except: [:permissions]
-      end
+        desc 'get <id>', CMD_STR[:get]
+        def get(id)
+          render client.runs.get(id: id), except: [:permissions]
+        end
 
-      desc 'apply <id>', CMD_STR[:apply]
-      option :comment, type: :string, desc: ATTR_STR[:comment]
-      def apply(id)
-        params = { id: id, action: :apply }
-        params[:comment] = options[:comment] if options[:comment]
-        render client.runs.action(params)
-      end
+        desc 'apply <id>', CMD_STR[:apply]
+        option :comment, type: :string, desc: ATTR_STR[:comment]
+        def apply(id)
+          params = { id: id, action: :apply }
+          params[:comment] = options[:comment] if options[:comment]
+          render client.runs.action(params)
+        end
 
-      desc 'discard <id>', CMD_STR[:discard]
-      option :comment, type: :string, desc: ATTR_STR[:comment]
-      def discard(id)
-        params = { id: id, action: :discard }
-        params[:comment] = options[:comment] if options[:comment]
-        render client.runs.action(params)
-      end
+        desc 'discard <id>', CMD_STR[:discard]
+        option :comment, type: :string, desc: ATTR_STR[:comment]
+        def discard(id)
+          params = { id: id, action: :discard }
+          params[:comment] = options[:comment] if options[:comment]
+          render client.runs.action(params)
+        end
 
-      desc 'logs <id>', 'Logs'
-      option :event, type: :string, required: true, desc: ATTR_STR[:event], enum:['plan', 'apply']
-      option :follow, type: :boolean, default: false, desc: ATTR_STR[:follow]
-      def logs(id)
-        following       = options[:follow]
-        finished        = false
-        exit_requested  = false
-        finished_states = %w[errored canceled finished]
+        desc 'logs <id>', 'Logs'
+        option :event, type: :string, required: true, desc: ATTR_STR[:event], enum:['plan', 'apply']
+        option :follow, type: :boolean, default: false, desc: ATTR_STR[:follow]
+        def logs(id)
+          following       = options[:follow]
+          finished        = false
+          exit_requested  = false
+          finished_states = %w[errored canceled finished]
 
-        # Listens for "control-c" to exit
-        Kernel.trap('INT') { exit_requested = true }
+          # Listens for "control-c" to exit
+          Kernel.trap('INT') { exit_requested = true }
 
-        loop do
-          event    = get_event_resource(id, options[:event])
-          url      = event.attributes['log-read-url']
-          finished = finished_states.include?(event.attributes['status'].to_s)
-          logs     = RestClient.get(url).body
-          
-          # errase screen and go to (0,0)
-          print "\033[2J" if following
-          print logs
+          loop do
+            event    = get_event_resource(id, options[:event])
+            url      = event.attributes['log-read-url']
+            finished = finished_states.include?(event.attributes['status'].to_s)
+            logs     = RestClient.get(url).body
+            
+            # errase screen and go to (0,0)
+            print "\033[2J" if following
+            print logs
 
-          break if !following || exit_requested || finished
-          
-          sleep 2
-        end 
-      end
+            break if !following || exit_requested || finished
+            
+            sleep 2
+          end 
+        end
 
-      private
+        private
 
-      def get_event_resource(id, event)
-        event_type    = event == 'plan' ? 'plans' : 'applies'
-        error_message = "#{options[:event].to_s.capitalize} not started yet"
-        run_response  = client.runs.get(id: id, include: [event.to_sym])
-        render run_response unless run_response.success?
-        event_resource = run_response.resource.included.find do |er|
-          er.type.to_s == event_type
+        def get_event_resource(id, event)
+          event_type    = event == 'plan' ? 'plans' : 'applies'
+          error_message = "#{options[:event].to_s.capitalize} not started yet"
+          run_response  = client.runs.get(id: id, include: [event.to_sym])
+          render run_response unless run_response.success?
+          event_resource = run_response.resource.included.find do |er|
+            er.type.to_s == event_type
+          end
+          error! error_message unless event_resource
+          event_resource
         end
-        error! error_message unless event_resource
-        event_resource
       end
     end
   end
-end
+end

data/lib/terraform_enterprise/command_line/commands/teams.rb

@@ -2,32 +2,34 @@ require 'terraform_enterprise/command_line/command'
 
 module TerraformEnterprise
   module CommandLine
-    class TeamsCommand < TerraformEnterprise::CommandLine::Command
-      ATTR_STR = STRINGS[:teams][:attributes]
-      CMD_STR = STRINGS[:teams][:commands]
+    module Commands
+      class TeamsCommand < TerraformEnterprise::CommandLine::Command
+        ATTR_STR = STRINGS[:teams][:attributes]
+        CMD_STR = STRINGS[:teams][:commands]
 
-      desc 'list', CMD_STR[:list]
-      option :table, type: :boolean, default: true, desc: STRINGS[:options][:table]
-      option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
-      def list
-        render client.teams.list(organization: options[:organization]), except: [:permissions]
-      end
+        desc 'list', CMD_STR[:list]
+        option :table, type: :boolean, default: true, desc: STRINGS[:options][:table]
+        option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
+        def list
+          render client.teams.list(organization: options[:organization]), except: [:permissions]
+        end
 
-      desc 'create <name>', CMD_STR[:create]
-      option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
-      def create(name)
-        render client.teams.create(name: name, organization: options[:organization])
-      end
+        desc 'create <name>', CMD_STR[:create]
+        option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
+        def create(name)
+          render client.teams.create(name: name, organization: options[:organization])
+        end
 
-      desc 'get <id>', CMD_STR[:get]
-      def get(id)
-        render client.teams.get(id:id), except: [:permissions]
-      end
+        desc 'get <id>', CMD_STR[:get]
+        def get(id)
+          render client.teams.get(id:id), except: [:permissions]
+        end
 
-      desc 'delete <id>', CMD_STR[:delete]
-      def delete(id)
-        render client.teams.delete(id: id), except: [:permissions]
+        desc 'delete <id>', CMD_STR[:delete]
+        def delete(id)
+          render client.teams.delete(id: id), except: [:permissions]
+        end
       end
     end
   end
-end
+end

data/lib/terraform_enterprise/command_line/commands/variables.rb

@@ -2,60 +2,62 @@ require 'terraform_enterprise/command_line/command'
 
 module TerraformEnterprise
   module CommandLine
-    class VariablesCommand < TerraformEnterprise::CommandLine::Command
-      ATTR_STR = STRINGS[:variables][:attributes]
-      CMD_STR = STRINGS[:variables][:commands]
+    module Commands
+      class VariablesCommand < TerraformEnterprise::CommandLine::Command
+        ATTR_STR = STRINGS[:variables][:attributes]
+        CMD_STR = STRINGS[:variables][:commands]
 
-      desc 'list', CMD_STR[:list]
-      option :table, type: :boolean, default: true, desc: STRINGS[:options][:table]
-      option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
-      option :workspace, type: :string, desc: ATTR_STR[:workspace]
-      def list
-        render client.variables.list(options)
-      end
+        desc 'list', CMD_STR[:list]
+        option :table, type: :boolean, default: true, desc: STRINGS[:options][:table]
+        option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
+        option :workspace, type: :string, desc: ATTR_STR[:workspace]
+        def list
+          render client.variables.list(options)
+        end
 
-      desc 'create <key> <value>', CMD_STR[:create]
-      option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
-      option :workspace, required: true, type: :string, desc: ATTR_STR[:workspace]
-      option :category, default: 'terraform', type: :string, desc: ATTR_STR[:category], enum:['terraform', 'env']
-      option :hcl, default: false, type: :boolean, desc: ATTR_STR[:hcl]
-      option :sensitive, default: false, type: :boolean, desc: ATTR_STR[:sensitive]
-      def create(key, value)
-        params = {
-          category: options[:category],
-          hcl: options[:hcl],
-          key: key,
-          organization: options[:organization],
-          sensitive: options[:sensitive],
-          value: value,
-          workspace: options[:workspace],
-        }
-        render client.variables.create(params)
-      end
+        desc 'create <key> <value>', CMD_STR[:create]
+        option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
+        option :workspace, required: true, type: :string, desc: ATTR_STR[:workspace]
+        option :category, default: 'terraform', type: :string, desc: ATTR_STR[:category], enum:['terraform', 'env']
+        option :hcl, default: false, type: :boolean, desc: ATTR_STR[:hcl]
+        option :sensitive, default: false, type: :boolean, desc: ATTR_STR[:sensitive]
+        def create(key, value)
+          params = {
+            category: options[:category],
+            hcl: options[:hcl],
+            key: key,
+            organization: options[:organization],
+            sensitive: options[:sensitive],
+            value: value,
+            workspace: options[:workspace],
+          }
+          render client.variables.create(params)
+        end
 
-      desc 'update <id>', CMD_STR[:update]
-      option :hcl, type: :boolean, desc: ATTR_STR[:hcl]
-      option :sensitive, type: :boolean, desc: ATTR_STR[:sensitive]
-      option :key, type: :string, desc: ATTR_STR[:key]
-      option :value, type: :string, desc: ATTR_STR[:value]
-      def update(id)
-        params             = {id: id}
-        params[:hcl]       = options[:hcl] if options.include?('hcl')
-        params[:key]       = options[:key] if options[:key]
-        params[:sensitive] = options[:sensitive] if options.include?('sensitive')
-        params[:value]     = options[:value] if options[:value]
-        render client.variables.update(params)
-      end
+        desc 'update <id>', CMD_STR[:update]
+        option :hcl, type: :boolean, desc: ATTR_STR[:hcl]
+        option :sensitive, type: :boolean, desc: ATTR_STR[:sensitive]
+        option :key, type: :string, desc: ATTR_STR[:key]
+        option :value, type: :string, desc: ATTR_STR[:value]
+        def update(id)
+          params             = {id: id}
+          params[:hcl]       = options[:hcl] if options.include?('hcl')
+          params[:key]       = options[:key] if options[:key]
+          params[:sensitive] = options[:sensitive] if options.include?('sensitive')
+          params[:value]     = options[:value] if options[:value]
+          render client.variables.update(params)
+        end
 
-      desc 'get <id>', CMD_STR[:get]
-      def get(id)
-        render client.variables.get(id:id)
-      end
+        desc 'get <id>', CMD_STR[:get]
+        def get(id)
+          render client.variables.get(id:id)
+        end
 
-      desc 'delete <id>', CMD_STR[:delete]
-      def delete(id)
-        render client.variables.delete(id: id)
+        desc 'delete <id>', CMD_STR[:delete]
+        def delete(id)
+          render client.variables.delete(id: id)
+        end
       end
     end
   end
-end
+end

data/lib/terraform_enterprise/command_line/commands/workspaces.rb

@@ -2,86 +2,88 @@ require 'terraform_enterprise/command_line/command'
 
 module TerraformEnterprise
   module CommandLine
-    class WorkspacesCommand < TerraformEnterprise::CommandLine::Command
-      ATTR_STR = STRINGS[:workspaces][:attributes]
-      CMD_STR = STRINGS[:workspaces][:commands]
+    module Commands
+      class WorkspacesCommand < TerraformEnterprise::CommandLine::Command
+        ATTR_STR = STRINGS[:workspaces][:attributes]
+        CMD_STR = STRINGS[:workspaces][:commands]
 
-      desc 'list', CMD_STR[:list]
-      option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
-      option :table, type: :boolean, default: true, desc: STRINGS[:options][:table]
-      def list
-        render client.workspaces.list(options), except:[:permissions, :actions, :environment, 'created-at']
-      end
-
-      desc 'create <name>', CMD_STR[:create]
-      option :terraform_version, type: :string, desc: ATTR_STR[:terraform_version]
-      option :working_directory, type: :string, desc: ATTR_STR[:working_directory]
-      option :oauth_token, type: :string, desc: ATTR_STR[:oauth_token]
-      option :branch, type: :string, desc: ATTR_STR[:branch]
-      option :ingress_submodules, type: :boolean, desc: ATTR_STR[:ingress_submodules]
-      option :repo, type: :string, desc: ATTR_STR[:repos]
-      option :import_legacy_environment, type: :string, desc: ATTR_STR[:import_legacy]
-      option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
-      def create(name)
-        params = {
-          organization: options[:organization],
-          name: name,
-          'working-directory' => options[:working_directory] || '',
-        }
-        if options[:repo] && options[:oauth_token]
-          repo = {}
-          repo['branch']             = options[:branch] || ''
-          repo['identifier']         = options[:repo]
-          repo['oauth-token-id']     = options[:oauth_token]
-          repo['ingress-submodules'] = options[:ingress_submodules] || false
-          params['vcs-repo'] = repo
+        desc 'list', CMD_STR[:list]
+        option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
+        option :table, type: :boolean, default: true, desc: STRINGS[:options][:table]
+        def list
+          render client.workspaces.list(options), except:[:permissions, :actions, :environment, 'created-at']
         end
 
-        params['migration-environment'] = options[:import_legacy_environment] if options[:import_legacy_environment]
-        params['terraform_version']     = options[:terraform_version] if options[:terraform_version]
-        render client.workspaces.create(params), except:[:permissions, :actions, :environment]
-      end
+        desc 'create <name>', CMD_STR[:create]
+        option :terraform_version, type: :string, desc: ATTR_STR[:terraform_version]
+        option :working_directory, type: :string, desc: ATTR_STR[:working_directory]
+        option :oauth_token, type: :string, desc: ATTR_STR[:oauth_token]
+        option :branch, type: :string, desc: ATTR_STR[:branch]
+        option :ingress_submodules, type: :boolean, desc: ATTR_STR[:ingress_submodules]
+        option :repo, type: :string, desc: ATTR_STR[:repos]
+        option :import_legacy_environment, type: :string, desc: ATTR_STR[:import_legacy]
+        option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
+        def create(name)
+          params = {
+            organization: options[:organization],
+            name: name,
+            'working-directory' => options[:working_directory] || '',
+          }
+          if options[:repo] && options[:oauth_token]
+            repo = {}
+            repo['branch']             = options[:branch] || ''
+            repo['identifier']         = options[:repo]
+            repo['oauth-token-id']     = options[:oauth_token]
+            repo['ingress-submodules'] = options[:ingress_submodules] || false
+            params['vcs-repo'] = repo
+          end
 
-      desc 'get <name>', CMD_STR[:get]
-      option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
-      def get(name)
-        params = {
-          organization: options[:organization],
-          workspace: name
-        }
-        render client.workspaces.get(params), except:[:permissions, :environment]
-      end
+          params['migration-environment'] = options[:import_legacy_environment] if options[:import_legacy_environment]
+          params['terraform_version']     = options[:terraform_version] if options[:terraform_version]
+          render client.workspaces.create(params), except:[:permissions, :actions, :environment]
+        end
 
-      desc 'delete <name>', CMD_STR[:delete]
-      option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
-      def delete(name)
-        params = {
-          organization: options[:organization],
-          workspace: name
-        }
-        render client.workspaces.delete(params), except:[:permissions, :actions, :environment]
-      end
+        desc 'get <name>', CMD_STR[:get]
+        option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
+        def get(name)
+          params = {
+            organization: options[:organization],
+            workspace: name
+          }
+          render client.workspaces.get(params), except:[:permissions, :environment]
+        end
 
-      desc 'update <name>', CMD_STR[:update]
-      option :working_directory, type: :string, desc: ATTR_STR[:working_directory]
-      option :terraform_version, type: :string, desc: ATTR_STR[:terraform_version]
-      option :auto_apply, type: :boolean, desc: ATTR_STR[:auto_apply]
-      option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
-      def update(name)
-        params = options
-        params[:workspace] = name
-        render client.workspaces.update(params), except:[:permissions, :environment]
-      end
+        desc 'delete <name>', CMD_STR[:delete]
+        option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
+        def delete(name)
+          params = {
+            organization: options[:organization],
+            workspace: name
+          }
+          render client.workspaces.delete(params), except:[:permissions, :actions, :environment]
+        end
 
-      desc 'lock <id>', CMD_STR[:lock]
-      def lock(id)
-        render client.workspaces.action(action: :lock, id: id), except:[:permissions, :environment]
-      end
+        desc 'update <name>', CMD_STR[:update]
+        option :working_directory, type: :string, desc: ATTR_STR[:working_directory]
+        option :terraform_version, type: :string, desc: ATTR_STR[:terraform_version]
+        option :auto_apply, type: :boolean, desc: ATTR_STR[:auto_apply]
+        option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
+        def update(name)
+          params = options
+          params[:workspace] = name
+          render client.workspaces.update(params), except:[:permissions, :environment]
+        end
 
-      desc 'unlock <id>', CMD_STR[:unlock]
-      def unlock(id)
-        render client.workspaces.action(action: :unlock, id: id), except:[:permissions, :environment]
+        desc 'lock <id>', CMD_STR[:lock]
+        def lock(id)
+          render client.workspaces.action(action: :lock, id: id), except:[:permissions, :environment]
+        end
+
+        desc 'unlock <id>', CMD_STR[:unlock]
+        def unlock(id)
+          render client.workspaces.action(action: :unlock, id: id), except:[:permissions, :environment]
+        end
       end
     end
   end
-end
+end

data/lib/terraform_enterprise/command_line/formatter.rb

@@ -9,7 +9,10 @@ module TerraformEnterprise
     # Module with render method to render the Resource object
     class Formatter
       def render(obj, options = {})
-        String.disable_colorization = !options[:color]
+        
+        if options.include?(:color)
+          String.disable_colorization = !options[:color]
+        end
 
         if !obj.is_a?(TerraformEnterprise::API::Response)
           unkown_response(obj)

data/lib/terraform_enterprise/command_line/version.rb

@@ -1,5 +1,5 @@
 module TerraformEnterprise
   module CommandLine
-    VERSION = '0.0.6'.freeze
+    VERSION = '0.0.7'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: terraform-enterprise-cli
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Maciej Skierkowski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-05 00:00:00.000000000 Z
+date: 2018-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: terraform-enterprise-client
@@ -105,6 +105,7 @@ files:
 - lib/terraform-enterprise-command-line.rb
 - lib/terraform_enterprise/command_line/command.rb
 - lib/terraform_enterprise/command_line/commands/configuration_versions.rb
+- lib/terraform_enterprise/command_line/commands/main.rb
 - lib/terraform_enterprise/command_line/commands/oauth_tokens.rb
 - lib/terraform_enterprise/command_line/commands/organizations.rb
 - lib/terraform_enterprise/command_line/commands/policies.rb
@@ -137,7 +138,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: CLI tool for interacting with Terraform Enterprise