Class: Bundler::Thor::Shell::Basic (Ruby 2.7.2)
Description: Class : Bundler::Thor::Shell::Basic - Ruby 2.7.2

### Home Classes Methods

### In Files

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

### Parent

Object

### Methods

- #answer_match
- #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

- AmbiguousCommandError
- AmbiguousTaskError
- 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::Config::Base
- 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::ConnectionPool
- Bundler::ConnectionPool::Error
- Bundler::ConnectionPool::PoolShuttingDownError
- Bundler::ConnectionPool::Process
- Bundler::ConnectionPool::TimedStack
- Bundler::ConnectionPool::Wrapper
- 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::Fetcher::TooManyRequestsError
- Bundler::FileUtils
- Bundler::FileUtils::DryRun
- Bundler::FileUtils::Entry_
- Bundler::FileUtils::Entry_::File
- Bundler::FileUtils::NoWrite
- Bundler::FileUtils::StreamUtils_
- Bundler::FileUtils::StreamUtils_::RbConfig
- Bundler::FileUtils::Verbose
- Bundler::FriendlyErrors
- Bundler::GemHelper
- Bundler::GemHelper::Rake
- 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::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::Psych
- Bundler::RemoteSpecification
- Bundler::Resolver
- Bundler::Resolver::SpecGroup
- Bundler::Retry
- Bundler::RubyDsl
- Bundler::RubyGemsGemInstaller
- Bundler::RubyVersion
- Bundler::RubyVersionMismatch
- Bundler::RubygemsIntegration
- Bundler::RubygemsIntegration::Gem
- 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::Actions
- Bundler::Thor::Actions::CapturableERB
- Bundler::Thor::Actions::ClassMethods
- Bundler::Thor::Base
- Bundler::Thor::Base::ClassMethods
- Bundler::Thor::Command
- Bundler::Thor::CoreExt
- Bundler::Thor::CoreExt::OrderedHash
- Bundler::Thor::DidYouMean
- Bundler::Thor::DynamicCommand
- Bundler::Thor::DynamicTask
- Bundler::Thor::Group
- Bundler::Thor::HiddenCommand
- Bundler::Thor::HiddenTask
- Bundler::Thor::Invocation
- Bundler::Thor::Invocation::ClassMethods
- Bundler::Thor::LineEditor
- Bundler::Thor::LineEditor::Basic
- Bundler::Thor::LineEditor::Readline
- Bundler::Thor::LineEditor::Readline::PathCompletion
- Bundler::Thor::NestedContext
- Bundler::Thor::RakeCompat
- Bundler::Thor::RakeCompat::Rake
- Bundler::Thor::Shell
- Bundler::Thor::Shell::Basic
- Bundler::Thor::Shell::Color
- Bundler::Thor::Shell::HTML
- Bundler::Thor::Task
- Bundler::Thor::Util
- Bundler::ThreadCreationError
- Bundler::UI
- Bundler::UI::RGProxy
- Bundler::UI::Shell
- Bundler::UI::Silent
- Bundler::URI
- Bundler::URI::BadURIError
- Bundler::URI::Error
- Bundler::URI::Escape
- Bundler::URI::FTP
- Bundler::URI::File
- Bundler::URI::Generic
- Bundler::URI::HTTP
- Bundler::URI::HTTPS
- Bundler::URI::InvalidComponentError
- Bundler::URI::InvalidURIError
- Bundler::URI::LDAP
- Bundler::URI::LDAPS
- Bundler::URI::MailTo
- Bundler::URI::REGEXP
- Bundler::URI::RFC2396_Parser
- Bundler::URI::RFC2396_REGEXP
- Bundler::URI::RFC2396_REGEXP::PATTERN
- Bundler::URICredentialsFilter
- Bundler::VersionConflict
- Bundler::VersionRanges
- Bundler::VersionRanges::ReqR
- Bundler::VirtualProtocolError
- Bundler::Worker
- Bundler::Worker::WrappedException
- Bundler::YAMLSerializer
- Bundler::YamlSyntaxError
- Capistrano
- DidYouMean
- Error
- Gem
- Gem::Dependency
- Gem::Ext
- Gem::Ext::Builder
- Gem::Platform
- Gem::Specification
- InvocationError
- Kernel
- MalformattedArgumentError
- Object
- Rake
- RequiredArgumentMissingError
- UndefinedCommandError
- UndefinedCommandError::SpellChecker
- UndefinedTaskError
- UnknownArgumentError
- UnknownArgumentError::SpellChecker

No matching classes.

# Bundler::Thor::Shell::Basic

### Constants

DEFAULT_TERMINAL_WIDTH

### 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 a default value is specified it will be presented to the user and allows them to select that value with an empty response. This option is ignored when limited answers are supplied.

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 the planet furthest from the sun?”, :default => “Pluto”)

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 bundler/vendor/thor/lib/thor/shell/basic.rb, line 78
    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 bundler/vendor/thor/lib/thor/shell/basic.rb, line 321
    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 and merge

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

      loop do
        answer = ask(
          %Q[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..."
        when is?(:merge)
          if block_given? && !merge_tool.empty?
            merge(destination, yield)
            return nil
          end

          say "Please specify merge tool to `THOR_MERGE` env."
        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 bundler/vendor/thor/lib/thor/shell/basic.rb, line 41
    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 bundler/vendor/thor/lib/thor/shell/basic.rb, line 20
    def mute
      @mute = true
      yield
    ensure
      @mute = false
    end

mute?() click to toggle source

Check if base is muted

                   # File bundler/vendor/thor/lib/thor/shell/basic.rb, line 29
    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 bundler/vendor/thor/lib/thor/shell/basic.rb, line 134
    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 bundler/vendor/thor/lib/thor/shell/basic.rb, line 35
    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 bundler/vendor/thor/lib/thor/shell/basic.rb, line 143
    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 bundler/vendor/thor/lib/thor/shell/basic.rb, line 165
    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 bundler/vendor/thor/lib/thor/shell/basic.rb, line 227
    def print_wrapped(message, options = {})
      indent = options[:indent] || 0
      width = terminal_width - indent
      paras = message.split("\n\n")

      paras.map! do |unwrapped|
        counter = 0
        unwrapped.split(" ").inject do |memo, word|
          word = word.gsub(/\n\005/, "\n").gsub(/\005/, "\n")
          counter = 0 if word.include? "\n"
          if (counter + word.length + 1) < width
            memo = "#{memo} #{word}"
            counter += (word.length + 1)
          else
            memo = "#{memo}\n#{word}"
            counter = word.length
          end
          memo
        end
      end.compact!

      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 bundler/vendor/thor/lib/thor/shell/basic.rb, line 96
    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 bundler/vendor/thor/lib/thor/shell/basic.rb, line 109
    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 bundler/vendor/thor/lib/thor/shell/basic.rb, line 305
    def terminal_width
      result = if ENV["THOR_COLUMNS"]
        ENV["THOR_COLUMNS"].to_i
      else
        unix? ? dynamic_width : DEFAULT_TERMINAL_WIDTH
      end
      result < 10 ? DEFAULT_TERMINAL_WIDTH : result
    rescue
      DEFAULT_TERMINAL_WIDTH
    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 bundler/vendor/thor/lib/thor/shell/basic.rb, line 127
    def yes?(statement, color = nil)
      !!(ask(statement, color, :add_to_history => false) =~ is?(:yes))
    end

### Protected Instance Methods

answer_match(possibilities, answer, case_insensitive) click to toggle source

                   # File bundler/vendor/thor/lib/thor/shell/basic.rb, line 465
    def answer_match(possibilities, answer, case_insensitive)
      if case_insensitive
        possibilities.detect{ |possibility| possibility.downcase == answer.downcase }
      else
        possibilities.detect{ |possibility| possibility == answer }
      end
    end

as_unicode() click to toggle source

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

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

                   # File bundler/vendor/thor/lib/thor/shell/basic.rb, line 452
    def ask_filtered(statement, color, options)
      answer_set = options[:limited_to]
      case_insensitive = options.fetch(:case_insensitive, false)
      correct_answer = nil
      until correct_answer
        answers = answer_set.join(", ")
        answer = ask_simply("#{statement} [#{answers}]", color, options)
        correct_answer = answer_match(answer_set, answer, case_insensitive)
        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 bundler/vendor/thor/lib/thor/shell/basic.rb, line 435
    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 bundler/vendor/thor/lib/thor/shell/basic.rb, line 339
    def can_display_colors?
      false
    end

dynamic_width() click to toggle source

Calculate the dynamic width of the terminal

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

dynamic_width_stty() click to toggle source

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

dynamic_width_tput() click to toggle source

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

lookup_color(color) click to toggle source

                   # File bundler/vendor/thor/lib/thor/shell/basic.rb, line 343
    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 bundler/vendor/thor/lib/thor/shell/basic.rb, line 334
    def prepare_message(message, *color)
      spaces = "  " * padding
      spaces + set_color(message.to_s, *color)
    end

stderr() click to toggle source

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

stdout() click to toggle source

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

truncate(string, width) click to toggle source

                   # File bundler/vendor/thor/lib/thor/shell/basic.rb, line 410
    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 bundler/vendor/thor/lib/thor/shell/basic.rb, line 406
    def unix?
      RUBY_PLATFORM =~ /(aix|darwin|linux|(net|free|open)bsd|cygwin|solaris|irix|hpux)/i
    end