vagrant-unbundled 2.2.6.2 → 2.2.14.0

data/plugins/commands/cloud/publish.rb

@@ -5,11 +5,13 @@ module VagrantPlugins
   module CloudCommand
     module Command
       class Publish < Vagrant.plugin("2", :command)
+        include Util
+
         def execute
-          options = {}
+          options = {direct_upload: true}
 
           opts = OptionParser.new do |o|
-            o.banner = "Usage: vagrant cloud publish [options] organization/box-name version provider-name provider-file"
+            o.banner = "Usage: vagrant cloud publish [options] organization/box-name version provider-name [provider-file]"
             o.separator ""
             o.separator "Create and release a new Vagrant Box on Vagrant Cloud"
             o.separator ""
@@ -19,7 +21,7 @@ module VagrantPlugins
             o.on("--box-version VERSION", String, "Version of box to create") do |v|
               options[:box_version] = v
             end
-            o.on("--url URL", String, "Remote URL to download this provider") do |u|
+            o.on("--url URL", String, "Remote URL to download this provider (cannot be used with provider-file)") do |u|
               options[:url] = u
             end
             o.on("-d", "--description DESCRIPTION", String, "Full description of box") do |d|
@@ -28,154 +30,229 @@ module VagrantPlugins
             o.on("--version-description DESCRIPTION", String, "Description of the version to create") do |v|
               options[:version_description] = v
             end
-            o.on("-f", "--force", "Disables confirmation to create or update box") do |f|
+            o.on("-f", "--[no-]force", "Disables confirmation to create or update box") do |f|
               options[:force] = f
             end
-            o.on("-p", "--private", "Makes box private") do |p|
+            o.on("-p", "--[no-]private", "Makes box private") do |p|
               options[:private] = p
             end
-            o.on("-r", "--release", "Releases box") do |p|
+            o.on("-r", "--[no-]release", "Releases box") do |p|
               options[:release] = p
             end
             o.on("-s", "--short-description DESCRIPTION", String, "Short description of the box") do |s|
               options[:short_description] = s
             end
-            o.on("-u", "--username USERNAME_OR_EMAIL", String, "Vagrant Cloud username or email address") do |u|
-              options[:username] = u
-            end
             o.on("-c", "--checksum CHECKSUM_VALUE", String, "Checksum of the box for this provider. --checksum-type option is required.") do |c|
               options[:checksum] = c
             end
             o.on("-C", "--checksum-type TYPE", String, "Type of checksum used (md5, sha1, sha256, sha384, sha512). --checksum option is required.") do |c|
               options[:checksum_type] = c
             end
+            o.on("--[no-]direct-upload", "Upload asset directly to backend storage") do |d|
+              options[:direct_upload] = d
+            end
           end
 
           # Parse the options
           argv = parse_options(opts)
           return if !argv
 
-          if argv.empty? || argv.length > 4 || argv.length < 3
+          if argv.length < 3 || # missing required arguments
+              argv.length > 4 || # too many arguments
+              (argv.length < 4 && !options.key?(:url)) || # file argument required if url is not provided
+              (argv.length > 3 && options.key?(:url)) # cannot provider url and file argument
             raise Vagrant::Errors::CLIInvalidUsage,
               help: opts.help.chomp
           end
 
-          box = argv.first.split('/', 2)
-          org = box[0]
-          box_name = box[1]
-          version = argv[1]
-          provider_name = argv[2]
-          box_file = argv[3]
+          org, box_name = argv.first.split('/', 2)
+          _, version, provider_name, box_file = argv
 
-          if !options[:url] && !File.file?(box_file)
+          if box_file && !File.file?(box_file)
             raise Vagrant::Errors::BoxFileNotExist,
               file: box_file
           end
 
-          @client = VagrantPlugins::CloudCommand::Util.client_login(@env, options[:username])
+          @client = client_login(@env)
+          params = options.slice(:private, :release, :url, :short_description,
+            :description, :version_description, :checksum, :checksum_type)
 
-          publish_box(org, box_name, version, provider_name, box_file, options, @client.token)
-        end
-
-        def publish_box(org, box_name, version, provider_name, box_file, options, access_token)
-          server_url = VagrantPlugins::CloudCommand::Util.api_server_url
-
-          @env.ui.warn(I18n.t("cloud_command.publish.confirm.warn"))
-
-          @env.ui.info(I18n.t("cloud_command.publish.confirm.box", org: org,
-                              box_name: box_name, version: version, provider_name: provider_name))
-          @env.ui.info(I18n.t("cloud_command.publish.confirm.private")) if options[:private]
-          @env.ui.info(I18n.t("cloud_command.publish.confirm.release")) if options[:release]
-          @env.ui.info(I18n.t("cloud_command.publish.confirm.box_url",
-                             url: options[:url])) if options[:url]
-          @env.ui.info(I18n.t("cloud_command.publish.confirm.box_description",
-                             description: options[:description])) if options[:description]
-          @env.ui.info(I18n.t("cloud_command.publish.confirm.box_short_desc",
-                             short_description: options[:short_description])) if options[:short_description]
-          @env.ui.info(I18n.t("cloud_command.publish.confirm.version_desc",
-                             version_description: options[:version_description])) if options[:version_description]
+          # Display output to user describing action to be taken
+          display_preamble(org, box_name, version, provider_name, params)
 
           if !options[:force]
             cont = @env.ui.ask(I18n.t("cloud_command.continue"))
             return 1 if cont.strip.downcase != "y"
           end
 
-          account = VagrantPlugins::CloudCommand::Util.account(org, access_token, server_url)
-          box = VagrantCloud::Box.new(account, box_name, nil, options[:short_description], options[:description], access_token)
-          cloud_version = VagrantCloud::Version.new(box, version, nil, options[:version_description], access_token)
-          provider = VagrantCloud::Provider.new(cloud_version, provider_name, nil, options[:url], org, box_name,
-            access_token, nil, options[:checksum], options[:checksum_type])
-
-          ui = Vagrant::UI::Prefixed.new(@env.ui, "cloud")
-
-          begin
-            ui.info(I18n.t("cloud_command.publish.box_create"))
-            box.create
-          rescue VagrantCloud::ClientError => e
-            if e.error_code == 422
-              ui.warn(I18n.t("cloud_command.publish.update_continue", obj: "Box"))
-              box.update(options)
-            else
-              @env.ui.error(I18n.t("cloud_command.errors.publish.fail", org: org, box_name: box_name))
-              @env.ui.error(e)
-              return 1
-            end
-          end
+          # Load up all the models we'll need to publish the asset
+          box = load_box(org, box_name, @client.token)
+          box_v = load_box_version(box, version)
+          box_p = load_version_provider(box_v, provider_name)
 
-          begin
-            ui.info(I18n.t("cloud_command.publish.version_create"))
-            cloud_version.create_version
-          rescue VagrantCloud::ClientError => e
-            if e.error_code == 422
-              ui.warn(I18n.t("cloud_command.publish.update_continue", obj: "Version"))
-              cloud_version.update
-            else
-              @env.ui.error(I18n.t("cloud_command.errors.publish.fail", org: org, box_name: box_name))
-              @env.ui.error(e)
-              return 1
-            end
-          rescue VagrantCloud::InvalidVersion => e
-            @env.ui.error(I18n.t("cloud_command.errors.publish.fail", org: org, box_name: box_name))
-            @env.ui.error(e)
-            return 1
+          # Update all the data
+          set_box_info(box, params.slice(:private, :short_description, :description))
+          set_version_info(box_v, params.slice(:version_description))
+          set_provider_info(box_p, params.slice(:checksum, :checksum_type, :url))
+
+          # Save any updated state
+          @env.ui.warn(I18n.t("cloud_command.publish.box_save"))
+          box.save
+
+          # If we have a box file asset, upload it
+          if box_file
+            upload_box_file(box_p, box_file, options.slice(:direct_upload))
           end
 
-          begin
-            ui.info(I18n.t("cloud_command.publish.provider_create"))
-            provider.create_provider
-          rescue VagrantCloud::ClientError => e
-            if e.error_code == 422
-              ui.warn(I18n.t("cloud_command.publish.update_continue", obj: "Provider"))
-              provider.update
-            else
-              @env.ui.error(I18n.t("cloud_command.errors.publish.fail", org: org, box_name: box_name))
-              @env.ui.error(e)
-              return 1
-            end
+          # If configured to release the box, release it
+          if options[:release] && !box_v.released?
+            release_version(box_v)
           end
 
-          begin
-            if !options[:url]
-              box_file = File.absolute_path(box_file)
-              ui.info(I18n.t("cloud_command.publish.upload_provider", file: box_file))
-              ul = Vagrant::Util::Uploader.new(provider.upload_url, box_file, ui: @env.ui)
-              ul.upload!
-            end
-            if options[:release]
-              ui.info(I18n.t("cloud_command.publish.release"))
-              cloud_version.release
-            end
-            @env.ui.success(I18n.t("cloud_command.publish.complete", org: org, box_name: box_name))
-            success = box.read(org, box_name)
-            success = success.delete_if{|_, v|v.nil?}
-            VagrantPlugins::CloudCommand::Util.format_box_results(success, @env)
-            return 0
-          rescue Vagrant::Errors::UploaderError, VagrantCloud::ClientError => e
-            @env.ui.error(I18n.t("cloud_command.errors.publish.fail", org: org, box_name: box_name))
-            @env.ui.error(e)
-            return 1
+          # And we're done!
+          @env.ui.success(I18n.t("cloud_command.publish.complete", org: org, box_name: box_name))
+          format_box_results(box, @env)
+          0
+        rescue VagrantCloud::Error => err
+          @env.ui.error(I18n.t("cloud_command.errors.publish.fail", org: org, box_name: box_name))
+          @env.ui.error(err.message)
+          1
+        end
+
+        # Upload the file for the given box provider
+        #
+        # @param [VagrantCloud::Box::Provider] provider Vagrant Cloud box version provider
+        # @param [String] box_file Path to local asset for upload
+        # @param [Hash] options
+        # @option options [Boolean] :direct_upload Upload directly to backend storage
+        # @return [nil]
+        def upload_box_file(provider, box_file, options={})
+          box_file = File.absolute_path(box_file)
+          @env.ui.info(I18n.t("cloud_command.publish.upload_provider", file: box_file))
+          provider.upload(direct: options[:direct_upload]) do |upload_url|
+            Vagrant::Util::Uploader.new(upload_url, box_file, ui: @env.ui, method: :put).upload!
           end
-          return 1
+          nil
+        end
+
+        # Release the box version
+        #
+        # @param [VagrantCloud::Box::Version] version Vagrant Cloud box version
+        # @return [nil]
+        def release_version(version)
+          @env.ui.info(I18n.t("cloud_command.publish.release"))
+          version.release
+          nil
+        end
+
+        # Set any box related attributes that were provided
+        #
+        # @param [VagrantCloud::Box] box Vagrant Cloud box
+        # @param [Hash] options
+        # @option options [Boolean] :private Box access is private
+        # @option options [String] :short_description Short description of box
+        # @option options [String] :description Full description of box
+        # @return [VagrantCloud::Box]
+        def set_box_info(box, options={})
+          box.private = options[:private] if options.key?(:private)
+          box.short_description = options[:short_description] if options.key?(:short_description)
+          box.description = options[:description] if options.key?(:description)
+          box
+        end
+
+        # Set any version related attributes that were provided
+        #
+        # @param [VagrantCloud::Box::Version] version Vagrant Cloud box version
+        # @param [Hash] options
+        # @option options [String] :version_description Description for this version
+        # @return [VagrantCloud::Box::Version]
+        def set_version_info(version, options={})
+          version.description = options[:version_description] if options.key?(:version_description)
+          version
+        end
+
+        # Set any provider related attributes that were provided
+        #
+        # @param [VagrantCloud::Box::Provider] provider Vagrant Cloud box version provider
+        # @param [Hash] options
+        # @option options [String] :url Remote URL for self hosted
+        # @option options [String] :checksum_type Type of checksum value provided
+        # @option options [String] :checksum Checksum of the box asset
+        # @return [VagrantCloud::Box::Provider]
+        def set_provider_info(provider, options={})
+          provider.url = options[:url] if options.key?(:url)
+          provider.checksum_type = options[:checksum_type] if options.key?(:checksum_type)
+          provider.checksum = options[:checksum] if options.key?(:checksum)
+          provider
+        end
+
+        # Load the requested version provider
+        #
+        # @param [VagrantCloud::Box::Version] version The version of the Vagrant Cloud box
+        # @param [String] provider_name Name of the provider
+        # @return [VagrantCloud::Box::Provider]
+        def load_version_provider(version, provider_name)
+          provider = version.providers.detect { |pv| pv.name == provider_name }
+          return provider if provider
+          version.add_provider(provider_name)
+        end
+
+        # Load the requested box version
+        #
+        # @param [VagrantCloud::Box] box The Vagrant Cloud box
+        # @param [String] version Version of the box
+        # @return [VagrantCloud::Box::Version]
+        def load_box_version(box, version)
+          v = box.versions.detect { |v| v.version == version }
+          return v if v
+          box.add_version(version)
+        end
+
+        # Load the requested box
+        #
+        # @param [String] org Organization name for box
+        # @param [String] box_name Name of the box
+        # @param [String] access_token User access token
+        # @return [VagrantCloud::Box]
+        def load_box(org, box_name, access_token)
+          account = VagrantCloud::Account.new(
+            custom_server: api_server_url,
+            access_token: access_token
+          )
+          box = account.organization(name: org).boxes.detect { |b| b.name == box_name }
+          return box if box
+          account.organization(name: org).add_box(box_name)
+        end
+
+        # Display publishing information to user before starting process
+        #
+        # @param [String] org Organization name
+        # @param [String] box_name Name of the box to publish
+        # @param [String] version Version of the box to publish
+        # @param [String] provider_name Name of the provider being published
+        # @param [Hash] options
+        # @option options [Boolean] :private Box is private
+        # @option options [Boolean] :release Box should be released
+        # @option options [String] :url Remote URL for self-hosted boxes
+        # @option options [String] :description Description of the box
+        # @option options [String] :short_description Short description of the box
+        # @option options [String] :version_description Description of the box version
+        # @return [nil]
+        def display_preamble(org, box_name, version, provider_name, options={})
+          @env.ui.warn(I18n.t("cloud_command.publish.confirm.warn"))
+          @env.ui.info(I18n.t("cloud_command.publish.confirm.box", org: org,
+            box_name: box_name, version: version, provider_name: provider_name))
+          @env.ui.info(I18n.t("cloud_command.publish.confirm.private")) if options[:private]
+          @env.ui.info(I18n.t("cloud_command.publish.confirm.release")) if options[:release]
+          @env.ui.info(I18n.t("cloud_command.publish.confirm.box_url",
+            url: options[:url])) if options[:url]
+          @env.ui.info(I18n.t("cloud_command.publish.confirm.box_description",
+            description: options[:description])) if options[:description]
+          @env.ui.info(I18n.t("cloud_command.publish.confirm.box_short_desc",
+            short_description: options[:short_description])) if options[:short_description]
+          @env.ui.info(I18n.t("cloud_command.publish.confirm.version_desc",
+            version_description: options[:version_description])) if options[:version_description]
+          nil
         end
       end
     end

data/plugins/commands/cloud/search.rb

@@ -4,8 +4,10 @@ module VagrantPlugins
   module CloudCommand
     module Command
       class Search < Vagrant.plugin("2", :command)
+        include Util
+
         def execute
-          options = {}
+          options = {quiet: true}
 
           opts = OptionParser.new do |o|
             o.banner = "Usage: vagrant cloud search [options] query"
@@ -37,45 +39,56 @@ module VagrantPlugins
             o.on("--sort-by SORT", "Field to sort results on (created, downloads, updated) Default: downloads") do |s|
               options[:sort] = s
             end
-            o.on("-u", "--username USERNAME_OR_EMAIL", String, "Vagrant Cloud username or email address to login with") do |u|
-              options[:username] = u
+            o.on("--[no-]auth", "Authenticate with Vagrant Cloud if required before searching") do |l|
+              options[:quiet] = !l
             end
           end
 
           # Parse the options
           argv = parse_options(opts)
           return if !argv
-          if argv.length > 1
+          if argv.length != 1
             raise Vagrant::Errors::CLIInvalidUsage,
               help: opts.help.chomp
           end
 
-          @client = VagrantPlugins::CloudCommand::Util.client_login(@env, options[:username])
+          @client = client_login(@env, options.slice(:quiet))
           query = argv.first
 
           options[:limit] = 25 if !(options[:limit].to_i < 1) && !options[:limit]
 
-          search(query, options, @client.token)
+          search(query, @client&.token, options)
         end
 
-        def search(query, options, access_token)
-          server_url = VagrantPlugins::CloudCommand::Util.api_server_url
-          search = VagrantCloud::Search.new(access_token, server_url)
+        # Perform requested search and display results to user
+        #
+        # @param [String] query Search query string
+        # @param [Hash] options
+        # @option options [String] :provider Filter by provider
+        # @option options [String] :sort Field to sort results
+        # @option options [Integer] :limit Number of results to display
+        # @option options [Integer] :page Page of results to display
+        # @param [String] access_token User access token
+        # @return [Integer]
+        def search(query, access_token, options={})
+          account = VagrantCloud::Account.new(
+            custom_server: api_server_url,
+            access_token: access_token
+          )
+          params = {query: query}.merge(options.slice(:provider, :sort, :order, :limit, :page))
+          result = account.searcher.search(**params)
 
-          begin
-            search_results = search.search(query, options[:provider], options[:sort], options[:order], options[:limit], options[:page])
-            if !search_results["boxes"].empty?
-              VagrantPlugins::CloudCommand::Util.format_search_results(search_results["boxes"], options[:short], options[:json], @env)
-            else
-              @env.ui.warn(I18n.t("cloud_command.search.no_results", query: query))
-            end
+          if result.boxes.empty?
+            @env.ui.warn(I18n.t("cloud_command.search.no_results", query: query))
             return 0
-          rescue VagrantCloud::ClientError => e
-            @env.ui.error(I18n.t("cloud_command.errors.search.fail"))
-            @env.ui.error(e)
-            return 1
           end
-          return 1
+
+          format_search_results(result.boxes, options[:short], options[:json], @env)
+          0
+        rescue VagrantCloud::Error => e
+          @env.ui.error(I18n.t("cloud_command.errors.search.fail"))
+          @env.ui.error(e.message)
+          1
         end
       end
     end

data/plugins/commands/cloud/util.rb

@@ -1,205 +1,309 @@
 module VagrantPlugins
   module CloudCommand
-    class Util
-      class << self
-        # @param [String] username - Vagrant Cloud username
-        # @param [String] access_token - Vagrant Cloud Token used to authenticate
-        # @param [String] vagrant_cloud_server - Vagrant Cloud server to make API request
-        # @return [VagrantCloud::Account]
-        def account(username, access_token, vagrant_cloud_server)
-          if !defined?(@_account)
-            @_account = VagrantCloud::Account.new(username, access_token, vagrant_cloud_server)
-          end
-          @_account
-        end
-
-        def api_server_url
-          if Vagrant.server_url == Vagrant::DEFAULT_SERVER_URL
-            return "#{Vagrant.server_url}/api/v1"
-          else
-            return Vagrant.server_url
-          end
+    module Util
+      # @return [String] Vagrant Cloud server URL
+      def api_server_url
+        if Vagrant.server_url == Vagrant::DEFAULT_SERVER_URL
+          return "#{Vagrant.server_url}/api/v1"
+        else
+          return Vagrant.server_url
         end
+      end
 
-        # @param [Vagrant::Environment] env
-        # @param [Hash] options
-        # @returns [VagrantPlugins::CloudCommand::Client]
-        def client_login(env, options)
-          if !defined?(@_client)
-            @_client = Client.new(env)
-            return @_client if @_client.logged_in?
+      # @param [Vagrant::Environment] env
+      # @param [Hash] options
+      # @option options [String] :login Username or email
+      # @option options [String] :description Description of login usage for token
+      # @option options [String] :code 2FA code for login
+      # @option options [Boolean] :quiet Do not prompt user
+      # @returns [VagrantPlugins::CloudCommand::Client, nil]
+      def client_login(env, options={})
+        return @_client if defined?(@_client)
+        @_client = Client.new(env)
+        return @_client if @_client.logged_in?
 
-            # Let the user know what is going on.
-            env.ui.output(I18n.t("cloud_command.command_header") + "\n")
+        # If directed to be quiet, do not continue and
+        # just return nil
+        return if options[:quiet]
 
-            # If it is a private cloud installation, show that
-            if Vagrant.server_url != Vagrant::DEFAULT_SERVER_URL
-              env.ui.output("Vagrant Cloud URL: #{Vagrant.server_url}")
-            end
+        # Let the user know what is going on.
+        env.ui.output(I18n.t("cloud_command.command_header") + "\n")
 
-            options = {} if !options
-            # Ask for the username
-            if options[:login]
-              @_client.username_or_email = options[:login]
-              env.ui.output("Vagrant Cloud username or email: #{@_client.username_or_email}")
-            else
-              @_client.username_or_email = env.ui.ask("Vagrant Cloud username or email: ")
-            end
+        # If it is a private cloud installation, show that
+        if Vagrant.server_url != Vagrant::DEFAULT_SERVER_URL
+          env.ui.output("Vagrant Cloud URL: #{Vagrant.server_url}")
+        end
 
-            @_client.password = env.ui.ask("Password (will be hidden): ", echo: false)
+        options = {} if !options
+        # Ask for the username
+        if options[:login]
+          @_client.username_or_email = options[:login]
+          env.ui.output("Vagrant Cloud username or email: #{@_client.username_or_email}")
+        else
+          @_client.username_or_email = env.ui.ask("Vagrant Cloud username or email: ")
+        end
 
-            description_default = "Vagrant login from #{Socket.gethostname}"
-            if !options[:description]
-              description = env.ui.ask("Token description (Defaults to #{description_default.inspect}): ")
-            else
-              description = options[:description]
-              env.ui.output("Token description: #{description}")
-            end
+        @_client.password = env.ui.ask("Password (will be hidden): ", echo: false)
 
-            description = description_default if description.empty?
+        description_default = "Vagrant login from #{Socket.gethostname}"
+        if !options[:description]
+          description = env.ui.ask("Token description (Defaults to #{description_default.inspect}): ")
+        else
+          description = options[:description]
+          env.ui.output("Token description: #{description}")
+        end
 
-            code = nil
+        description = description_default if description.empty?
 
-            begin
-              token = @_client.login(description: description, code: code)
-            rescue Errors::TwoFactorRequired
-              until code
-                code = env.ui.ask("2FA code: ")
+        code = nil
 
-                if @_client.two_factor_delivery_methods.include?(code.downcase)
-                  delivery_method, code = code, nil
-                  @_client.request_code delivery_method
-                end
-              end
+        begin
+          token = @_client.login(description: description, code: code)
+        rescue Errors::TwoFactorRequired
+          until code
+            code = env.ui.ask("2FA code: ")
 
-              retry
+            if @_client.two_factor_delivery_methods.include?(code.downcase)
+              delivery_method, code = code, nil
+              @_client.request_code delivery_method
             end
-
-            @_client.store_token(token)
-            Vagrant::Util::CredentialScrubber.sensitive(token)
-            env.ui.success(I18n.t("cloud_command.logged_in"))
-            @_client
           end
-          @_client
-        end
 
-        # ===================================================
-        # Modified from https://stackoverflow.com/a/28685559
-        # for printing arrays of hashes in formatted tables
-        # ===================================================
-
-        # @param [Vagrant::Environment] - env
-        # @param [Hash] - column_labels - A hash of key values for table labels (i.e. {:col1=>"COL1", :col2=>"COL2"})
-        # @param [Array] - results - An array of hashes
-        # @param [Array] - to_jrust_keys - An array of column keys that should be right justified (default is left justified for all columns)
-        def print_search_table(env, column_labels, results, to_rjust_keys)
-          columns = column_labels.each_with_object({}) { |(col,label),h|
-            h[col] = { label: label,
-                       width: [results.map { |g| g[col].size }.max, label.size].max
-                     }}
-
-          write_header(env, columns)
-          write_divider(env, columns)
-          results.each { |h| write_line(env, columns, h,to_rjust_keys) }
-          write_divider(env, columns)
+          retry
         end
 
-        def write_header(env, columns)
-          env.ui.info "| #{ columns.map { |_,g| g[:label].ljust(g[:width]) }.join(' | ') } |"
-        end
+        @_client.store_token(token)
+        Vagrant::Util::CredentialScrubber.sensitive(token)
+        env.ui.success(I18n.t("cloud_command.logged_in"))
+        @_client
+      end
 
-        def write_divider(env, columns)
-          env.ui.info "+-#{ columns.map { |_,g| "-"*g[:width] }.join("-+-") }-+"
+      # Print search results from Vagrant Cloud to the console
+      #
+      # @param [Array<VagrantCloud::Box>] search_results Box search results from Vagrant Cloud
+      # @param [Boolean] short Print short summary
+      # @param [Boolean] json Print output in JSON format
+      # @param [Vagrant::Environment] env Current Vagrant environment
+      # @return [nil]
+      def format_search_results(search_results, short, json, env)
+        result = search_results.map do |b|
+          {
+            name: b.tag,
+            version: b.current_version.version,
+            downloads: format_downloads(b.downloads.to_s),
+            providers: b.current_version.providers.map(&:name).join(", ")
+          }
         end
 
-        def write_line(env, columns,h,to_rjust_keys)
-          str = h.keys.map { |k|
-            if to_rjust_keys.include?(k)
-              h[k].rjust(columns[k][:width])
-            else
-              h[k].ljust(columns[k][:width])
-            end
-          }.join(" | ")
-          env.ui.info "| #{str} |"
+        if short
+          result.map { |b| env.ui.info(b[:name]) }
+        elsif json
+          env.ui.info(result.to_json)
+        else
+          column_labels = {}
+          columns = result.first.keys
+          columns.each do |c|
+            column_labels[c] = c.to_s.upcase
+          end
+          print_search_table(env, column_labels, result, [:downloads])
         end
+        nil
+      end
 
-        # ===================================================
-        # ===================================================
+      # Output box details result from Vagrant Cloud
+      #
+      # @param [VagrantCloud::Box, VagrantCloud::Box::Version] box Box or box version to display
+      # @param [Vagrant::Environment] env Current Vagrant environment
+      # @return [nil]
+      def format_box_results(box, env)
+        if box.is_a?(VagrantCloud::Box)
+          info = box_info(box)
+        elsif box.is_a?(VagrantCloud::Box::Provider)
+          info = version_info(box.version)
+        else
+          info = version_info(box)
+        end
 
-        # Takes a "mostly" flat key=>value hash from Vagrant Cloud
-        # and prints its results in a list
-        #
-        # @param [Hash] - results - A response hash from vagrant cloud
-        # @param [Vagrant::Environment] - env
-        def format_box_results(results, env)
-          # TODO: remove other description fields? Maybe leave "short"?
-          results.delete("description_html")
+        width = info.keys.map(&:size).max
+        info.each do |k, v|
+          whitespace = width - k.size
+          env.ui.info "#{k}: #{"".ljust(whitespace)} #{v}"
+        end
+        nil
+      end
 
-          if results["current_version"]
-            versions = results.delete("versions")
-            results["providers"] = results["current_version"]["providers"]
+      # Load box and yield
+      #
+      # @param [VagrantCloud::Account] account Vagrant Cloud account
+      # @param [String] org Organization name
+      # @param [String] box Box name
+      # @yieldparam [VagrantCloud::Box] box Requested Vagrant Cloud box
+      # @yieldreturn [Integer]
+      # @return [Integer]
+      def with_box(account:, org:, box:)
+        org = account.organization(name: org)
+        b = org.boxes.detect { |b| b.name == box }
+        if !b
+          @env.ui.error(I18n.t("cloud_command.box.not_found",
+            org: org.username, box_name: box))
+          return 1
+        end
+        yield b
+      end
 
-            results["old_versions"] = versions.map{ |v| v["version"] }[1..5].join(", ") + "..."
+      # Load box version and yield
+      #
+      # @param [VagrantCloud::Account] account Vagrant Cloud account
+      # @param [String] org Organization name
+      # @param [String] box Box name
+      # @param [String] version Box version
+      # @yieldparam [VagrantCloud::Box::Version] version Requested Vagrant Cloud box version
+      # @yieldreturn [Integer]
+      # @return [Integer]
+      def with_version(account:, org:, box:, version:)
+        with_box(account: account, org: org, box: box) do |b|
+          v = b.versions.detect { |v| v.version == version }
+          if !v
+            @env.ui.error(I18n.t("cloud_command.version.not_found",
+              box_name: box, org: org, version: version))
+            return 1
           end
+          yield v
+        end
+      end
 
+      # Load box version and yield
+      #
+      # @param [VagrantCloud::Account] account Vagrant Cloud account
+      # @param [String] org Organization name
+      # @param [String] box Box name
+      # @param [String] version Box version
+      # @param [String] provider Box version provider name
+      # @yieldparam [VagrantCloud::Box::Provider] provider Requested Vagrant Cloud box version provider
+      # @yieldreturn [Integer]
+      # @return [Integer]
+      def with_provider(account:, org:, box:, version:, provider:)
+        with_version(account: account, org: org, box: box, version: version) do |v|
+          p = v.providers.detect { |p| p.name == provider }
+          if !p
+            @env.ui.error(I18n.t("cloud_command.provider.not_found",
+              org: org, box_name: box, version: version, provider_name: provider))
+            return 1
+          end
+          yield p
+        end
+      end
 
-          width = results.keys.map{|k| k.size}.max
-          results.each do |k,v|
-            if k == "versions"
-              v = v.map{ |ver| ver["version"] }.join(", ")
-            elsif k == "current_version"
-              v = v["version"]
-            elsif k == "providers"
-              v = v.map{ |p| p["name"] }.join(", ")
-            elsif k == "downloads"
-              v = format_downloads(v.to_s)
-            end
+      protected
 
-            whitespace = width-k.size
-            env.ui.info "#{k}:" + "".ljust(whitespace) + " #{v}"
+      # Extract box information for display
+      #
+      # @param [VagrantCloud::Box] box Box for extracting information
+      # @return [Hash<String,String>]
+      def box_info(box)
+        Hash.new.tap do |i|
+          i["Box"] = box.tag
+          i["Description"] = box.description
+          i["Private"] = box.private ? "yes" : "no"
+          i["Created"] = box.created_at
+          i["Updated"] = box.updated_at
+          if !box.current_version.nil?
+            i["Current Version"] = box.current_version.version
+          else
+            i["Current Version"] = "N/A"
+          end
+          i["Versions"] = box.versions.slice(0, 5).map(&:version).join(", ")
+          if box.versions.size > 5
+            i["Versions"] += " ..."
           end
+          i["Downloads"] = format_downloads(box.downloads)
+        end
+      end
+
+      # Extract version information for display
+      #
+      # @param [VagrantCloud::Box::Version] version Box version for extracting information
+      # @return [Hash<String,String>]
+      def version_info(version)
+        Hash.new.tap do |i|
+          i["Box"] = version.box.tag
+          i["Version"] = version.version
+          i["Description"] = version.description
+          i["Status"] = version.status
+          i["Providers"] = version.providers.map(&:name).sort.join(", ")
+          i["Created"] = version.created_at
+          i["Updated"] = version.updated_at
         end
+      end
 
-        # Converts a string of numbers into a formatted number
-        #
-        # 1234 -> 1,234
-        #
-        # @param [String] - download_string
-        def format_downloads(download_string)
-          return download_string.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
+      # Print table results from search request
+      #
+      # @param [Vagrant::Environment] env Current Vagrant environment
+      # @param [Hash] column_labels A hash of key/value pairs for table labels (i.e. {col1: "COL1"})
+      # @param [Array] results An array of hashes representing search resuls
+      # @param [Array] to_jrust_keys - List of columns keys to right justify (left justify is defualt)
+      # @return [nil]
+      # @note Modified from https://stackoverflow.com/a/28685559
+      def print_search_table(env, column_labels, results, to_rjust_keys)
+        columns = column_labels.each_with_object({}) do |(col,label),h|
+          h[col] = {
+            label: label,
+            width: [results.map { |g| g[col].size }.max, label.size].max
+          }
         end
 
+        write_header(env, columns)
+        write_divider(env, columns)
+        results.each { |h| write_line(env, columns, h, to_rjust_keys) }
+        write_divider(env, columns)
+      end
 
-        # @param [Array] search_results - Box search results from Vagrant Cloud
-        # @param [String,nil] short - determines if short version will be printed
-        # @param [String,nil] json - determines if json version will be printed
-        # @param [Vagrant::Environment] - env
-        def format_search_results(search_results, short, json, env)
-          result = []
-          search_results.each do |b|
-            box = {}
-            box = {
-              name: b["tag"],
-              version: b["current_version"]["version"],
-              downloads: format_downloads(b["downloads"].to_s),
-              providers: b["current_version"]["providers"].map{ |p| p["name"] }.join(",")
-            }
-            result << box
-          end
+      # Write the header for a table
+      #
+      # @param [Vagrant::Environment] env Current Vagrant environment
+      # @param [Array<Hash>] columns List of columns in Hash format with `:label` and `:width` keys
+      # @return [nil]
+      def write_header(env, columns)
+        env.ui.info "| #{ columns.map { |_,g| g[:label].ljust(g[:width]) }.join(' | ') } |"
+        nil
+      end
 
-          if short
-            result.map {|b| env.ui.info(b[:name])}
-          elsif json
-            env.ui.info(result.to_json)
+      # Write a row divider for a table
+      #
+      # @param [Vagrant::Environment] env Current Vagrant environment
+      # @param [Array<Hash>] columns List of columns in Hash format with `:label` and `:width` keys
+      # @return [nil]
+      def write_divider(env, columns)
+        env.ui.info "+-#{ columns.map { |_,g| "-"*g[:width] }.join("-+-") }-+"
+        nil
+      end
+
+      # Write a line of content for a table
+      #
+      # @param [Vagrant::Environment] env Current Vagrant environment
+      # @param [Array<Hash>] columns List of columns in Hash format with `:label` and `:width` keys
+      # @param [Hash] h Values to print in row
+      # @param [Array<String>] to_rjust_keys List of columns to right justify
+      # @return [nil]
+      def write_line(env, columns, h, to_rjust_keys)
+        str = h.keys.map { |k|
+          if to_rjust_keys.include?(k)
+            h[k].rjust(columns[k][:width])
           else
-            column_labels = {}
-            columns = result.first.keys
-            columns.each do |c|
-              column_labels[c] = c.to_s.upcase
-            end
-            print_search_table(env, column_labels, result, [:downloads])
+            h[k].ljust(columns[k][:width])
           end
-        end
+        }.join(" | ")
+        env.ui.info "| #{str} |"
+        nil
+      end
+
+      # Converts a string of numbers into a formatted number
+      #
+      # 1234 -> 1,234
+      #
+      # @param [String] number Numer to format
+      def format_downloads(number)
+        number.to_s.chars.reverse.each_slice(3).map(&:join).join(",").reverse
       end
     end
   end