### Home Classes Methods

### In Files

- lib/bundler/vendor/thor/lib/thor/shell/basic.rb

### Parent

Object

### Methods

- #as_unicode
- #ask
- #ask_filtered
- #ask_simply
- #can_display_colors?
- #dynamic_width
- #dynamic_width_stty
- #dynamic_width_tput
- #error
- #file_collision
- #indent
- #lookup_color
- #mute
- #mute?
- #no?
- #padding=
- #prepare_message
- #print_in_columns
- #print_table
- #print_wrapped
- #say
- #say_status
- #stderr
- #stdout
- #terminal_width
- #truncate
- #unix?
- #yes?

### Class/Module Index

Quicksearch

- Bundler
- Bundler::APIResponseMismatchError
- Bundler::BuildMetadata
- Bundler::BundlerError
- Bundler::CLI
- Bundler::CLI::Add
- Bundler::CLI::Binstubs
- Bundler::CLI::Cache
- Bundler::CLI::Check
- Bundler::CLI::Clean
- Bundler::CLI::Common
- Bundler::CLI::Config
- Bundler::CLI::Console
- Bundler::CLI::Doctor
- Bundler::CLI::Exec
- Bundler::CLI::Gem
- Bundler::CLI::Info
- Bundler::CLI::Init
- Bundler::CLI::Inject
- Bundler::CLI::Install
- Bundler::CLI::Issue
- Bundler::CLI::List
- Bundler::CLI::Lock
- Bundler::CLI::Open
- Bundler::CLI::Outdated
- Bundler::CLI::Package
- Bundler::CLI::Platform
- Bundler::CLI::Plugin
- Bundler::CLI::Pristine
- Bundler::CLI::Remove
- Bundler::CLI::Show
- Bundler::CLI::Update
- Bundler::CLI::Viz
- Bundler::CompactIndexClient
- Bundler::CompactIndexClient::Cache
- Bundler::CompactIndexClient::Error
- Bundler::CompactIndexClient::Updater
- Bundler::CompactIndexClient::Updater::MisMatchedChecksumError
- Bundler::CurrentRuby
- Bundler::CyclicDependencyError
- Bundler::Definition
- Bundler::DepProxy
- Bundler::Dependency
- Bundler::Deployment
- Bundler::Deprecate
- Bundler::DeprecatedError
- Bundler::Dsl
- Bundler::Dsl::DSLError
- Bundler::EndpointSpecification
- Bundler::Env
- Bundler::EnvironmentPreserver
- Bundler::FeatureFlag
- Bundler::Fetcher
- Bundler::Fetcher::AuthenticationRequiredError
- Bundler::Fetcher::BadAuthenticationError
- Bundler::Fetcher::Base
- Bundler::Fetcher::CertificateFailureError
- Bundler::Fetcher::CompactIndex
- Bundler::Fetcher::Dependency
- Bundler::Fetcher::Downloader
- Bundler::Fetcher::FallbackError
- Bundler::Fetcher::Index
- Bundler::Fetcher::NetworkDownError
- Bundler::Fetcher::SSLError
- Bundler::FileUtils
- Bundler::FileUtils::DryRun
- Bundler::FileUtils::LowMethods
- Bundler::FileUtils::NoWrite
- Bundler::FileUtils::StreamUtils_
- Bundler::FileUtils::Verbose
- Bundler::FriendlyErrors
- Bundler::GemHelper
- Bundler::GemHelpers
- Bundler::GemHelpers::PlatformMatch
- Bundler::GemInstaller
- Bundler::GemNotFound
- Bundler::GemRemoteFetcher
- Bundler::GemRequireError
- Bundler::GemVersionPromoter
- Bundler::Gemdeps
- Bundler::GemfileError
- Bundler::GemfileEvalError
- Bundler::GemfileLockNotFound
- Bundler::GemfileNotFound
- Bundler::GemspecError
- Bundler::GenericSystemCallError
- Bundler::GitError
- Bundler::Graph
- Bundler::Graph::GraphVizClient
- Bundler::HTTPError
- Bundler::Index
- Bundler::Injector
- Bundler::InstallError
- Bundler::InstallHookError
- Bundler::Installer
- Bundler::InvalidOption
- Bundler::LazySpecification
- Bundler::LazySpecification::Identifier
- Bundler::LockfileError
- Bundler::LockfileGenerator
- Bundler::LockfileParser
- Bundler::MarshalError
- Bundler::MatchPlatform
- Bundler::MirrorSockets
- Bundler::Molinillo
- Bundler::Molinillo::CircularDependencyError
- Bundler::Molinillo::Compatibility
- Bundler::Molinillo::Delegates
- Bundler::Molinillo::Delegates::ResolutionState
- Bundler::Molinillo::Delegates::SpecificationProvider
- Bundler::Molinillo::DependencyGraph
- Bundler::Molinillo::DependencyGraph::Action
- Bundler::Molinillo::DependencyGraph::AddEdgeNoCircular
- Bundler::Molinillo::DependencyGraph::DeleteEdge
- Bundler::Molinillo::DependencyGraph::DetachVertexNamed
- Bundler::Molinillo::DependencyGraph::Log
- Bundler::Molinillo::DependencyGraph::Tag
- Bundler::Molinillo::DependencyGraph::Vertex
- Bundler::Molinillo::DependencyState
- Bundler::Molinillo::NoSuchDependencyError
- Bundler::Molinillo::PossibilityState
- Bundler::Molinillo::ResolutionState
- Bundler::Molinillo::Resolver
- Bundler::Molinillo::Resolver::Resolution
- Bundler::Molinillo::Resolver::Resolution::Conflict
- Bundler::Molinillo::Resolver::Resolution::PossibilitySet
- Bundler::Molinillo::Resolver::Resolution::UnwindDetails
- Bundler::Molinillo::ResolverError
- Bundler::Molinillo::SpecificationProvider
- Bundler::Molinillo::UI
- Bundler::Molinillo::VersionConflict
- Bundler::NoSpaceOnDeviceError
- Bundler::OperationNotSupportedError
- Bundler::ParallelInstaller
- Bundler::ParallelInstaller::SpecInstallation
- Bundler::PathError
- Bundler::PermissionError
- Bundler::Persistent
- Bundler::Persistent::Net
- Bundler::Persistent::Net::HTTP
- Bundler::Persistent::Net::HTTP::Persistent
- Bundler::Persistent::Net::HTTP::Persistent::Error
- Bundler::Persistent::Net::HTTP::Persistent::SSLReuse
- Bundler::PersistentHTTP
- Bundler::Plugin
- Bundler::Plugin::API
- Bundler::Plugin::API::Source
- Bundler::Plugin::DSL
- Bundler::Plugin::DSL::PluginGemfileError
- Bundler::Plugin::Events
- Bundler::Plugin::Index
- Bundler::Plugin::Index::CommandConflict
- Bundler::Plugin::Index::SourceConflict
- Bundler::Plugin::Installer
- Bundler::Plugin::Installer::Git
- Bundler::Plugin::Installer::Rubygems
- Bundler::Plugin::MalformattedPlugin
- Bundler::Plugin::SourceList
- Bundler::Plugin::UndefinedCommandError
- Bundler::Plugin::UnknownSourceError
- Bundler::PluginError
- Bundler::ProcessLock
- Bundler::ProductionError
- Bundler::RemoteSpecification
- Bundler::Resolver
- Bundler::Resolver::SpecGroup
- Bundler::Retry
- Bundler::RubyDsl
- Bundler::RubyGemsGemInstaller
- Bundler::RubyVersion
- Bundler::RubyVersionMismatch
- Bundler::RubygemsIntegration
- Bundler::RubygemsIntegration::::Kernel
- Bundler::RubygemsIntegration::AlmostModern
- Bundler::RubygemsIntegration::Ancient
- Bundler::RubygemsIntegration::Future
- Bundler::RubygemsIntegration::Future::Gem
- Bundler::RubygemsIntegration::Gem
- Bundler::RubygemsIntegration::Legacy
- Bundler::RubygemsIntegration::Legacy::Gem::SourceIndex
- Bundler::RubygemsIntegration::Modern
- Bundler::RubygemsIntegration::MoreFuture
- Bundler::RubygemsIntegration::MoreModern
- Bundler::RubygemsIntegration::Transitional
- Bundler::Runtime
- Bundler::SecurityError
- Bundler::Settings
- Bundler::Settings::Mirror
- Bundler::Settings::MirrorConfig
- Bundler::Settings::Mirrors
- Bundler::Settings::TCPSocketProbe
- Bundler::Settings::Validator
- Bundler::Settings::Validator::Rule
- Bundler::SharedHelpers
- Bundler::SimilarityDetector
- Bundler::SocketAddress
- Bundler::Source
- Bundler::Source::Gemspec
- Bundler::Source::Git
- Bundler::Source::Git::GitCommandError
- Bundler::Source::Git::GitNotAllowedError
- Bundler::Source::Git::GitNotInstalledError
- Bundler::Source::Git::GitProxy
- Bundler::Source::Git::MissingGitRevisionError
- Bundler::Source::Metadata
- Bundler::Source::Path
- Bundler::Source::Path::Installer
- Bundler::Source::Rubygems
- Bundler::Source::Rubygems::Remote
- Bundler::SourceList
- Bundler::SpecSet
- Bundler::Standalone
- Bundler::StubSpecification
- Bundler::SudoNotPermittedError
- Bundler::TemporaryResourceError
- Bundler::Thor
- Bundler::Thor::Actions
- Bundler::Thor::Actions::CapturableERB
- Bundler::Thor::Actions::ClassMethods
- Bundler::Thor::AmbiguousCommandError
- Bundler::Thor::AmbiguousTaskError
- Bundler::Thor::Base
- Bundler::Thor::Base::ClassMethods
- Bundler::Thor::Command
- Bundler::Thor::CoreExt
- Bundler::Thor::CoreExt::OrderedHash
- Bundler::Thor::DynamicCommand
- Bundler::Thor::DynamicTask
- Bundler::Thor::Error
- Bundler::Thor::Group
- Bundler::Thor::HiddenCommand
- Bundler::Thor::HiddenTask
- Bundler::Thor::Invocation
- Bundler::Thor::Invocation::ClassMethods
- Bundler::Thor::InvocationError
- Bundler::Thor::LineEditor
- Bundler::Thor::LineEditor::Basic
- Bundler::Thor::LineEditor::Readline
- Bundler::Thor::LineEditor::Readline::PathCompletion
- Bundler::Thor::MalformattedArgumentError
- Bundler::Thor::RakeCompat
- Bundler::Thor::RequiredArgumentMissingError
- Bundler::Thor::Shell
- Bundler::Thor::Shell::Basic
- Bundler::Thor::Shell::Color
- Bundler::Thor::Shell::HTML
- Bundler::Thor::Task
- Bundler::Thor::UndefinedCommandError
- Bundler::Thor::UndefinedTaskError
- Bundler::Thor::UnknownArgumentError
- Bundler::Thor::Util
- Bundler::ThreadCreationError
- Bundler::UI
- Bundler::UI::RGProxy
- Bundler::UI::Shell
- Bundler::UI::Silent
- Bundler::URICredentialsFilter
- Bundler::VersionConflict
- Bundler::VersionRanges
- Bundler::VersionRanges::ReqR
- Bundler::VirtualProtocolError
- Bundler::Worker
- Bundler::Worker::WrappedException
- Bundler::YAMLSerializer
- Bundler::YamlSyntaxError
- Gem
- Gem::Dependency
- Gem::Platform
- Gem::Requirement
- Gem::Specification
- Net
- Object

No matching classes.

# Bundler::Thor::Shell::Basic

### Attributes

base[RW]
padding[R]

### Public Instance Methods

ask(statement, *args) click to toggle source

Asks something to the user and receives a response.

If asked to limit the correct responses, you can pass in an array of acceptable answers. If one of those is not supplied, they will be shown a message stating that one of those answers must be given and re-asked the question.

If asking for sensitive information, the :echo option can be set to false to mask user input from $stdin.

If the required input is a path, then set the path option to true. This will enable tab completion for file paths relative to the current working directory on systems that support Readline.

#### Example

ask(“What is your name?”)

ask(“What is your favorite Neopolitan flavor?”, :limited_to => [“strawberry”, “chocolate”, “vanilla”])

ask(“What is your password?”, :echo => false)

ask(“Where should the file be saved?”, :path => true)

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 70
    def ask(statement, *args)
      options = args.last.is_a?(Hash) ? args.pop : {}
      color = args.first

      if options[:limited_to]
        ask_filtered(statement, color, options)
      else
        ask_simply(statement, color, options)
      end
    end

error(statement) click to toggle source

Called if something goes wrong during the execution. This is used by Bundler::Thor internally and should not be used inside your scripts. If something went wrong, you can always raise an exception. If you raise a Bundler::Thor::Error, it will be rescued and wrapped in the method below.

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 294
    def error(statement)
      stderr.puts statement
    end

file_collision(destination) click to toggle source

Deals with file collision and returns true if the file should be overwritten and false otherwise. If a block is given, it uses the block response as the content for the diff.

#### Parameters

destination<String> | the destination file to solve conflicts
block<Proc> | an optional block that returns the value to be used in diff

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 244
    def file_collision(destination)
      return true if @always_force
      options = block_given? ? "[Ynaqdh]" : "[Ynaqh]"

      loop do
        answer = ask(
          %[Overwrite #{destination}? (enter "h" for help) #{options}],
          :add_to_history => false
        )

        case answer
        when nil
          say ""
          return true
        when is?(:yes), is?(:force), ""
          return true
        when is?(:no), is?(:skip)
          return false
        when is?(:always)
          return @always_force = true
        when is?(:quit)
          say "Aborting..."
          raise SystemExit
        when is?(:diff)
          show_diff(destination, yield) if block_given?
          say "Retrying..."
        else
          say file_collision_help
        end
      end
    end

indent(count = 1) click to toggle source

Sets the output padding while executing a block and resets it.

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 39
    def indent(count = 1)
      orig_padding = padding
      self.padding = padding + count
      yield
      self.padding = orig_padding
    end

mute() click to toggle source

Mute everything that’s inside given block

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 18
    def mute
      @mute = true
      yield
    ensure
      @mute = false
    end

mute?() click to toggle source

Check if base is muted

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 27
    def mute?
      @mute
    end

no?(statement, color = nil) click to toggle source

Make a question the to user and returns true if the user replies “n” or “no”.

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 126
    def no?(statement, color = nil)
      !!(ask(statement, color, :add_to_history => false) =~ is?(:no))
    end

padding=(value) click to toggle source

Sets the output padding, not allowing less than zero values.

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 33
    def padding=(value)
      @padding = [0, value].max
    end

print_in_columns(array) click to toggle source

Prints values in columns

#### Parameters

Array[String, String, …]

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 135
    def print_in_columns(array)
      return if array.empty?
      colwidth = (array.map { |el| el.to_s.size }.max || 0) + 2
      array.each_with_index do |value, index|
        # Don't output trailing spaces when printing the last column
        if ((((index + 1) % (terminal_width / colwidth))).zero? && !index.zero?) || index + 1 == array.length
          stdout.puts value
        else
          stdout.printf("%-#{colwidth}s", value)
        end
      end
    end

print_table(array, options = {}) click to toggle source

Prints a table.

#### Parameters

Array[Array[String, String, …]]

#### Options

indent<Integer> | Indent the first column by indent value.
colwidth<Integer> | Force the first column to colwidth spaces wide.

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 157
    def print_table(array, options = {}) # rubocop:disable MethodLength
      return if array.empty?

      formats = []
      indent = options[:indent].to_i
      colwidth = options[:colwidth]
      options[:truncate] = terminal_width if options[:truncate] == true

      formats << "%-#{colwidth + 2}s".dup if colwidth
      start = colwidth ? 1 : 0

      colcount = array.max { |a, b| a.size <=> b.size }.size

      maximas = []

      start.upto(colcount - 1) do |index|
        maxima = array.map { |row| row[index] ? row[index].to_s.size : 0 }.max
        maximas << maxima
        formats << if index == colcount - 1
                     # Don't output 2 trailing spaces when printing the last column
                     "%-s".dup
                   else
                     "%-#{maxima + 2}s".dup
                   end
      end

      formats[0] = formats[0].insert(0, " " * indent)
      formats << "%s"

      array.each do |row|
        sentence = "".dup

        row.each_with_index do |column, index|
          maxima = maximas[index]

          f = if column.is_a?(Numeric)
            if index == row.size - 1
              # Don't output 2 trailing spaces when printing the last column
              "%#{maxima}s"
            else
              "%#{maxima}s  "
            end
          else
            formats[index]
          end
          sentence << f % column.to_s
        end

        sentence = truncate(sentence, options[:truncate]) if options[:truncate]
        stdout.puts sentence
      end
    end

print_wrapped(message, options = {}) click to toggle source

Prints a long string, word-wrapping the text to the current width of the terminal display. Ideal for printing heredocs.

#### Parameters

String

#### Options

indent<Integer> | Indent each line of the printed paragraph by indent value.

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 219
    def print_wrapped(message, options = {})
      indent = options[:indent] || 0
      width = terminal_width - indent
      paras = message.split("\n\n")

      paras.map! do |unwrapped|
        unwrapped.strip.tr("\n", " ").squeeze(" ").gsub(/.{1,#{width}}(?:\s|\Z)/) { ($& + 5.chr).gsub(/\n\0005/, "\n").gsub(/\0005/, "\n") }
      end

      paras.each do |para|
        para.split("\n").each do |line|
          stdout.puts line.insert(0, " " * indent)
        end
        stdout.puts unless para == paras.last
      end
    end

say(message = "", color = nil, force_new_line = (message.to_s !~ /( |\t)\Z/)) click to toggle source

Say (print) something to the user. If the sentence ends with a whitespace or tab character, a new line is not appended (print + flush). Otherwise are passed straight to puts (behavior got from Highline).

#### Example

say(“I know you knew that.”)

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 88
    def say(message = "", color = nil, force_new_line = (message.to_s !~ /( |\t)\Z/))
      buffer = prepare_message(message, *color)
      buffer << "\n" if force_new_line && !message.to_s.end_with?("\n")

      stdout.print(buffer)
      stdout.flush
    end

say_status(status, message, log_status = true) click to toggle source

Say a status with the given color and appends the message. Since this method is used frequently by actions, it allows nil or false to be given in log_status, avoiding the message from being shown. If a Symbol is given in log_status, it’s used as the color.

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 101
    def say_status(status, message, log_status = true)
      return if quiet? || log_status == false
      spaces = "  " * (padding + 1)
      color  = log_status.is_a?(Symbol) ? log_status : :green

      status = status.to_s.rjust(12)
      status = set_color status, color, true if color

      buffer = "#{status}#{spaces}#{message}"
      buffer = "#{buffer}\n" unless buffer.end_with?("\n")

      stdout.print(buffer)
      stdout.flush
    end

terminal_width() click to toggle source

This code was copied from Rake, available under MIT-LICENSE Copyright © 2003, 2004 Jim Weirich

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 278
    def terminal_width
      result = if ENV["THOR_COLUMNS"]
        ENV["THOR_COLUMNS"].to_i
      else
        unix? ? dynamic_width : 80
      end
      result < 10 ? 80 : result
    rescue
      80
    end

yes?(statement, color = nil) click to toggle source

Make a question the to user and returns true if the user replies “y” or “yes”.

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 119
    def yes?(statement, color = nil)
      !!(ask(statement, color, :add_to_history => false) =~ is?(:yes))
    end

### Protected Instance Methods

as_unicode() click to toggle source

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 394
    def as_unicode
      yield
    end

ask_filtered(statement, color, options) click to toggle source

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 424
    def ask_filtered(statement, color, options)
      answer_set = options[:limited_to]
      correct_answer = nil
      until correct_answer
        answers = answer_set.join(", ")
        answer = ask_simply("#{statement} [#{answers}]", color, options)
        correct_answer = answer_set.include?(answer) ? answer : nil
        say("Your response must be one of: [#{answers}]. Please try again.") unless correct_answer
      end
      correct_answer
    end

ask_simply(statement, color, options) click to toggle source

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 407
    def ask_simply(statement, color, options)
      default = options[:default]
      message = [statement, ("(#{default})" if default), nil].uniq.join(" ")
      message = prepare_message(message, *color)
      result = Bundler::Thor::LineEditor.readline(message, options)

      return unless result

      result = result.strip

      if default && result == ""
        default
      else
        result
      end
    end

can_display_colors?() click to toggle source

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 312
    def can_display_colors?
      false
    end

dynamic_width() click to toggle source

Calculate the dynamic width of the terminal

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 366
    def dynamic_width
      @dynamic_width ||= (dynamic_width_stty.nonzero? || dynamic_width_tput)
    end

dynamic_width_stty() click to toggle source

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 370
    def dynamic_width_stty
      `stty size 2>/dev/null`.split[1].to_i
    end

dynamic_width_tput() click to toggle source

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 374
    def dynamic_width_tput
      `tput cols 2>/dev/null`.to_i
    end

lookup_color(color) click to toggle source

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 316
    def lookup_color(color)
      return color unless color.is_a?(Symbol)
      self.class.const_get(color.to_s.upcase)
    end

prepare_message(message, *color) click to toggle source

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 307
    def prepare_message(message, *color)
      spaces = "  " * padding
      spaces + set_color(message.to_s, *color)
    end

stderr() click to toggle source

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 325
    def stderr
      $stderr
    end

stdout() click to toggle source

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 321
    def stdout
      $stdout
    end

truncate(string, width) click to toggle source

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 382
    def truncate(string, width)
      as_unicode do
        chars = string.chars.to_a
        if chars.length <= width
          chars.join
        else
          chars[0, width - 3].join + "..."
        end
      end
    end

unix?() click to toggle source

    # File lib/bundler/vendor/thor/lib/thor/shell/basic.rb, line 378
    def unix?
      RUBY_PLATFORM =~ /(aix|darwin|linux|(net|free|open)bsd|cygwin|solaris|irix|hpux)/
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.