class Bundler::Thor::Shell::Basic
def answer_match(possibilities, answer, case_insensitive)
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
def as_unicode
def as_unicode yield end
def as_unicode
def as_unicode old = $KCODE $KCODE = "U" yield ensure $KCODE = old end
def ask(statement, *args)
ask("Where should the file be saved?", :path => true)
ask("What is your password?", :echo => false)
ask("What is your favorite Neopolitan flavor?", :limited_to => ["strawberry", "chocolate", "vanilla"])
ask("What is the planet furthest from the sun?", :default => "Pluto")
ask("What is your name?")
==== Example
Readline.
to the current working directory on systems that support
true. This will enable tab completion for file paths relative
If the required input is a path, then set the path option to
to false to mask user input from $stdin.
If asking for sensitive information, the :echo option can be set
must be given and re-asked the question.
they will be shown a message stating that one of those answers
array of acceptable answers. If one of those is not supplied,
If asked to limit the correct responses, you can pass in an
option is ignored when limited answers are supplied.
and allows them to select that value with an empty response. This
If a default value is specified it will be presented to the user
Asks something to the user and receives a response.
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
def ask_filtered(statement, color, options)
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
def ask_simply(statement, color, options)
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
def can_display_colors?
def can_display_colors? false end
def dynamic_width
def dynamic_width @dynamic_width ||= (dynamic_width_stty.nonzero? || dynamic_width_tput) end
def dynamic_width_stty
def dynamic_width_stty `stty size 2>/dev/null`.split[1].to_i end
def dynamic_width_tput
def dynamic_width_tput `tput cols 2>/dev/null`.to_i end
def error(statement)
will be rescued and wrapped in the method below.
wrong, you can always raise an exception. If you raise a Bundler::Thor::Error, it
internally and should not be used inside your scripts. If something went
Called if something goes wrong during the execution. This is used by Bundler::Thor
def error(statement) stderr.puts statement end
def file_collision(destination)
block
destination
==== Parameters
response as the content for the diff.
overwritten and false otherwise. If a block is given, it uses the block
Deals with file collision and returns true if the file should be
def file_collision(destination) return true if @always_force options = block_given? ? "[Ynaqdhm]" : "[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..." 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
def file_collision_help #:nodoc:
def file_collision_help #:nodoc: <<-HELP Y - yes, overwrite n - no, do not overwrite a - all, overwrite this and all others q - quit, abort d - diff, show the differences between the old and the new h - help, show this help m - merge, run merge tool HELP end
def git_merge_tool #:nodoc:
def git_merge_tool #:nodoc: `git config merge.tool`.rstrip rescue "" end
def indent(count = 1)
Sets the output padding while executing a block and resets it.
def indent(count = 1) orig_padding = padding self.padding = padding + count yield self.padding = orig_padding end
def initialize #:nodoc:
Initialize base, mute and padding to nil.
def initialize #:nodoc: @base = nil @mute = false @padding = 0 @always_force = false end
def is?(value) #:nodoc:
def is?(value) #:nodoc: value = value.to_s if value.size == 1 /\A#{value}\z/i else /\A(#{value}|#{value[0, 1]})\z/i end end
def lookup_color(color)
def lookup_color(color) return color unless color.is_a?(Symbol) self.class.const_get(color.to_s.upcase) end
def merge(destination, content) #:nodoc:
def merge(destination, content) #:nodoc: require "tempfile" Tempfile.open([File.basename(destination), File.extname(destination)], File.dirname(destination)) do |temp| temp.write content temp.rewind system %(#{merge_tool} "#{temp.path}" "#{destination}") end end
def merge_tool #:nodoc:
def merge_tool #:nodoc: @merge_tool ||= ENV["THOR_MERGE"] || git_merge_tool end
def mute
Mute everything that's inside given block
def mute @mute = true yield ensure @mute = false end
def mute?
Check if base is muted
def mute? @mute end
def no?(statement, color = nil)
"no".
Make a question the to user and returns true if the user replies "n" or
def no?(statement, color = nil) !!(ask(statement, color, :add_to_history => false) =~ is?(:no)) end
def padding=(value)
Sets the output padding, not allowing less than zero values.
def padding=(value) @padding = [0, value].max end
def prepare_message(message, *color)
def prepare_message(message, *color) spaces = " " * padding spaces + set_color(message.to_s, *color) end
def print_in_columns(array)
Array[String, String, ...]
==== Parameters
Prints values in columns
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
def print_table(array, options = {}) # rubocop:disable MethodLength
colwidth
indent
==== Options
Array[Array[String, String, ...]]
==== Parameters
Prints a table.
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
def print_wrapped(message, options = {})
indent
==== Options
String
==== Parameters
terminal display. Ideal for printing heredocs.
Prints a long string, word-wrapping the text to the current width of the
def print_wrapped(message, options = {}) indent = options[:indent] || 0 width = terminal_width - indent paras = message.split("\n\n") paras.map! do |unwrapped| words = unwrapped.split(" ") counter = words.first.length words.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
def quiet? #:nodoc:
def quiet? #:nodoc: mute? || (base && base.options[:quiet]) end
def say(message = "", color = nil, force_new_line = (message.to_s !~ /( |\t)\Z/))
say("I know you knew that.")
==== Example
are passed straight to puts (behavior got from Highline).
or tab character, a new line is not appended (print + flush). Otherwise
Say (print) something to the user. If the sentence ends with a whitespace
def say(message = "", color = nil, force_new_line = (message.to_s !~ /( |\t)\Z/)) return if quiet? buffer = prepare_message(message, *color) buffer << "\n" if force_new_line && !message.to_s.end_with?("\n") stdout.print(buffer) stdout.flush end
def say_error(message = "", color = nil, force_new_line = (message.to_s !~ /( |\t)\Z/))
say_error("error: something went wrong")
==== Example
are passed straight to puts (behavior got from Highline).
or tab character, a new line is not appended (print + flush). Otherwise
Say (print) an error to the user. If the sentence ends with a whitespace
def say_error(message = "", color = nil, force_new_line = (message.to_s !~ /( |\t)\Z/)) return if quiet? buffer = prepare_message(message, *color) buffer << "\n" if force_new_line && !message.to_s.end_with?("\n") stderr.print(buffer) stderr.flush end
def say_status(status, message, log_status = true)
given in log_status, it's used as the color.
in log_status, avoiding the message from being shown. If a Symbol is
method is used frequently by actions, it allows nil or false to be given
Say a status with the given color and appends the message. Since this
def say_status(status, message, log_status = true) return if quiet? || log_status == false spaces = " " * (padding + 1) status = status.to_s.rjust(12) margin = " " * status.length + spaces color = log_status.is_a?(Symbol) ? log_status : :green status = set_color status, color, true if color message = message.to_s.chomp.gsub(/(?<!\A)^/, margin) buffer = "#{status}#{spaces}#{message}\n" stdout.print(buffer) stdout.flush end
def set_color(string, *) #:nodoc:
Bundler::Thor::Shell::Basic class.
Apply color to the given string with optional bold. Disabled in the
def set_color(string, *) #:nodoc: string end
def show_diff(destination, content) #:nodoc:
def show_diff(destination, content) #:nodoc: diff_cmd = ENV["THOR_DIFF"] || ENV["RAILS_DIFF"] || "diff -u" require "tempfile" Tempfile.open(File.basename(destination), File.dirname(destination)) do |temp| temp.write content temp.rewind system %(#{diff_cmd} "#{destination}" "#{temp.path}") end end
def stderr
def stderr $stderr end
def stdout
def stdout $stdout end
def terminal_width
This code was copied from Rake, available under MIT-LICENSE
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
def truncate(string, width)
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
def unix?
def unix? RUBY_PLATFORM =~ /(aix|darwin|linux|(net|free|open)bsd|cygwin|solaris|irix|hpux)/i end
def yes?(statement, color = nil)
"yes".
Make a question the to user and returns true if the user replies "y" or
def yes?(statement, color = nil) !!(ask(statement, color, :add_to_history => false) =~ is?(:yes)) end